Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| from groq import Groq | |
| import os | |
| from PIL import Image, ImageDraw, ImageFont | |
| from datetime import datetime | |
| import json | |
| import tempfile | |
| # Initialize Groq client | |
| client = Groq( | |
| api_key=os.getenv("GROQ_API_KEY") | |
| ) | |
| class QuizApp: | |
| def __init__(self): | |
| self.current_questions = [] | |
| self.user_data = {} | |
| def generate_questions(self, text, num_questions): | |
| prompt = f"""Create {num_questions} multiple choice questions based on this text: | |
| {text} | |
| Each question should: | |
| 1. Have a clear, concise question text | |
| 2. Have exactly 4 options | |
| 3. Have only one correct answer | |
| 4. Be educational and test understanding | |
| Return the questions in this JSON format: | |
| [ | |
| {{ | |
| "question": "Question text?", | |
| "options": [ | |
| "Correct answer", | |
| "Wrong answer 1", | |
| "Wrong answer 2", | |
| "Wrong answer 3" | |
| ], | |
| "correct_answers": [0] | |
| }} | |
| ] | |
| Only return the JSON array, no other text.""" | |
| try: | |
| response = client.chat.completions.create( | |
| messages=[ | |
| {"role": "system", "content": "You are a quiz generator that creates clear, single-choice questions."}, | |
| {"role": "user", "content": prompt} | |
| ], | |
| model="llama-3.2-3b-preview", | |
| temperature=0.5, | |
| max_tokens=2048, | |
| top_p=0.9 | |
| ) | |
| response_text = response.choices[0].message.content.strip() | |
| # Remove any markdown formatting | |
| response_text = response_text.replace("```json", "").replace("```", "").strip() | |
| questions = json.loads(response_text) | |
| if isinstance(questions, list): | |
| self.current_questions = questions | |
| else: | |
| self.current_questions = questions.get("questions", []) | |
| # Validate question format | |
| for q in self.current_questions: | |
| if not all(key in q for key in ["question", "options", "correct_answers"]): | |
| raise ValueError("Invalid question format") | |
| if len(q["options"]) != 4: | |
| raise ValueError("Each question must have exactly 4 options") | |
| return json.dumps(self.current_questions, indent=2) | |
| except Exception as e: | |
| print(f"Error generating questions: {e}") | |
| return json.dumps([{ | |
| "question": "Error generating questions. Please try again.", | |
| "options": ["Error", "Error", "Error", "Error"], | |
| "correct_answers": [0] | |
| }]) | |
| def calculate_score(self, answers): | |
| try: | |
| answers = json.loads(answers) if isinstance(answers, str) else answers | |
| total = len(self.current_questions) | |
| correct = 0 | |
| for q, a in zip(self.current_questions, answers): | |
| if set(a) == set(q["correct_answers"]): | |
| correct += 1 | |
| return (correct / total) * 100 | |
| except Exception as e: | |
| print(f"Error calculating score: {e}") | |
| return 0 | |
| def generate_certificate(self, name, score, course_name, company_logo=None, participant_photo=None): | |
| try: | |
| # Create certificate with a light blue background | |
| certificate = Image.new('RGB', (1200, 800), '#F0F8FF') | |
| draw = ImageDraw.Draw(certificate) | |
| # Load fonts | |
| try: | |
| title_font = ImageFont.truetype("arial.ttf", 60) | |
| text_font = ImageFont.truetype("arial.ttf", 40) | |
| subtitle_font = ImageFont.truetype("arial.ttf", 30) | |
| except: | |
| print("Using default font as Arial not found") | |
| title_font = ImageFont.load_default() | |
| text_font = ImageFont.load_default() | |
| subtitle_font = ImageFont.load_default() | |
| # Add decorative border | |
| draw.rectangle([20, 20, 1180, 780], outline='#4682B4', width=3) | |
| # Draw certificate content | |
| draw.text((600, 100), "CertifyMe AI", font=title_font, fill='#4682B4', anchor="mm") | |
| draw.text((600, 160), "Certificate of Achievement", font=subtitle_font, fill='#4682B4', anchor="mm") | |
| draw.text((600, 300), "This is to certify that", font=text_font, fill='black', anchor="mm") | |
| draw.text((600, 380), name, font=text_font, fill='#4682B4', anchor="mm") | |
| draw.text((600, 460), "has successfully completed", font=text_font, fill='black', anchor="mm") | |
| draw.text((600, 540), course_name, font=text_font, fill='#4682B4', anchor="mm") | |
| draw.text((600, 620), f"with a score of {score:.1f}%", font=text_font, fill='black', anchor="mm") | |
| # Add 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) | |
| logo = logo.resize((150, 150)) | |
| certificate.paste(logo, (50, 50)) | |
| 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) | |
| photo = photo.resize((150, 150)) | |
| certificate.paste(photo, (1000, 50)) | |
| except Exception as e: | |
| print(f"Error adding photo: {e}") | |
| # Save certificate | |
| temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png') | |
| certificate.save(temp_file.name) | |
| return temp_file.name | |
| except Exception as e: | |
| print(f"Error generating certificate: {e}") | |
| return None | |
| def create_quiz_app(): | |
| quiz_app = QuizApp() | |
| with gr.Blocks(title="CertifyMe AI", theme=gr.themes.Soft()) as demo: | |
| current_tab = gr.State(0) | |
| current_questions = gr.State([]) | |
| user_answers = gr.State([]) | |
| gr.Markdown(""" | |
| # 🎓 CertifyMe AI | |
| ### Transform Your Knowledge into Recognized Achievements | |
| """) | |
| with gr.Tabs() as tabs: | |
| # Step 1: Profile Setup (remains largely the same) | |
| with gr.Tab("📋 Step 1: Profile Setup", id=0) as tab1: | |
| # ... (previous profile setup code remains the same) | |
| # Step 2: Take Assessment (completely revised) | |
| with gr.Tab("📝 Step 2: Take Assessment", id=1) as tab2: | |
| def format_questions(questions_json): | |
| try: | |
| questions = json.loads(questions_json) if isinstance(questions_json, str) else questions_json | |
| return questions | |
| except: | |
| return [] | |
| def display_questions(questions): | |
| with gr.Group() as quiz_container: | |
| answers = [] | |
| for i, q in enumerate(questions): | |
| gr.Markdown(f"### Question {i+1}") | |
| gr.Markdown(q["question"]) | |
| radio = gr.Radio( | |
| choices=q["options"], | |
| label="Select your answer", | |
| value=None, | |
| visible=True | |
| ) | |
| answers.append(radio) | |
| return quiz_container | |
| def process_answers(answers): | |
| processed = [] | |
| for i, ans in enumerate(answers): | |
| if ans is not None: | |
| processed.append([i]) | |
| return processed | |
| questions_display = gr.JSON(visible=False) # Hidden JSON storage | |
| quiz_area = gr.Group(visible=False) # Container for dynamic quiz content | |
| submit_btn = gr.Button("Submit Assessment", variant="primary", visible=False) | |
| score_display = gr.Number(label="Your Score", visible=False) | |
| # Update the question display when questions are generated | |
| questions_display.change( | |
| fn=lambda q: ( | |
| gr.Group(visible=True), | |
| gr.Button(visible=True), | |
| format_questions(q) | |
| ), | |
| inputs=[questions_display], | |
| outputs=[quiz_area, submit_btn, current_questions] | |
| ) | |
| # Step 3: Get Certified | |
| with gr.Tab("🎓 Step 3: Get Certified", id=2) as tab3: | |
| gr.Markdown(""" | |
| ### Certification | |
| - Your certificate will be generated automatically if you score 80% or above | |
| - The certificate includes your name, score, and completion date | |
| - Company logo and photo will be included if provided | |
| - You can download your certificate once it's generated | |
| """) | |
| course_name = gr.Textbox( | |
| label="Certification Title", | |
| value="Professional Assessment Certification" | |
| ) | |
| certificate_display = gr.Image(label="Your Certificate") | |
| # Helper functions for tab navigation | |
| def generate_and_switch_tab(text, num_questions): | |
| questions = quiz_app.generate_questions(text, num_questions) | |
| return questions, 1, gr.Markdown(visible=True), gr.Button(visible=True) | |
| def calculate_score(selected_answers, questions): | |
| correct = 0 | |
| total = len(questions) | |
| for q, ans in zip(questions, selected_answers): | |
| if set(ans) == set(q["correct_answers"]): | |
| correct += 1 | |
| score = (correct / total) * 100 if total > 0 else 0 | |
| return score, 2 | |
| # Event handlers | |
| generate_btn.click( | |
| fn=generate_and_switch_tab, | |
| inputs=[text_input, num_questions], | |
| outputs=[questions_display, current_tab, quiz_area, submit_btn] | |
| ).then( | |
| fn=lambda tab: gr.Tabs(selected=tab), | |
| inputs=[current_tab], | |
| outputs=[tabs] | |
| ) | |
| submit_btn.click( | |
| fn=calculate_score, | |
| inputs=[user_answers, current_questions], | |
| outputs=[score_display, current_tab] | |
| ).then( | |
| fn=lambda tab: gr.Tabs(selected=tab), | |
| inputs=[current_tab], | |
| outputs=[tabs] | |
| ) | |
| # Certificate generation remains the same | |
| score_display.change( | |
| fn=lambda score, user_name, course, logo, photo: ( | |
| quiz_app.generate_certificate(user_name, score, course, logo, photo) | |
| if score >= 80 else None | |
| ), | |
| inputs=[score_display, name, course_name, company_logo, participant_photo], | |
| outputs=certificate_display | |
| ) | |
| return demo | |
| # Main execution remains the same | |
| if __name__ == "__main__": | |
| if not os.getenv("GROQ_API_KEY"): | |
| print("Please set your GROQ_API_KEY environment variable") | |
| exit(1) | |
| demo = create_quiz_app() | |
| demo.launch() |