Update app.py

app.py

@@ -21,10 +21,6 @@ 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)
@@ -117,26 +113,34 @@ 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:
-            subprocess.run(["apt-get", "update", "-y"], check=True)
-            subprocess.run(
-                [
-                    "apt-get", "install", "-y",
-                    "fonts-liberation",
-                    "fontconfig",
-                    "fonts-dejavu-core"
-                ],
-                check=True
-            )
+            # 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(["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: Font installation error: {e}")
+            print(f"Warning: Unexpected error installing fonts: {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",
@@ -149,6 +153,7 @@ class FontManager:
             'bold': None
         }
         
+        # Common font filenames to try
         fonts_to_try = {
             'regular': [
                 'LiberationSans-Regular.ttf',
@@ -163,12 +168,14 @@ 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)
@@ -176,19 +183,20 @@ 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}', f'sans-serif:style={style}'],
+                            ['fc-match', '-f', '%{file}', '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: Font matching error: {e}")
+                print(f"Warning: Could not use fc-match to find fonts: {e}")
         
         return font_paths
 
@@ -203,9 +211,30 @@ 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,
@@ -214,6 +243,9 @@ 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)
@@ -228,42 +260,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:
-            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")
+            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()
-            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)
+            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)]
         ]
@@ -279,12 +311,15 @@ 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),
@@ -320,6 +355,7 @@ 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):
@@ -490,64 +526,20 @@ class QuizApp:
             <p>You need 80% or higher to pass and receive a certificate.</p>
         </div>
         """
-    def on_generate_questions(text: str, num_questions: int) -> List:
-        """Generate quiz questions and setup initial state"""
-        success, questions = quiz_app.generate_questions(text, num_questions)
-        
-        # Handle failure case
-        if not success or not questions:
-            return [
-                "",                                     # question_display
-                gr.update(choices=[], visible=False),   # current_options
-                "",                                     # question_counter
-                gr.update(visible=False),               # question_box
-                [],                                     # current_questions
-                0,                                      # current_question_idx
-                [None] * 5,                            # answer_state
-                gr.Tabs(selected=2),                    # tabs - navigate to assessment tab
-                gr.update(visible=False),               # results_group
-                gr.update(visible=False)                # view_cert_btn
-            ]
-        
-        # Setup initial state with first question
-        initial_answers = [None] * len(questions)
-        question = questions[0]
-        question_html = f"""
-        # Question 1 of {len(questions)}
-        
-        {question.question}
-        """
-        
-        return [
-            question_html,                              # question_display
-            gr.update(
-                choices=question.options,
-                value=None,
-                visible=True,
-                label="Select your answer:"
-            ),                                         # current_options
-            f"Question 1 of {len(questions)}",         # question_counter
-            gr.update(visible=True),                   # question_box
-            questions,                                 # current_questions
-            0,                                        # current_question_idx
-            initial_answers,                          # answer_state
-            gr.Tabs(selected=2),                      # tabs - navigate to assessment tab
-            gr.update(visible=False),                 # results_group
-            gr.update(visible=False)                  # view_cert_btn
-        ]     
+
 def create_quiz_interface():
     if not os.getenv("GROQ_API_KEY"):
         raise EnvironmentError("Please set your GROQ_API_KEY environment variable")
         
-    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)
+        answer_state = gr.State([None] * 5)  # Store all answers
         
+        # Header
         gr.Markdown("""
         # 🎓 CertifyMe AI
         ### Transform Your Knowledge into Recognized Achievements
@@ -555,7 +547,7 @@ def create_quiz_interface():
         
         with gr.Tabs() as tabs:
             # Profile Setup Tab
-            with gr.Tab(label="📋 Step 1: Profile Setup", id=1) as 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")
@@ -581,54 +573,40 @@ def create_quiz_interface():
                 generate_btn = gr.Button("Generate Assessment", variant="primary", size="lg")
             
             # Assessment Tab
-            with gr.Tab(label="📝 Step 2: Take Assessment", id=2) as assessment_tab:
+            with gr.Tab("📝 Step 2: Take Assessment") as assessment_tab:
                 with gr.Column(visible=True) as question_box:
+                    # Question section
                     with gr.Group():
-                        question_display = gr.Markdown("")
+                        # Question display
+                        question_display = gr.Markdown("", label="Current Question")
+                        
+                        # Single radio group for current question
                         current_options = gr.Radio(
                             choices=[],
                             label="Select your answer:",
                             visible=False
                         )
                         
+                        # Navigation
                         with gr.Row():
                             prev_btn = gr.Button("← Previous", variant="secondary", size="sm")
                             question_counter = gr.Markdown("Question 1 of 3")
                             next_btn = gr.Button("Next →", variant="secondary", size="sm")
                         
-                        gr.Markdown("---")
+                        gr.Markdown("---")  # Separator
                         
-                        with gr.Row():
-                            submit_btn = gr.Button(
-                                "Submit Assessment",
-                                variant="primary",
-                                size="lg"
-                            )
-                            reset_btn = gr.Button(
-                                "Reset Quiz",
-                                variant="secondary",
-                                size="lg"
-                            )
+                        submit_btn = gr.Button(
+                            "Submit Assessment",
+                            variant="primary",
+                            size="lg"
+                        )
                 
                 # Results section
                 with gr.Group(visible=False) as results_group:
                     feedback_box = gr.Markdown("")
-                    with gr.Row():
-                        view_cert_btn = gr.Button(
-                            "View Certificate",
-                            variant="primary",
-                            size="lg",
-                            visible=False
-                        )
-                        back_to_assessment = gr.Button(
-                            "Back to Assessment",
-                            variant="secondary",
-                            size="lg",
-                            visible=True
-                        )
             
             # Certification Tab
-            with gr.Tab(label="🎓 Step 3: Get Certified", id=3) as cert_tab:
+            with gr.Tab("🎓 Step 3: Get Certified"):
                 score_display = gr.Number(label="Your Score")
                 result_message = gr.Markdown("")
                 course_name = gr.Textbox(
@@ -637,6 +615,141 @@ def create_quiz_interface():
                 )
                 certificate_display = gr.Image(label="Your Certificate")
 
+
+        def on_generate_questions(text, num_questions):
+                    success, questions = quiz_app.generate_questions(text, num_questions)
+                    if not success:
+                        return [
+                            "",  # question_display
+                            gr.update(choices=[], visible=False),  # current_options
+                            "",  # question_counter
+                            gr.update(visible=False),  # question_box
+                            [],  # current_questions
+                            0,  # current_question_idx
+                            [None] * 5,  # answer_state
+                            gr.update(selected=1),  # tabs
+                            gr.update(visible=False)  # results_group
+                        ]
+                    
+                    # Initialize first question
+                    initial_answers = [None] * len(questions)
+                    question = questions[0]
+                    
+                    return [
+                        f"""## Question 1
+        {question.question}
+        
+        Please select one answer:""",  # question_display
+                        gr.update(
+                            choices=question.options,
+                            value=None,
+                            visible=True,
+                            label="Select your answer for Question 1:"
+                        ),  # current_options
+                        f"Question 1 of {len(questions)}",  # question_counter
+                        gr.update(visible=True),  # question_box
+                        questions,  # current_questions
+                        0,  # current_question_idx
+                        initial_answers,  # answer_state
+                        gr.update(selected=1),  # tabs
+                        gr.update(visible=False)  # results_group
+                    ]
+        
+                def navigate(direction, current_idx, questions, answers, current_answer):
+                    """
+                    Handle navigation between questions
+                    """
+                    if not questions:  # No questions available
+                        return [
+                            0,  # current_question_idx
+                            answers,  # answer_state
+                            "",  # question_display
+                            gr.update(choices=[], value=None, visible=False),  # current_options
+                            "",  # question_counter
+                            gr.update(visible=False)  # question_box
+                        ]
+                    
+                    # Save current answer
+                    new_answers = list(answers)
+                    if current_answer and 0 <= current_idx < len(new_answers):
+                        new_answers[current_idx] = current_answer
+                    
+                    # Calculate new index
+                    new_idx = max(0, min(len(questions) - 1, current_idx + direction))
+                    
+                    # Get current question
+                    question = questions[new_idx]
+                    
+                    return [
+                        new_idx,  # current_question_idx
+                        new_answers,  # answer_state
+                        f"""## Question {new_idx + 1}
+        {question.question}
+        
+        Please select one answer:""",  # question_display
+                        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}:"
+                        ),  # current_options
+                        f"Question {new_idx + 1} of {len(questions)}",  # question_counter
+                        gr.update(visible=True)  # question_box
+                    ]
+
+        def on_submit(questions, answers, current_idx, current_answer):
+            # Update the current answer in the answers list
+            final_answers = list(answers)
+            if 0 <= current_idx < len(final_answers):
+                final_answers[current_idx] = current_answer
+            
+            # Validate all answers are provided
+            if not all(a is not None for a in final_answers[:len(questions)]):
+                return {
+                    feedback_box: "⚠️ Please answer all questions before submitting.",
+                    results_group: gr.update(visible=True),
+                    score_display: 0,
+                    result_message: "",
+                    question_box: gr.update(visible=True),
+                    tabs: gr.update(selected=1)
+                }
+            
+            score, passed, feedback = quiz_app.calculate_score(final_answers[:len(questions)])
+            
+            # Generate feedback HTML
+            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_box: feedback_html,
+                results_group: gr.update(visible=True),
+                score_display: score,
+                result_message: result_msg,
+                question_box: gr.update(visible=passed),
+                tabs: gr.update(selected=2 if passed else 1)
+            }
+
         # Event handlers
         generate_btn.click(
             fn=on_generate_questions,
@@ -650,14 +763,33 @@ def create_quiz_interface():
                 current_question_idx,
                 answer_state,
                 tabs,
-                results_group,
-                view_cert_btn
+                results_group
             ]
-        ).then(
-            fn=goto_take_assessment,
-            outputs=tabs
         )
 
+        # Navigation event handlers
+        def handle_prev(current_idx, questions, answers, current_answer):
+            result = navigate(-1, current_idx, questions, answers, current_answer)
+            return [
+                result[current_question_idx],
+                result[answer_state],
+                result[question_display],
+                result[current_options],
+                result[question_counter],
+                result[question_box]
+            ]
+
+        def handle_next(current_idx, questions, answers, current_answer):
+            result = navigate(1, current_idx, questions, answers, current_answer)
+            return [
+                result[current_question_idx],
+                result[answer_state],
+                result[question_display],
+                result[current_options],
+                result[question_counter],
+                result[question_box]
+            ]
+
         prev_btn.click(
             fn=handle_prev,
             inputs=[
@@ -694,14 +826,33 @@ def create_quiz_interface():
             ]
         )
 
+        # Update answer state when radio button changes
+        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
+
         current_options.change(
             fn=update_answer_state,
             inputs=[current_options, current_question_idx, answer_state],
             outputs=answer_state
         )
 
+        # Submission handler
+        def on_submit_wrapper(questions, answers, current_idx, current_answer):
+            result = on_submit(questions, answers, current_idx, current_answer)
+            return [
+                result[feedback_box],
+                result[results_group],
+                result[score_display],
+                result[result_message],
+                result[question_box],
+                result[tabs]
+            ]
+
         submit_btn.click(
-            fn=on_submit,
+            fn=on_submit_wrapper,
             inputs=[
                 current_questions,
                 answer_state,
@@ -714,40 +865,13 @@ def create_quiz_interface():
                 score_display,
                 result_message,
                 question_box,
-                tabs,
-                view_cert_btn
-            ]
-        )
-
-        reset_btn.click(
-            fn=reset_quiz,
-            inputs=[text_input, num_questions],
-            outputs=[
-                question_display,
-                current_options,
-                question_counter,
-                question_box,
-                current_questions,
-                current_question_idx,
-                answer_state,
-                tabs,
-                results_group,
-                view_cert_btn
+                tabs
             ]
         )
 
-        view_cert_btn.click(
-            fn=goto_certificate,
-            outputs=tabs
-        )
-
-        back_to_assessment.click(
-            fn=goto_take_assessment,
-            outputs=tabs
-        )
-
+        # Certificate generation
         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),
+            fn=quiz_app.certificate_generator.generate,
             inputs=[score_display, name, course_name, company_logo, participant_photo],
             outputs=certificate_display
         )
@@ -756,4 +880,4 @@ def create_quiz_interface():
 
 if __name__ == "__main__":
     demo = create_quiz_interface()
-    demo.launch()
+    demo.launch()