app.py

import os
import streamlit as st
from dotenv import load_dotenv
from docx import Document
import fitz  # PyMuPDF
import google.generativeai as genai


def extract_text_from_pdf(file):
    """Extract text from PDF."""
    text = ""
    doc = fitz.open(stream=file.read(), filetype="pdf")
    for page in doc:
        text += page.get_text()
    return text

def create_multiple_choice_prompt(num_questions, quiz_context, expertise):
    """Create the prompt template for multiple-choice quiz."""
    template = f"""
You are an expert in {expertise}. Generate a quiz with {num_questions} multiple-choice questions that are relevant to {expertise} based on the following content: {quiz_context}.

The questions should be at the level of {expertise} and should challenge the knowledge of someone proficient in this field.
For each question, also specify the Bloom's Taxonomy level it corresponds to, choosing from the following levels:
1. Remember
2. Understand
3. Apply
4. Analyze
5. Evaluate
6. Create

The format of the quiz is as follows:
- Multiple-choice:
- Questions:
    1. <Question1>:
        a. Answer 1
        b. Answer 2
        c. Answer 3
        d. Answer 4

    2. <Question2>:
        a. Answer 1
        b. Answer 2
        c. Answer 3
        d. Answer 4
    ....
- Answers:
    1. <a|b|c|d>
    2. <a|b|c|d>
    ....
Example:
- Questions:
    1. What is the time complexity of a binary search tree?
        a. O(n)
        b. O(log n)
        c. O(n^2)
        d. O(1)
- Answers:
    1. b
"""
    return template

def create_true_false_prompt(num_questions, quiz_context, expertise):
    """Create the prompt template for true-false quiz."""
    template = f"""
You are an expert in {expertise}. Generate a quiz with {num_questions} true-false questions that are relevant to {expertise} based on the following content: {quiz_context}.

The questions should be at the level of {expertise} and should challenge the knowledge of someone proficient in this field.
For each question, also specify the Bloom's Taxonomy level it corresponds to, choosing from the following levels:
1. Remember
2. Understand
3. Apply
4. Analyze
5. Evaluate
6. Create

The format of the quiz is as follows:
- True-false:
- Questions:
    1. <Question1>: <True|False>
    2. <Question2>: <True|False>
    .....
- Answers:
    1. <True|False>
    2. <True|False>
    .....
Example:
- Questions:
    1. A binary search tree is a type of data structure.
    2. Binary search trees are typically used for sorting and searching operations.
- Answers:
    1. True
    2. True
"""
    return template

def create_open_ended_prompt(num_questions, quiz_context, expertise):
    """Create the prompt template for open-ended quiz."""
    template = f"""
You are an expert in {expertise}. Generate a quiz with {num_questions} open-ended questions that are relevant to {expertise} based on the following content: {quiz_context}.

The questions should be at the level of {expertise} and should challenge the knowledge of someone proficient in this field.
For each question, also specify the Bloom's Taxonomy level it corresponds to, choosing from the following levels:
1. Remember
2. Understand
3. Apply
4. Analyze
5. Evaluate
6. Create

The format of the quiz is as follows:
- Open-ended:
- Questions:
    1. <Question1>
    2. <Question2>
    ....
Example:
- Questions:
    1. What is a binary search tree?
    2. How are binary search trees implemented?
"""
    return template

def create_fill_in_the_blank_prompt(num_questions, quiz_context, expertise):
    """Create the prompt template for fill-in-the-blank quiz."""
    template = f"""
You are an expert in {expertise}. Generate a quiz with {num_questions} fill-in-the-blank questions that are relevant to {expertise} based on the following content: {quiz_context}.

The questions should be at the level of {expertise} and should challenge the knowledge of someone proficient in this field.
For each question, also specify the Bloom's Taxonomy level it corresponds to, choosing from the following levels:
1. Remember
2. Understand
3. Apply
4. Analyze
5. Evaluate
6. Create

The format of the quiz is as follows:
- Fill-in-the-blank:
- Questions:
    1. <Question1>: <Fill-in-the-blank>
    2. <Question2>: <Fill-in-the-blank>
    ....
Example:
- Questions:
    1. A binary search tree is a ________ data structure.
    2. Binary search trees are implemented using ________.
- Answers:
    1. hierarchical
    2. linked lists
"""
    return template

def create_mixed_questions_prompt(num_questions, quiz_context, expertise):
    """Create the prompt template for a mix of all question types."""
    template = f"""
You are an expert in {expertise}. Generate a quiz with exactly {num_questions} questions that include a random mix of multiple-choice, true-false, open-ended, and fill-in-the-blank questions relevant to {expertise} based on the following content: {quiz_context}.

The questions should be at the level of {expertise} and should challenge the knowledge of someone proficient in this field. Ensure that the questions are randomly mixed among the different types.
For each question, also specify the Bloom's Taxonomy level it corresponds to, choosing from the following levels:
1. Remember
2. Understand
3. Apply
4. Analyze
5. Evaluate
6. Create

The format of the quiz is as follows:
- Mixed Questions:
- Questions:
    1. <Question1> (Question type):
        <Answers if applicable>

    2. <Question2> (Question type):
        <Answers if applicable>

    3. <Question3> (Question type):
        <Answers if applicable>

    ...
    {num_questions}. <Question{num_questions}> (Question type):
        <Answers if applicable>

Example:
- Questions:
    1. What is the time complexity of a binary search tree? (Multiple-choice)
        a. O(n)
        b. O(log n)
        c. O(n^2)
        d. O(1)
    2. A binary search tree is a type of data structure. (True/False)
    3. What is a binary search tree? (Open-ended)
    4. A binary search tree is a ________ data structure. (Fill-in-the-blank)
    5. Another sample question. (Multiple-choice)
        a. Sample 1
        b. Sample 2
        c. Sample 3
        d. Sample 4

- Answers:
    1. b
    2. True
    3. A binary search tree is a data structure used to store data in a sorted manner.
    4. hierarchical
    5. b

Note:Ensure there are exactly {num_questions} questions in total with a random mix of question types.Here only template is given if there are more than mentioned example questions generate questions by your own.
"""
    return template


def get_gemini_response(question, prompt):
    """Function to load Google Gemini model and provide queries as response."""
    model = genai.GenerativeModel('gemini-1.5-flash')
    response = model.generate_content([prompt, question])
    return response.text

def split_questions_answers(quiz_response):
    """Function that splits the questions and answers from the quiz response."""
    if "Answers:" in quiz_response:
        questions = quiz_response.split("Answers:")[0]
        answers = quiz_response.split("Answers:")[1]
    else:
        questions = quiz_response
        answers = "Answers section not found in the response."
    return questions, answers

def main():
    st.title("Question Generation Application")
    st.write("This app generates questions based on the uploaded document.")
    load_dotenv()
    genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
    
    uploaded_file = st.file_uploader("Upload a PDF document", type=["pdf"])
    if uploaded_file is not None:
        text = extract_text_from_pdf(uploaded_file)
        num_questions = st.number_input("Enter the number of questions", min_value=1, max_value=10, value=3)
        quiz_type = st.selectbox("Select the type of Question", ["multiple-choice", "true-false", "open-ended", "fill-in-the-blank", "mixed"])
        expertise = st.text_input("Enter the domain of the expertise to be generated.")

        if st.button("Generate Questions"):
            if quiz_type == "multiple-choice":
                prompt_template = create_multiple_choice_prompt(num_questions, text, expertise)
            elif quiz_type == "true-false":
                prompt_template = create_true_false_prompt(num_questions, text, expertise)
            elif quiz_type == "open-ended":
                prompt_template = create_open_ended_prompt(num_questions, text, expertise)
            elif quiz_type == "fill-in-the-blank":
                prompt_template = create_fill_in_the_blank_prompt(num_questions, text, expertise)
            else:  # mixed
                prompt_template = create_mixed_questions_prompt(num_questions, text, expertise)

            quiz_response = get_gemini_response(text, prompt_template)
            questions, answers = split_questions_answers(quiz_response)
            st.session_state.answers = answers
            st.session_state.questions = questions
            st.write(questions)
    
    if st.button("Show Answers"):
        st.markdown(st.session_state.questions)
        st.write("----")
        st.markdown(st.session_state.answers)

if __name__ == "__main__":
    main()