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"""Generate {num_questions} multiple choice questions based on this text: | |
| {text} | |
| Format your response as a list of questions, where each question is a JSON object with the following structure: | |
| [ | |
| {{ | |
| "question": "Question text", | |
| "options": ["option1", "option2", "option3", "option4"], | |
| "correct_answers": [0, 1] | |
| }} | |
| ] | |
| Only return the JSON array, no other text.""" | |
| try: | |
| response = client.chat.completions.create( | |
| messages=[{"role": "user", "content": prompt}], | |
| model="llama2-70b-4096", | |
| temperature=0.7, | |
| max_tokens=1024 | |
| ) | |
| # Parse the response directly as a list | |
| questions = json.loads(response.choices[0].message.content) | |
| if isinstance(questions, list): | |
| self.current_questions = questions | |
| else: | |
| # If we get an object with a questions key, extract the list | |
| self.current_questions = questions.get("questions", []) | |
| return json.dumps(self.current_questions, indent=2) | |
| except Exception as e: | |
| print(f"Error generating questions: {e}") | |
| return json.dumps({"error": "Failed to generate valid questions. Please try again."}) | |
| def calculate_score(self, answers): | |
| try: | |
| answers = json.loads(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") as demo: | |
| # Store current tab state | |
| current_tab = gr.State(0) | |
| gr.Markdown(""" | |
| # CertifyMe AI | |
| ### Transform Your Knowledge into Recognized Achievements | |
| Get AI-powered assessments and professional certificates for any learning content. | |
| """) | |
| # Create tabs | |
| with gr.Tabs() as tabs: | |
| # Step 1: Profile Setup | |
| with gr.Tab("📋 Step 1: Profile Setup", id=0) as tab1: | |
| 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", | |
| placeholder="Enter the text content you want to be assessed on", | |
| lines=10 | |
| ) | |
| with gr.Row(): | |
| num_questions = gr.Slider( | |
| minimum=1, | |
| maximum=10, | |
| value=5, | |
| step=1, | |
| label="Number of 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") | |
| # Instructions for Step 1 | |
| gr.Markdown(""" | |
| ### Instructions: | |
| 1. Enter your full name and email | |
| 2. Paste or type the learning content you want to be assessed on | |
| 3. Select the number of questions for your assessment | |
| 4. Optionally upload a company logo and your photo for the certificate | |
| 5. Click 'Generate Assessment' to proceed | |
| """) | |
| # Step 2: Take Assessment | |
| with gr.Tab("📝 Step 2: Take Assessment", id=1) as tab2: | |
| gr.Markdown(""" | |
| ### Assessment Instructions: | |
| 1. Review each question carefully | |
| 2. For each question, you may select one or more correct options | |
| 3. Enter your answers as arrays of indices (e.g., [0, 2] for first and third options) | |
| 4. Click 'Submit Assessment' when you're ready | |
| 5. You need 80% or higher to earn your certificate | |
| """) | |
| questions_display = gr.JSON(label="Assessment Questions") | |
| answers_input = gr.JSON( | |
| label="Your Answers", | |
| placeholder="Enter answers as arrays of indices, e.g., [[0], [1, 2], [3]]" | |
| ) | |
| submit_btn = gr.Button("Submit Assessment", variant="primary") | |
| score_display = gr.Number(label="Your Score") | |
| # 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 | |
| def submit_and_switch_tab(answers): | |
| score = quiz_app.calculate_score(answers) | |
| return score, 2 | |
| # Event handlers | |
| generate_btn.click( | |
| fn=generate_and_switch_tab, | |
| inputs=[text_input, num_questions], | |
| outputs=[questions_display, current_tab] | |
| ).then( | |
| fn=lambda tab: gr.Tabs(selected=tab), | |
| inputs=[current_tab], | |
| outputs=[tabs] | |
| ) | |
| submit_btn.click( | |
| fn=submit_and_switch_tab, | |
| inputs=[answers_input], | |
| outputs=[score_display, current_tab] | |
| ).then( | |
| fn=lambda tab: gr.Tabs(selected=tab), | |
| inputs=[current_tab], | |
| outputs=[tabs] | |
| ) | |
| 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 | |
| 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() |