app.py

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}
        
        Return the response in this JSON format:
        {{
            "questions": [
                {{
                    "question": "Question text",
                    "options": ["option1", "option2", "option3", "option4"],
                    "correct_answers": [0, 1]
                }}
            ]
        }}
        Only return the JSON, no other text."""
        
        # Use Groq API directly
        response = client.chat.completions.create(
            messages=[{"role": "user", "content": prompt}],
            model="llama-3.2-3b-preview",
            temperature=0.7,
            max_tokens=1024
        )
        
        try:
            questions = json.loads(response.choices[0].message.content)
            self.current_questions = questions["questions"]
            return json.dumps(questions["questions"], indent=2)
        except json.JSONDecodeError:
            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:
            return 0
    
    def generate_certificate(self, name, score, course_name, company_logo=None, participant_photo=None):
        # Create certificate
        certificate = Image.new('RGB', (1200, 800), 'white')
        draw = ImageDraw.Draw(certificate)
        
        # Load a default font
        try:
            title_font = ImageFont.truetype("arial.ttf", 60)
            text_font = ImageFont.truetype("arial.ttf", 40)
        except:
            # Fallback to default font
            title_font = ImageFont.load_default()
            text_font = ImageFont.load_default()
        
        # Add certificate content
        draw.text((600, 100), "Certificate of Completion", font=title_font, fill='black', anchor="mm")
        draw.text((600, 300), f"This is to certify that", font=text_font, fill='black', anchor="mm")
        draw.text((600, 380), name, font=text_font, fill='black', anchor="mm")
        draw.text((600, 460), f"has successfully completed", font=text_font, fill='black', anchor="mm")
        draw.text((600, 540), course_name, font=text_font, fill='black', 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 to temporary file
        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
        certificate.save(temp_file.name)
        return temp_file.name

def create_quiz_app():
    quiz_app = QuizApp()
    
    with gr.Blocks(title="QuizForge AI") as demo:
        gr.Markdown("# QuizForge AI")
        gr.Markdown("### Generate personalized quizzes and earn certificates powered by AI")
        
        # User Information Tab
        with gr.Tab("Step 1: User Information"):
            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="Content for Quiz", 
                placeholder="Enter the text content for generating questions",
                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="Participant Photo (Optional)", type="filepath")
                
            generate_btn = gr.Button("Generate Quiz", variant="primary")
        
        # Quiz Tab
        with gr.Tab("Step 2: Take Quiz"):
            gr.Markdown("""
            ### Instructions:
            1. Questions will appear in JSON format below
            2. Each question has multiple options
            3. Enter answers as array indices (e.g., [0, 2] for first and third options)
            4. Submit when ready to get your score
            """)
            
            questions_display = gr.JSON(label="Questions")
            answers_input = gr.JSON(label="Your Answers (Enter indices of correct options)")
            submit_btn = gr.Button("Submit Answers", variant="primary")
            score_display = gr.Number(label="Your Score")
        
        # Certificate Tab
        with gr.Tab("Step 3: Get Certificate"):
            gr.Markdown("### Your certificate will be generated automatically if you score 80% or above")
            course_name = gr.Textbox(
                label="Course Name", 
                value="QuizForge AI Certification"
            )
            certificate_display = gr.Image(label="Certificate")
        
        # Event handlers
        generate_btn.click(
            fn=quiz_app.generate_questions,
            inputs=[text_input, num_questions],
            outputs=questions_display
        )
        
        submit_btn.click(
            fn=quiz_app.calculate_score,
            inputs=[answers_input],
            outputs=score_display
        )
        
        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(share=True)