Update app.py

app.py

@@ -45,7 +45,7 @@ class QuizGenerator:
                     }
                 ],
                 model="gemma2-9b-it",
-                temperature=0.1,
+                temperature=0,
                 max_tokens=6000
             )
             
@@ -70,39 +70,29 @@ class QuizGenerator:
             raise QuizGenerationError(f"Failed to generate questions: {str(e)}")
     
     def _create_prompt(self, text: str, num_questions: int) -> str:
-        """Create a simple, clear prompt optimized for gemma2-9b-it"""
-        return f"""Create exactly {num_questions} multiple choice questions based on this text. Return your response in this exact JSON format with no additional text or formatting:
-    [{{
-        "question": "Write the first question here?",
-        "options": [
-            "First option",
-            "Second option",
-            "Third option",
-            "Fourth option"
-        ],
-        "correct_answer": 0
-    }},{{
-        "question": "Write the second question here?",
-        "options": [
-            "First option",
-            "Second option",
-            "Third option",
-            "Fourth option"
-        ],
-        "correct_answer": 0
-    }}]
-    
-    Important formatting rules:
-    1. The JSON must start with [ and end with ]
-    2. Each question object must be wrapped in {{ }}
-    3. Questions must be separated by commas
-    4. No trailing commas after the last question
-    5. Each question must have exactly 4 options
-    6. correct_answer must be a number (0, 1, 2, or 3)
-    7. Return only the JSON with no other text
-    
-    Text to use:
-    {text.strip()}"""
+        """Create a simple, clear prompt optimized for llama-3.2-3b-preview"""
+        return f"""Create {num_questions} multiple choice questions about this text. Return only the JSON array in this exact format:
+[
+  {{
+    "question": "Write the question here?",
+    "options": [
+      "First option",
+      "Second option",
+      "Third option",
+      "Fourth option"
+    ],
+    "correct_answer": 0
+  }}
+]
+
+Rules:
+1. Return only the JSON array
+2. Each question must have exactly 4 options
+3. correct_answer must be 0, 1, 2, or 3
+4. No explanations or additional text
+
+Text to use:
+{text.strip()}"""
 
     def _parse_response(self, response_text: str) -> List[Dict]:
         """Parse response with improved error handling"""
@@ -110,7 +100,7 @@ class QuizGenerator:
             # Clean up the response text
             cleaned = response_text.strip()
             
-            # Remove markdown formatting
+            # Remove any markdown formatting
             cleaned = cleaned.replace('```json', '').replace('```', '').strip()
             
             # Find the JSON array
@@ -122,40 +112,35 @@ class QuizGenerator:
             
             json_str = cleaned[start:end]
             
-            # Fix common JSON formatting issues
-            json_str = re.sub(r',(\s*})', r'\1', json_str)  # Remove trailing commas in objects
-            json_str = re.sub(r',(\s*])', r'\1', json_str)  # Remove trailing commas in arrays
-            json_str = re.sub(r'}\s*{', '},{', json_str)    # Fix spacing between objects
-            json_str = re.sub(r'\n\s*\n', '\n', json_str)   # Remove extra newlines
-            
-            # Fix missing commas between objects
-            json_str = re.sub(r'}\s*{', '},{', json_str)
-            
-            # Ensure array brackets
-            if not json_str.startswith('['):
-                json_str = '[' + json_str
-            if not json_str.endswith(']'):
-                json_str = json_str + ']'
+            # Remove any trailing commas before closing brackets
+            json_str = re.sub(r',(\s*})', r'\1', json_str)
+            json_str = re.sub(r',(\s*])', r'\1', json_str)
             
+            # Try to parse the cleaned JSON
             try:
                 return json.loads(json_str)
             except json.JSONDecodeError:
-                # Try fixing any remaining issues
-                fixed_str = re.sub(r'(["\d\w])\s*}', r'\1}', json_str)  # Fix spacing before closing braces
-                fixed_str = re.sub(r'\[\s*{', '[{', fixed_str)          # Fix spacing after opening bracket
-                fixed_str = re.sub(r'}\s*]', '}]', fixed_str)           # Fix spacing before closing bracket
+                # If that fails, try using ast.literal_eval as a fallback
+                import ast
+                return ast.literal_eval(json_str)
                 
-                try:
-                    return json.loads(fixed_str)
-                except:
-                    # Last resort: Try using ast.literal_eval
-                    import ast
-                    return ast.literal_eval(fixed_str)
-                    
         except Exception as e:
             print(f"Parse error details: {str(e)}")
             print(f"Attempted to parse: {response_text}")
-            raise ValueError(f"Failed to parse response: {str(e)}")
+            
+            # Last resort: try to fix the JSON manually
+            try:
+                # Remove any trailing commas and fix newlines
+                fixed = re.sub(r',(\s*[}\]])', r'\1', response_text)
+                fixed = fixed.replace('}\n{', '},{')
+                fixed = fixed.strip()
+                if not fixed.startswith('['):
+                    fixed = '[' + fixed
+                if not fixed.endswith(']'):
+                    fixed = fixed + ']'
+                return json.loads(fixed)
+            except:
+                raise ValueError(f"Failed to parse response: {str(e)}")
     
     def _validate_questions(self, questions: List[Dict], num_questions: int) -> List[Question]:
         """Validate questions with strict checking"""
@@ -540,6 +525,88 @@ class QuizApp:
         self.quiz_generator = QuizGenerator(api_key)
         self.certificate_generator = CertificateGenerator()
         self.current_questions: List[Question] = []
+        self.logo_path = "atgc_logo.png"
+        self.selected_level = "Basic"  # Default level
+        
+        # Map difficulty levels to number of questions
+        self.difficulty_levels = {
+            "Basic": 5,
+            "Intermediate": 10,
+            "Advanced": 20
+        }
+        
+        # Add fixed content here
+        self.fixed_content = """# Power BI: A Comprehensive Learning Guide
+
+## Introduction to Power BI
+
+Power BI represents Microsoft's flagship business intelligence platform, offering a comprehensive suite of tools for data analysis and visualization. This guide will walk you through the essential concepts, from basic data connectivity to advanced implementations, helping you master this powerful platform.
+
+## Understanding Data Connectivity and Management
+
+The foundation of any Power BI solution begins with data connectivity. Power BI offers two primary methods for connecting to data sources: Import mode and DirectQuery mode. Import mode loads data directly into Power BI's memory, providing faster performance and offline access capabilities. In contrast, DirectQuery maintains a live connection to your data source, ensuring real-time data access albeit with potentially slower performance due to query execution time.
+
+When working with data sources, Power BI supports a vast array of connections including SQL Server databases, Excel spreadsheets, CSV files, web services, and SharePoint lists. Understanding how to effectively use these connections is crucial for building robust solutions. For instance, when working with Excel data, you can import not only basic tables but also Power Pivot Data Models and Power View Reports, providing flexibility in how you structure your data imports.
+
+## Mastering Data Modeling
+
+Data modeling in Power BI follows best practices from dimensional modeling, with the star schema being a fundamental concept. In a star schema, you organize your data around a central fact table connected to multiple dimension tables. This structure optimizes query performance and creates clear, intuitive relationships between your data elements.
+
+A critical distinction in Power BI modeling is understanding the difference between calculated columns and measures. Calculated columns compute values for each row and store them in memory, making them ideal for values that need to be filtered or grouped. Measures, on the other hand, calculate results at query time based on user interactions, making them perfect for aggregations and complex calculations that need to respond to different filter contexts.
+
+## DAX: The Language of Data Analysis
+
+Data Analysis Expressions (DAX) serves as the formula language in Power BI, enabling you to create sophisticated calculations and data analyses. Beginning with basic functions, you'll learn to create fundamental calculations like total sales or year-to-date values. For example, a simple year-to-date sales calculation might look like:
+
+```
+YTD Sales = TOTALYTD(SUM(Sales[Amount]), 'Date'[Date])
+```
+
+As you advance, you'll encounter more complex scenarios requiring advanced DAX concepts. Time intelligence functions allow you to create period-over-period comparisons, while context transition helps you navigate between row and filter contexts effectively. Understanding these concepts becomes crucial when building sophisticated financial or sales analysis solutions.
+
+## Advanced Analysis and Visualization
+
+Power BI's visualization capabilities extend far beyond basic charts and graphs. The platform offers a rich set of visualization tools, from standard bar and line charts to sophisticated custom visuals available through the marketplace. Learning to choose the right visualization for your data story becomes crucial for effective communication.
+
+Consider a sales analysis scenario: you might combine a line chart showing trends over time with a map visualization displaying regional performance, while using drill-through capabilities to provide detailed product-level analysis. These interactive features allow users to explore data naturally, moving from high-level overviews to detailed insights seamlessly.
+
+## Security and Administration
+
+Security in Power BI operates at multiple levels. Row-level security (RLS) allows you to control data access at a granular level, ensuring users see only the data they're authorized to view. For example, regional managers might only see sales data for their specific territories, while executive leadership sees all regions.
+
+Administration extends beyond security to include workspace management, sharing permissions, and gateway configuration. The Enterprise Gateway facilitates secure data refresh from on-premises sources, while Personal Gateway serves individual users' needs. Understanding these components helps you build a secure and efficient BI environment.
+
+## Performance Optimization and Best Practices
+
+Optimizing Power BI solutions requires attention to several key areas. Data model optimization involves choosing the right storage mode, implementing appropriate relationships, and creating efficient measures. Query performance can be enhanced through proper use of variables in DAX, implementing query folding in Power Query, and utilizing aggregations for large datasets.
+
+For large-scale implementations, consider incremental refresh strategies to manage data loading efficiently. This might involve setting up refresh windows to load only the most recent data while maintaining historical information in a static form.
+
+## Real-World Implementation Scenarios
+
+Practical application of Power BI often involves complex scenarios combining multiple concepts. Consider a financial reporting solution that requires:
+- Integration with multiple data sources
+- Implementation of security roles
+- Automated refresh schedules
+- Excel integration for detailed analysis
+
+Or a sales performance dashboard featuring:
+- Real-time data tracking
+- Predictive analytics integration
+- Mobile optimization
+- Automated alerting systems
+
+These scenarios require combining technical knowledge with business understanding to create effective solutions.
+
+## Conclusion
+
+Mastering Power BI requires understanding not just individual components but how they work together to create effective business intelligence solutions. From basic data connectivity through advanced DAX calculations to security implementation, each element plays a crucial role in building robust, scalable BI systems. Regular practice with real-world scenarios helps reinforce these concepts and builds the experience needed to handle complex business requirements effectively.
+
+Continue your learning journey by experimenting with different features, challenging yourself with complex scenarios, and staying updated with the platform's evolving capabilities. Remember that effective BI solutions balance technical capability with business needs, creating insights that drive meaningful business decisions."""
+
+    def get_certificate_title(self, base_title: str) -> str:
+        """Get certificate title with difficulty level"""
+        return f"{base_title} - {self.selected_level} Level"    
 
     def generate_questions(self, text: str, num_questions: int) -> Tuple[bool, List[Question]]:
         """
@@ -720,7 +787,7 @@ def create_quiz_interface():
         # Header
         gr.Markdown("""
         <div style="text-align: center;">
-            <h1>🎓 CertifyMe AI </h1>
+            <h1>🎓 Power BI Assessment Certification </h1>
             <h3>Transform Your Knowledge into Recognized Achievements</h3></p>
         </div>
         
@@ -728,14 +795,15 @@ def create_quiz_interface():
             <h4>Assessment Overview:</h4>
             <ul style="list-style-type: none; padding-left: 0;">
                 <li>📌 <strong>Basic Level:</strong> 5 questions - Perfect for beginners</li>
-                <li>📚 <strong>Intermediate Level:</strong> 10 questions - For gaining Intermediate Experience</li>
+                <li>📚 <strong>Intermediate Level:</strong> 10 questions - For those with HR experience</li>
                 <li>🎯 <strong>Advanced Level:</strong> 20 questions - Comprehensive assessment</li>
                 <li>⏱️ <strong>Passing Score:</strong> 80% or higher</li>
                 <li>🏆 <strong>Certificate:</strong> Awarded upon successful completion</li>
             </ul>
-            <p style="margin-top: 15px;"><i>This assessment evaluates your understanding of the Learning Content that you pasted below:</i></p>
+            <p style="margin-top: 15px;"><i>This assessment evaluates your understanding of Power BI.</i></p>
         </div>
-        """, show_label=False)         
+        """, show_label=False)   
+        
         with gr.Tabs() as tabs:
             # Profile Setup Tab
             with gr.Tab(id=1, label="📋 Step 1: Profile Setup"):
@@ -745,20 +813,19 @@ def create_quiz_interface():
                 
                 text_input = gr.Textbox(
                     label="Learning Content",
-                    placeholder="Enter the text content you want to be assessed on",
+                    value=quiz_app.fixed_content,  # Set the fixed content
+                    interactive=False,  # Make it non-editable
                     lines=10
                 )
                 
-                num_questions = gr.Slider(
-                    minimum=1,
-                    maximum=20,
-                    value=10,
-                    step=1,
-                    label="Number of Questions"
-                )
+                difficulty_level = gr.Radio(
+                    choices=["Basic", "Intermediate", "Advanced"],
+                    value="Basic",
+                    label="Select Difficulty Level",
+                    info="Basic: 5 questions | Intermediate: 10 questions | Advanced: 20 questions")
+                
                 
                 with gr.Row():
-                    company_logo = gr.Image(label="Company Logo (Optional)", type="filepath")
                     participant_photo = gr.Image(label="Your Photo (Optional)", type="filepath")
                 
                 generate_btn = gr.Button("Generate Assessment", variant="primary", size="lg")
@@ -814,40 +881,33 @@ def create_quiz_interface():
                             )                    
 
             # Certification Tab (Hidden by default)
+
             with gr.Tab(id=3, label="🎓 Step 3: Get Certified", visible=False) as cert_tab:
                 score_display = gr.Number(label="Your Score", visible=False)
                 course_name = gr.Textbox(
                     label="Certification Title",
-                    value="Professional Assessment Certification",
-                    interactive=False  # Make it non-editable
+                    value=lambda: f"Power BI Assessment Certification",  # Dynamic title with level
+                    interactive=False
                 )
-                certificate_display = gr.Image(label="Your Certificate")
+                certificate_display = gr.Image(label="Your Certificate")        
+                    
 
-        # Update view_cert_btn click handler to show certification tab
         def show_certificate_tab():
             return [
                 gr.update(visible=True),  # Make cert_tab visible
+                gr.update(
+                    value=f"Power BI Assessment Certification"  # Update title with level
+                ),
                 gr.update(selected=3)     # Switch to cert_tab
             ]
 
 
         # Helper Functions
-        def on_generate_questions(text, num_questions):
-            if not text.strip():
-                return [
-                    "",
-                    gr.update(visible=False),
-                    gr.update(choices=[], visible=False),
-                    "",
-                    [],
-                    0,
-                    [None] * 5,
-                    gr.update(selected=1),
-                    gr.update(visible=False),
-                    gr.update(visible=False)
-                ]
+        def on_generate_questions(text, level):
+            quiz_app.selected_level = level  # Store selected level
+            num_questions = quiz_app.difficulty_levels[level]  # Get number of questions for level
             
-            success, questions = quiz_app.generate_questions(text, num_questions)
+            success, questions = quiz_app.generate_questions(quiz_app.fixed_content, num_questions)
             if not success or not questions:
                 return [
                     "",
@@ -856,15 +916,14 @@ def create_quiz_interface():
                     "",
                     [],
                     0,
-                    [None] * 5,
+                    [None] * num_questions,  # Updated to use dynamic size
                     gr.update(selected=1),
                     gr.update(visible=False),
                     gr.update(visible=False)
                 ]
             
             question = questions[0]
-            question_md = f"""### Question 1
-{question.question}"""
+            question_md = f"""### Question 1\n{question.question}"""
             
             return [
                 question_md,
@@ -938,48 +997,62 @@ def create_quiz_interface():
             if 0 <= current_idx < len(final_answers):
                 final_answers[current_idx] = current_answer
             
-            # Check for unanswered questions
             if not all(a is not None for a in final_answers[:len(questions)]):
-                # Find unanswered question numbers
+                # Create list of unanswered question numbers
                 unanswered = [i+1 for i, a in enumerate(final_answers[:len(questions)]) if a is None]
                 warning_content = f"""
-                <div style="background-color: #fff3cd; padding: 20px; border-radius: 8px; border: 1px solid #ffeeba; margin: 10px 0;">
-                    <div style="display: flex; align-items: center; margin-bottom: 10px;">
-                        <span style="font-size: 24px; margin-right: 10px;">⚠️</span>
-                        <h3 style="color: #856404; margin: 0;">Please Complete All Questions</h3>
-                    </div>
-                    <p style="color: #856404; margin: 10px 0;">The following questions are unanswered:</p>
-                    <p style="color: #856404; font-weight: bold; margin: 5px 0;">Question(s) {', '.join(map(str, unanswered))}</p>
-                    <p style="color: #856404; margin: 10px 0;">Please answer all questions before submitting.</p>
+                <div style="background-color: #fff3cd; padding: 20px; border-radius: 10px; border-left: 5px solid #ffa000;">
+                    <h3 style="color: #ff6b6b; margin: 0;">⚠️ Please Complete All Questions</h3>
+                    <p style="margin: 10px 0;">Unanswered Questions: {', '.join(map(str, unanswered))}</p>
                 </div>
                 """
                 return [
-                    warning_content,                # feedback_box
-                    gr.update(visible=True),        # results_group
-                    0,                             # score
-                    "⚠️ Incomplete Submission",     # result_message
-                    gr.update(visible=True),        # question_box
-                    gr.update(visible=True),        # reset_btn
-                    gr.update(visible=False),       # view_cert_btn
-                    gr.update(selected=2)           # tabs
+                    warning_content,             # feedback_box
+                    gr.update(visible=True),     # results_group
+                    0,                          # score
+                    "",                         # result_message
+                    gr.update(visible=True),     # question_box
+                    gr.update(visible=True),     # reset_btn
+                    gr.update(visible=False),    # view_cert_btn
+                    gr.update(selected=2)        # tabs
                 ]
-        
-            # Rest of the original function remains the same...
+            
             score, passed, feedback = quiz_app.calculate_score(final_answers[:len(questions)])
-            feedback_content = f"""# Assessment Results\n\n**Score: {score:.1f}%**\n\n"""
+            
+            # Create feedback content using proper Markdown with emojis
+            feedback_content = f"""# Assessment Results
+        
+        **Score: {score:.1f}%**
+        
+        """
             
             for i, (q, f) in enumerate(zip(questions, feedback)):
                 icon = "✅" if f.is_correct else "❌"
                 color = "green" if f.is_correct else "red"
+                
+                # Using markdown syntax with color formatting
                 feedback_content += f"""### Question {i+1}
-                {q.question}\n
-                {icon} **Your answer:** {f.selected or 'No answer'}
-                {'' if f.is_correct else f'**Correct answer:** {f.correct_answer}'}\n\n"""
+        {q.question}
+        
+        {icon} **Your answer:** {f.selected or 'No answer'}
+        {'' if f.is_correct else f'**Correct answer:** {f.correct_answer}'}
+        
+        """
             
+            # Add summary box
             if passed:
-                feedback_content += f"""\n---\n## 🎉 Congratulations!\nYou passed with a score of {score:.1f}%!"""
+                feedback_content += f"""
+        ---
+        ## 🎉 Congratulations!
+        You passed with a score of {score:.1f}%!
+        """
             else:
-                feedback_content += f"""\n---\n## Need Improvement\nYou scored {score:.1f}%. You need 80% or higher to pass.\nPlease try again."""
+                feedback_content += f"""
+        ---
+        ## Need Improvement
+        You scored {score:.1f}%. You need 80% or higher to pass.
+        Please try again.
+        """
             
             return [
                 feedback_content,                # feedback_box
@@ -991,11 +1064,10 @@ def create_quiz_interface():
                 gr.update(visible=passed),       # view_cert_btn
                 gr.update(selected=2)            # tabs
             ]
-            
         # Event Handlers
         generate_btn.click(
             fn=on_generate_questions,
-            inputs=[text_input, num_questions],
+            inputs=[text_input, difficulty_level],  # Replace num_questions with difficulty_level
             outputs=[
                 question_display,
                 question_box,
@@ -1039,7 +1111,7 @@ def create_quiz_interface():
         
         reset_btn.click(
             fn=on_generate_questions,
-            inputs=[text_input, num_questions],
+            inputs=[text_input, difficulty_level],  # Replace num_questions with difficulty_level
             outputs=[
                 question_display,
                 question_box,
@@ -1053,10 +1125,10 @@ def create_quiz_interface():
                 view_cert_btn
             ]
         )
-        
+
         view_cert_btn.click(
             fn=show_certificate_tab,
-            outputs=[cert_tab, tabs]
+            outputs=[cert_tab, course_name, tabs]  # Add course_name to outputs
         )
         
         current_options.change(
@@ -1066,11 +1138,15 @@ def create_quiz_interface():
         )
         
         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),
-            inputs=[score_display, name, course_name, company_logo, participant_photo],
+            fn=lambda s, n, c, p: quiz_app.certificate_generator.generate(
+                s, n, 
+                quiz_app.get_certificate_title(c),  # Add difficulty level to title
+                quiz_app.logo_path, p
+            ) or gr.update(value=None),
+            inputs=[score_display, name, course_name, participant_photo],
             outputs=certificate_display
         )
-        
+                
     return demo
 
 if __name__ == "__main__":