Update app.py

app.py

@@ -21,6 +21,10 @@ class QuizFeedback:
     selected: Optional[str]
     correct_answer: str
 
+class QuizGenerationError(Exception):
+    """Exception raised for errors in quiz generation"""
+    pass
+
 class QuizGenerator:
     def __init__(self, api_key: str):
         self.client = Groq(api_key=api_key)
@@ -113,34 +117,26 @@ class QuizGenerator:
         )
 
 class FontManager:
-    """Manages font installation and loading for the certificate generator"""
-    
     @staticmethod
     def install_fonts():
-        """Install required fonts if they're not already present"""
         try:
-            # Install fonts package
-            subprocess.run([
-                "apt-get", "update", "-y"
-            ], check=True)
-            subprocess.run([
-                "apt-get", "install", "-y",
-                "fonts-liberation",    # Liberation Sans fonts
-                "fontconfig",          # Font configuration
-                "fonts-dejavu-core"    # DejaVu fonts as fallback
-            ], check=True)
-            
-            # Clear font cache
+            subprocess.run(["apt-get", "update", "-y"], check=True)
+            subprocess.run(
+                [
+                    "apt-get", "install", "-y",
+                    "fonts-liberation",
+                    "fontconfig",
+                    "fonts-dejavu-core"
+                ],
+                check=True
+            )
             subprocess.run(["fc-cache", "-f"], check=True)
             print("Fonts installed successfully")
-        except subprocess.CalledProcessError as e:
-            print(f"Warning: Could not install fonts: {e}")
         except Exception as e:
-            print(f"Warning: Unexpected error installing fonts: {e}")
+            print(f"Warning: Font installation error: {e}")
     
     @staticmethod
     def get_font_paths() -> Dict[str, str]:
-        """Get the paths to the required fonts with multiple fallbacks"""
         standard_paths = [
             "/usr/share/fonts",
             "/usr/local/share/fonts",
@@ -153,7 +149,6 @@ class FontManager:
             'bold': None
         }
         
-        # Common font filenames to try
         fonts_to_try = {
             'regular': [
                 'LiberationSans-Regular.ttf',
@@ -168,14 +163,12 @@ class FontManager:
         }
         
         def find_font(font_name: str) -> Optional[str]:
-            """Search for a font file in standard locations"""
             for base_path in standard_paths:
                 for root, _, files in os.walk(os.path.expanduser(base_path)):
                     if font_name in files:
                         return os.path.join(root, font_name)
             return None
         
-        # Try to find each font
         for style in ['regular', 'bold']:
             for font_name in fonts_to_try[style]:
                 font_path = find_font(font_name)
@@ -183,20 +176,19 @@ class FontManager:
                     font_paths[style] = font_path
                     break
         
-        # If no fonts found, try using fc-match as fallback
         if not all(font_paths.values()):
             try:
                 for style in ['regular', 'bold']:
                     if not font_paths[style]:
                         result = subprocess.run(
-                            ['fc-match', '-f', '%{file}', 'sans-serif:style=' + style],
+                            ['fc-match', '-f', '%{file}', f'sans-serif:style={style}'],
                             capture_output=True,
                             text=True
                         )
                         if result.returncode == 0 and result.stdout.strip():
                             font_paths[style] = result.stdout.strip()
             except Exception as e:
-                print(f"Warning: Could not use fc-match to find fonts: {e}")
+                print(f"Warning: Font matching error: {e}")
         
         return font_paths
 
@@ -211,30 +203,9 @@ class CertificateGenerator:
         self.border_color = '#4682B4'
         self.background_color = '#F0F8FF'
         
-        # Install fonts if needed
         FontManager.install_fonts()
         self.font_paths = FontManager.get_font_paths()
     
-    def _load_fonts(self) -> Dict[str, ImageFont.FreeTypeFont]:
-        """Load fonts with fallbacks"""
-        fonts = {}
-        try:
-            if self.font_paths['regular'] and self.font_paths['bold']:
-                fonts['title'] = ImageFont.truetype(self.font_paths['bold'], 60)
-                fonts['text'] = ImageFont.truetype(self.font_paths['regular'], 40)
-                fonts['subtitle'] = ImageFont.truetype(self.font_paths['regular'], 30)
-            else:
-                raise ValueError("No suitable fonts found")
-        except Exception as e:
-            print(f"Font loading error: {e}. Using default font.")
-            default = ImageFont.load_default()
-            fonts = {
-                'title': default,
-                'text': default,
-                'subtitle': default
-            }
-        return fonts
-        
     def generate(
         self,
         score: float,
@@ -243,9 +214,6 @@ class CertificateGenerator:
         company_logo: Optional[str] = None,
         participant_photo: Optional[str] = None
     ) -> str:
-        """
-        Generate a certificate with custom styling and optional logo/photo
-        """
         try:
             certificate = self._create_base_certificate()
             draw = ImageDraw.Draw(certificate)
@@ -260,42 +228,42 @@ class CertificateGenerator:
             print(f"Error generating certificate: {e}")
             return None
     
-    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]:
+        fonts = {}
         try:
-            return {
-                'title': ImageFont.truetype("arial.ttf", 60),
-                'text': ImageFont.truetype("arial.ttf", 40),
-                'subtitle': ImageFont.truetype("arial.ttf", 30)
-            }
+            if self.font_paths['regular'] and self.font_paths['bold']:
+                fonts['title'] = ImageFont.truetype(self.font_paths['bold'], 60)
+                fonts['text'] = ImageFont.truetype(self.font_paths['regular'], 40)
+                fonts['subtitle'] = ImageFont.truetype(self.font_paths['regular'], 30)
+            else:
+                raise ValueError("No suitable fonts found")
         except Exception as e:
             print(f"Font loading error: {e}. Using default font.")
             default = ImageFont.load_default()
-            return {'title': default, 'text': default, 'subtitle': default}
+            fonts = {
+                'title': default,
+                'text': default,
+                'subtitle': default
+            }
+        return fonts
+    
+    def _create_base_certificate(self) -> Image.Image:
+        return Image.new('RGB', self.certificate_size, self.background_color)
     
     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)]
         ]
@@ -311,15 +279,12 @@ class CertificateGenerator:
         course_name: str,
         score: float
     ):
-        # 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")
         
-        # Clean inputs
         name = str(name).strip() or "Participant"
         course_name = str(course_name).strip() or "Assessment"
         
-        # Main content
         content = [
             (300, "This is to certify that", 'black'),
             (380, name, self.border_color),
@@ -355,7 +320,6 @@ class CertificateGenerator:
         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):
@@ -530,16 +494,15 @@ def create_quiz_interface():
     if not os.getenv("GROQ_API_KEY"):
         raise EnvironmentError("Please set your GROQ_API_KEY environment variable")
         
-    global quiz_app  # Make quiz_app accessible to helper functions
+    global quiz_app
     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([])
         current_question_idx = gr.State(0)
-        answer_state = gr.State([None] * 5)  # Store all answers
+        answer_state = gr.State([None] * 5)
         
-        # Header
         gr.Markdown("""
         # 🎓 CertifyMe AI
         ### Transform Your Knowledge into Recognized Achievements
@@ -547,7 +510,7 @@ def create_quiz_interface():
         
         with gr.Tabs() as tabs:
             # Profile Setup Tab
-            with gr.Tab(id=1,label="📋 Step 1: Profile Setup"):
+            with gr.Tab(label="📋 Step 1: Profile Setup", id=1) as setup_tab:
                 with gr.Row():
                     name = gr.Textbox(label="Full Name", placeholder="Enter your full name")
                     email = gr.Textbox(label="Email", placeholder="Enter your email")
@@ -571,13 +534,12 @@ def create_quiz_interface():
                     participant_photo = gr.Image(label="Your Photo (Optional)", type="filepath")
                 
                 generate_btn = gr.Button("Generate Assessment", variant="primary", size="lg")
-
+            
             # Assessment Tab
-            with gr.Tab(id=2,label="📝 Step 2: Take Assessment") as assessment_tab:
+            with gr.Tab(label="📝 Step 2: Take Assessment", id=2) as assessment_tab:
                 with gr.Column(visible=True) as question_box:
-                    # Question section
                     with gr.Group():
-                        question_display = gr.Markdown("", label="Current Question")
+                        question_display = gr.Markdown("")
                         current_options = gr.Radio(
                             choices=[],
                             label="Select your answer:",
@@ -619,9 +581,9 @@ def create_quiz_interface():
                             size="lg",
                             visible=True
                         )
-
+            
             # Certification Tab
-            with gr.Tab(id=3,label="🎓 Step 3: Get Certified"):
+            with gr.Tab(label="🎓 Step 3: Get Certified", id=3) as cert_tab:
                 score_display = gr.Number(label="Your Score")
                 result_message = gr.Markdown("")
                 course_name = gr.Textbox(
@@ -630,154 +592,7 @@ def create_quiz_interface():
                 )
                 certificate_display = gr.Image(label="Your Certificate")
 
-# Helper Functions
-
-            def on_generate_questions(text: str, num_questions: int) -> List:
-                success, questions = quiz_app.generate_questions(text, num_questions)
-                tab_index = 2  # Index for "Take Assessment" tab
-                
-                if not success:
-                    return [
-                        "",
-                        gr.update(choices=[], visible=False),
-                        "",
-                        gr.update(visible=False),
-                        [],
-                        0,
-                        [None] * 5,
-                        gr.Tabs(selected=2),
-                        gr.update(visible=False),
-                        gr.update(visible=False)
-                    ]
-                
-                initial_answers = [None] * len(questions)
-                question = questions[0]
-                
-                return [
-                    f"## Question 1\n{question.question}\n\nPlease select one answer:",
-                    gr.update(
-                        choices=question.options,
-                        value=None,
-                        visible=True,
-                        label="Select your answer for Question 1:"
-                    ),
-                    f"Question 1 of {len(questions)}",
-                    gr.update(visible=True),
-                    questions,
-                    0,
-                    initial_answers,
-                    gr.Tabs(selected=tab_index),
-                    gr.update(visible=False),
-                    gr.update(visible=False)
-                ]
-        
-        def navigate(direction: int, current_idx: int, questions: List, answers: List, current_answer: Optional[str]) -> List:
-            if not questions:
-                return [
-                    0,
-                    answers,
-                    "",
-                    gr.update(choices=[], value=None, visible=False),
-                    "",
-                    gr.update(visible=False)
-                ]
-            
-            new_answers = list(answers)
-            if current_answer and 0 <= current_idx < len(new_answers):
-                new_answers[current_idx] = current_answer
-            
-            new_idx = max(0, min(len(questions) - 1, current_idx + direction))
-            question = questions[new_idx]
-            
-            return [
-                new_idx,
-                new_answers,
-                f"## Question {new_idx + 1}\n{question.question}\n\nPlease select one answer:",
-                gr.update(
-                    choices=question.options,
-                    value=new_answers[new_idx] if new_idx < len(new_answers) else None,
-                    visible=True,
-                    label=f"Select your answer for Question {new_idx + 1}:"
-                ),
-                f"Question {new_idx + 1} of {len(questions)}",
-                gr.update(visible=True)
-            ]
-
-        def handle_prev(current_idx, questions, answers, current_answer):
-            return navigate(-1, current_idx, questions, answers, current_answer)
-        
-        def handle_next(current_idx, questions, answers, current_answer):
-            return navigate(1, current_idx, questions, answers, current_answer)
-        
-        def update_answer_state(answer, idx, current_answers):
-            new_answers = list(current_answers)
-            if 0 <= idx < len(new_answers):
-                new_answers[idx] = answer
-            return new_answers
-            
-        def on_submit(questions, answers, current_idx, current_answer):
-            final_answers = list(answers)
-            if 0 <= current_idx < len(final_answers):
-                final_answers[current_idx] = current_answer
-            
-            if not all(a is not None for a in final_answers[:len(questions)]):
-                return [
-                    "⚠️ Please answer all questions before submitting.",
-                    gr.update(visible=True),
-                    0,
-                    "",
-                    gr.update(visible=True),
-                    gr.Tabs(selected=1),
-                    gr.update(visible=False)
-                ]
-            
-            score, passed, feedback = quiz_app.calculate_score(final_answers[:len(questions)])
-            
-            feedback_html = "# Assessment Results\n\n"
-            for i, (q, f) in enumerate(zip(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 or "No answer"}
-            {'' if f.is_correct else f'<br>Correct answer: {f.correct_answer}'}
-        </div>
-        """
-            
-            result_msg = "🎉 Passed!" if passed else "Please try again"
-            if not passed:
-                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>
-        """
-            
-            return [
-                feedback_html,
-                gr.update(visible=True),
-                score,
-                result_msg,
-                gr.update(visible=not passed),
-                gr.update(selected=1),
-                gr.update(visible=passed)
-            ]
-        
-        def reset_quiz(text, num_questions):
-            """Handle quiz reset"""
-            return on_generate_questions(text, num_questions)
-
-        def view_certificate():
-            """Navigate to certificate tab"""
-            return gr.Tabs(selected=3)
-
-        def back_to_assessment():
-            return gr.Tabs(selected=2) #This will navigate    
-
-# Event handlers
+        # Event handlers
         generate_btn.click(
             fn=on_generate_questions,
             inputs=[text_input, num_questions],
@@ -794,7 +609,7 @@ def create_quiz_interface():
                 view_cert_btn
             ]
         ).then(
-            fn=lambda: gr.update(selected=1),
+            fn=goto_take_assessment,
             outputs=tabs
         )
 
@@ -877,11 +692,14 @@ def create_quiz_interface():
         )
 
         view_cert_btn.click(
-            fn=view_certificate,
-            outputs=[tabs]
+            fn=goto_certificate,
+            outputs=tabs
         )
 
-
+        back_to_assessment.click(
+            fn=goto_take_assessment,
+            outputs=tabs
+        )
 
         score_display.change(
             fn=lambda s, n, c, l, p: quiz_app.certificate_generator.generate(s, n, c, l, p) or gr.update(value=None),
@@ -891,6 +709,11 @@ def create_quiz_interface():
 
     return demo
 
+if __name__ == "__main__":
+    demo = create_quiz_interface()
+    demo.launch()
+    return demo
+
 if __name__ == "__main__":
     demo = create_quiz_interface()
     demo.launch()