sync to remote

.gitignore

@@ -0,0 +1,171 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc

Exam_Maker.py

@@ -0,0 +1,214 @@
+import streamlit as st
+import sqlite3
+from passlib.hash import bcrypt
+import pandas as pd
+import re
+import warnings
+warnings.filterwarnings("ignore", message="module 'bcrypt' has no attribute '__about__'")
+if "is_starting" not in st.session_state:
+    st.session_state["is_starting"] = True
+
+if "authenticated" not in st.session_state:
+    st.session_state["authenticated"] = False
+
+#from pages.About import show_about
+#from pages.Text_prompt import show_text_prompt
+#from pages.Multimodal import show_multimodal
+#from pages.Settings import show_settings
+
+if "authenticated" not in st.session_state:
+    st.session_state["authenticated"] = False
+
+def create_usertable():
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('CREATE TABLE IF NOT EXISTS userstable(username TEXT, password BLOB)')
+    c.execute('CREATE TABLE IF NOT EXISTS system_instructions(username TEXT PRIMARY KEY, instruction TEXT)')
+    c.execute('CREATE TABLE IF NOT EXISTS user_prompts(id INTEGER PRIMARY KEY AUTOINCREMENT, username TEXT, prompt_time TEXT, prompt_type TEXT)')
+    conn.commit()
+    conn.close()
+
+def add_userdata(username, password):
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('INSERT INTO userstable(username, password) VALUES (?,?)', (username, password))
+    conn.commit()
+    conn.close()
+
+def login_user(username, password):
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('SELECT password FROM userstable WHERE username =?', (username,))
+    stored_hash = c.fetchone()
+    conn.close()
+    
+    if stored_hash:
+        stored_hash = stored_hash[0]
+        return check_hashes(password, stored_hash)
+    else:
+        return False
+
+def view_all_users():
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('SELECT * FROM userstable')
+    data = c.fetchall()
+    conn.close()
+    return data
+
+# --- Hashing ---
+def make_hashes(password):
+    return bcrypt.hash(password)
+
+def check_hashes(password, hashed_text):
+    return bcrypt.verify(password, hashed_text)
+
+# --- Authentication ---
+def authenticate(username, password):
+    return login_user(username, password)
+
+def logout():
+    del st.session_state["authenticated"]
+    del st.session_state["username"]
+    del st.session_state["page"]
+
+# --- Initialize session state ---
+if "authenticated" not in st.session_state:
+    st.session_state["authenticated"] = False
+if "username" not in st.session_state:
+    st.session_state["username"] = None
+if "page" not in st.session_state:
+    st.session_state["page"] = "login"
+
+# --- Login page ---
+def login_page():
+    st.title("WVSU Exam Maker")
+    st.subheader("User Login")
+    username = st.text_input("User Name")
+    password = st.text_input("Password", type='password')
+    if st.button("Login"):
+        result = authenticate(username.lower(), password)
+        if result:
+            st.session_state["authenticated"] = True
+            st.session_state["username"] = username
+            st.success("Logged In as {}".format(username))
+            st.session_state["page"] = "main"
+            st.session_state["is_starting"] = False
+            st.rerun()
+        else:
+            st.warning("Incorrect Username/Password")
+
+    st.write("Don't have an account? Click Signup.")
+    # --- Signup button ---
+    if st.button("Signup"):
+        st.session_state["page"] = "signup"
+        st.rerun()
+
+# --- Signup page ---
+def signup_page():
+    st.subheader("Create New Account")
+    new_user = st.text_input("Username")
+    new_password = st.text_input("Password", type='password')
+    
+    # Display password requirements
+    st.write("Password Requirements:")
+    st.write("* Minimum length: 8 characters")
+    st.write("* Mix of uppercase and lowercase letters")
+    st.write("* At least one number")
+    st.write("* At least one special character")
+    
+    # Validate password strength
+    col1, col2 = st.columns([1, 1])
+    if col1.button("Signup"):
+        password_strength = validate_password(new_password)
+        if password_strength:
+            # Check if username already exists
+            conn = sqlite3.connect('users.db')
+            c = conn.cursor()
+            c.execute('SELECT * FROM userstable WHERE username=?', (new_user,))
+            existing_user = c.fetchone()
+            conn.close()
+            
+            if existing_user:
+                st.error("Username already exists. Please choose a different username.")
+            else:
+                hashed_new_password = make_hashes(new_password.encode("utf-8"))
+                add_userdata(new_user, hashed_new_password)
+                st.success("You have successfully created a valid Account")
+                st.info("Go to Login Menu to login")
+                st.session_state["page"] = "login"
+                st.rerun()
+        else:
+            st.error("Password does not meet the requirements.")
+    if col2.button("Cancel"):
+        st.session_state["page"] = "login"
+        st.rerun()
+
+# --- Validate password strength ---
+def validate_password(password):
+    # Define password requirements
+    min_length = 8
+    has_uppercase = re.search(r"[A-Z]", password)
+    has_lowercase = re.search(r"[a-z]", password)
+    has_number = re.search(r"\d", password)
+    has_symbol = re.search(r"[!@#$%^&*()_+=-{};:'<>,./?]", password)
+    
+    # Check if password meets all requirements
+    if (len(password) >= min_length and 
+        has_uppercase and 
+        has_lowercase and 
+        has_number and 
+        has_symbol):
+        return True
+    else:
+        return False
+
+# --- Manage users page ---
+def manage_users_page():
+    st.subheader("User Management")
+    user_result = view_all_users()
+    clean_db = pd.DataFrame(user_result, columns=["Username", "Password"])
+    st.dataframe(clean_db)
+
+# --- Main app ---
+def main():
+    create_usertable()
+
+    if st.session_state["page"] == "login":
+        login_page()
+    elif st.session_state["page"] == "signup":
+        signup_page()
+    else:
+
+        msg = """
+# Welcome to the WVSU Exam Maker!
+
+We are excited to introduce you to the WVSU Exam Maker, a cutting-edge tool designed to assist faculty members of West Visayas State University in creating comprehensive exams with ease.
+
+### Empowering Teachers, Enhancing Education
+
+With the WVSU Exam Maker, you can generate high-quality exam questions in various formats, saving you time and effort. Our innovative app leverages the latest AI technology from Google Gemini 2 to help you create exams that are both effective and engaging.
+
+### Explore the Possibilities
+
+• **Streamline exam creation**: Generate questions in multiple formats, including Multiple Choice, True or False, Short Response, and Essay.
+• **Enhance exam accuracy**: Review and refine AI-generated questions to ensure accuracy and relevance.
+• **Simplify exam preparation**: Use our intuitive interface to define exam requirements and upload reference materials.
+
+### Get Started Today!
+
+We invite you to explore the WVSU Exam Maker and discover how it can support your teaching and assessment needs. 
+
+Thank you for using the WVSU Exam Maker!
+"""
+        st.markdown(msg)
+    
+        # Display username and logout button on every page
+        st.sidebar.write(f"Welcome, {st.session_state['username']}")
+        if st.sidebar.button("Logout"):
+            logout()
+            st.rerun()
+
+ 
+if __name__ == "__main__":
+    main()

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Louie F. Cervantes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pages/1_About.py

@@ -0,0 +1,45 @@
+import streamlit as st
+
+def show_about():
+    about = """
+### WVSU Exam Maker: A Faculty Guide
+
+The WVSU Exam Maker is a cutting-edge tool designed to assist faculty members of West Visayas State University in creating comprehensive exams with ease. Leveraging the latest AI technology from Google Gemini 2, this innovative app helps teachers generate questions in various formats, including:
+
+
+* **Multiple Choice**: Assess students' knowledge with objective, structured questions.
+* **True or False**: Evaluate students' understanding with concise, binary questions.
+* **Short Response**: Encourage students to provide brief, written answers.
+* **Essay**: Foster critical thinking and in-depth writing with longer, more open-ended questions.
+
+
+## Key Features
+
+### Text Prompt Page
+Define exam requirements with precision using various input options.
+
+
+### Multimodal Prompt Page
+Upload reference documents (PDF or image) to generate questions, including:
+
+
+* Lecture materials
+* Tables of specifications
+* Rubrics
+* Other relevant inputs
+
+
+## Important Note
+While the WVSU Exam Maker utilizes advanced AI technology, it is essential to review the output carefully, as AI can make mistakes. User supervision is necessary to ensure accuracy.
+
+## Development Team
+The WVSU Exam Maker was developed by the AI Research Team of the Management Information System Office.
+"""
+    # Add your About page content here
+    st.markdown(about)
+
+if st.session_state["authenticated"]:
+    show_about()   
+else:
+    if not st.session_state["is_starting"]:
+        st.write("You are not authenticated. Please log in to access this page.") 

pages/2_Text_prompt.py

@@ -0,0 +1,208 @@
+import streamlit as st
+import sqlite3
+import time
+import datetime
+from PIL import Image
+import google.generativeai as genai
+import os
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import A4, letter 
+from io import BytesIO
+import tempfile
+import json
+import re
+from reportlab.platypus import Paragraph, Frame, Spacer
+from reportlab.lib.styles import getSampleStyleSheet
+import shutil
+from pdfutils import generate_quiz_content, create_pdf, create_json, generate_metadata, merge_json_strings, generate_text, clean_markdown
+
+MODEL_ID = "gemini-2.0-flash-exp" 
+api_key = os.getenv("GEMINI_API_KEY")
+model_id = MODEL_ID
+genai.configure(api_key=api_key)
+
+if "model" not in st.session_state:
+    st.session_state.model = genai.GenerativeModel(MODEL_ID)
+
+if "chat" not in st.session_state:
+    st.session_state.chat = st.session_state.model.start_chat()
+
+def get_system_instruction(username):
+    """ Retrieves the system instruction for the user from the database. """
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('SELECT instruction FROM system_instructions WHERE username=?', (username,))
+    instruction = c.fetchone()
+    conn.close()
+    if instruction:
+        return instruction[0]
+    else:
+        return "Default system instruction."
+
+def save_user_prompt(username, prompt_time, prompt_type):
+    """ Saves the user prompt to the database for monitoring purposes. """
+
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('INSERT INTO user_prompts(username, prompt_time, prompt_type) VALUES (?,?,?)', (username, prompt_time, prompt_type))
+    conn.commit()
+    conn.close()
+
+def show_text_prompt():
+    st.subheader("Text Prompt")
+
+    username = st.session_state["username"]
+    st.write(f"Welcome, {username}! This page allows you to generate questions based on user inputs.")
+
+    # Display username and logout button on every page
+    st.sidebar.write(f"Current user: {st.session_state['username']}")
+
+    # User inputs
+    # Course selection
+    course = st.text_input("Enter Course", 
+                        "e.g.,Bachelor of Secondary Education")
+
+    # Year level selection
+    year_level = st.selectbox("Select Year Level", 
+                            ["1st Year", 
+                            "2nd Year", 
+                            "3rd Year", 
+                            "4th Year"])
+
+     # Subject selection
+    subject = st.text_input("Enter Subject", 
+                        "e.g.,The Teaching Profession, Facilitating Learner-Centered Teaching")
+
+    # Topic selection
+    topic = st.text_input("Enter Topic", 
+                        "e.g., Teacher as a professional, Introduction to Learner-Centered Teaching")
+
+    # Question type selection
+    question_type = st.selectbox("Select Question Type", 
+                                ["Multiple Choice", 
+                                "True or False", 
+                                "Short Response", 
+                                "Essay Type"])
+
+    difficulty = st.selectbox("Select Difficulty",["easy","average","hard"])
+
+    #number of questions to generate
+    if question_type != "Essay Type":
+        num_questions = st.selectbox("Number of Questions to Generate",
+                                [10, 20, 30, 40, 50])  
+    else:
+        num_questions = st.selectbox("Number of Questions to Generate",
+                                [1, 2, 3, 4, 5]) 
+
+    # Combine user inputs into a prompt
+    prompt = f"""Refer to the uploaded document. Generate a {question_type} question for a {year_level} {course} student
+                    in {subject} on the topic of {topic} with a {difficulty} difficulty level.
+                    The questions should require higher order thinking skills. 
+                    """
+
+    if question_type == "Multiple Choice":    
+        prompt += """Provide 4 choices. Provide the correct answer in the format 'Answer: A'.
+        Use the following JSON format for each question:
+        [{
+        "question": "Your question here?",
+        "options": ["Option A", "Option B", "Option C", "Option D"],
+        "correct_answer": "full text of the correct answer"
+        }, ... more questions]
+        Ensure that the response only contains the JSON array of questions and nothing else.
+        """
+    elif question_type == "True or False":
+        prompt += """Indicate whether the statement is true or false. Keep the statement brief and concise.
+                    Use the following JSON format for each question:
+                    [{
+                    "statement": "Your statement here",
+                    "options": ["True", "False"],
+                    "correct_answer": True"
+                    }, ... more questions]
+                    Ensure that the response only contains the JSON array of questions and nothing else.    
+                    """   
+    elif question_type == "Short Response":
+        prompt += """Create question that require a word or short phrase as answer.  Use the following JSON format for each question:
+                    [{
+                    "question": "Your question here?",
+                    "correct_answer": A word or phrase"
+                    },  ... more questions]
+                    Ensure that the response only contains the JSON array of questions and nothing else.
+                    """
+    elif question_type == "Essay Type":
+        prompt += """Create questions that require a short essay between 300 to 500 words. 
+                    Provide a detailed answer. Use the following JSON format for each question:
+                    [{
+                    "question": "Your question here?",
+                    "correct_answer": The essay answer goes here."
+                    }, ... more questions]
+                    Ensure that the response only contains the JSON array of questions and nothing else.
+                    """
+
+    if not question_type == "Essay Type":
+        prompt += f"Generate 10 questions. Do not repeat questions you have already given in previous prompts. Exclude markdown tags in the response."
+    else:
+        prompt += f" Generate {num_questions} questions. Do not repeat questions you have already given in previous prompts. Exclude markdown tags in the response"  
+
+    full_quiz = ""    
+    
+    # Send button
+    if st.button("Generate Questions"):
+
+        if question_type == "Essay Type":
+            #prompt once
+            with st.spinner('Generating questions...'):
+                full_quiz = clean_markdown(generate_text(prompt))  
+
+        else:
+            if num_questions == 10:
+
+                #prompt once
+                with st.spinner('Generating questions...'):
+                    full_quiz = clean_markdown(generate_text(prompt))
+            else:
+                #prompt multiple times
+                times = num_questions//10
+                for i in range(times):
+                    with st.spinner('Generating questions...'):
+                        response = generate_text(prompt)  
+
+                        if i==0:
+                            full_quiz = clean_markdown(response)
+                        else:                        
+                            full_quiz = merge_json_strings(full_quiz, response) 
+
+        metadata = generate_metadata(subject, topic, num_questions, question_type)
+
+        try:
+            # Attempt to load the string as JSON to validate it            
+            content = json.loads(full_quiz)
+        except json.JSONDecodeError:
+            st.error("Error: Invalid JSON string for quiz content.")
+            st.stop()
+
+        json_string = create_json(metadata, content)
+        
+        quiz_markdown = generate_quiz_content(json_string)
+        st.markdown(quiz_markdown)
+
+        pdf_path = create_pdf(json_string)
+        
+        if pdf_path:
+            """Click the button to download the generated PDF."""
+            try:
+                with open(pdf_path, "rb") as f:
+                    st.download_button("Download PDF", f, file_name=os.path.basename(pdf_path))
+            except Exception as e:
+                st.error(f"Error handling file download: {e}")
+        else:
+            st.error("Failed to generate the PDF. Please try again.")
+
+        #record the prompt for monitoring
+        save_user_prompt(username, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "Multimodal")
+
+if st.session_state["authenticated"]:
+    show_text_prompt()
+
+else:
+    if not st.session_state["is_starting"]:
+        st.write("You are not authenticated. Please log in to access this page.")   

pages/3_Multimodal.py

@@ -0,0 +1,639 @@
+import streamlit as st
+import sqlite3
+import time
+import datetime
+from PIL import Image
+import google.generativeai as genai
+import os
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import A4, letter 
+from io import BytesIO
+import tempfile
+import json
+import re
+from reportlab.platypus import Paragraph, Frame, Spacer
+from reportlab.lib.styles import getSampleStyleSheet
+import shutil
+
+MODEL_ID = "gemini-2.0-flash-exp" 
+api_key = os.getenv("GEMINI_API_KEY")
+model_id = MODEL_ID
+genai.configure(api_key=api_key)
+enable_stream = False
+
+if "model" not in st.session_state:
+    st.session_state.model = genai.GenerativeModel(MODEL_ID)
+
+if "chat" not in st.session_state:
+    st.session_state.chat = st.session_state.model.start_chat()
+
+if "is_new_file" not in st.session_state:
+    st.session_state.is_new_file = True
+
+def get_system_instruction(username):
+    """ Retrieves the system instruction for the user from the database. """
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('SELECT instruction FROM system_instructions WHERE username=?', (username,))
+    instruction = c.fetchone()
+    conn.close()
+    if instruction:
+        return instruction[0]
+    else:
+        return "Default system instruction."
+
+def save_user_prompt(username, prompt_time, prompt_type):
+    """ Saves the user prompt to the database for monitoring purposes. """
+
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('INSERT INTO user_prompts(username, prompt_time, prompt_type) VALUES (?,?,?)', (username, prompt_time, prompt_type))
+    conn.commit()
+    conn.close()
+
+def merge_json_strings(json_str1, json_str2):
+    """
+    Merges two JSON strings into one, handling potential markdown tags.
+
+    Args:
+        json_str1: The first JSON string, potentially with markdown tags.
+        json_str2: The second JSON string, potentially with markdown tags.
+
+    Returns:
+        A cleaned JSON string representing the merged JSON objects.
+    """
+
+    # Clean the JSON strings by removing markdown tags
+    cleaned_json_str1 = _clean_markdown(json_str1)
+    cleaned_json_str2 = _clean_markdown(json_str2)
+
+    try:
+        # Parse the cleaned JSON strings into Python dictionaries
+        data1 = json.loads(cleaned_json_str1)
+        data2 = json.loads(cleaned_json_str2)
+
+        # Merge the dictionaries
+        merged_data = _merge_dicts(data1, data2)
+
+        # Convert the merged dictionary back into a JSON string
+        return json.dumps(merged_data, indent=2)
+    except json.JSONDecodeError as e:
+        return f"Error decoding JSON: {e}"
+
+
+def _clean_markdown(text):
+    """
+    Removes markdown tags from a string if they exist. 
+    Otherwise, returns the original string unchanged.
+
+    Args:
+        text: The input string.
+
+    Returns:
+        The string with markdown tags removed, or the original string 
+        if no markdown tags were found.
+    """
+    try:
+        # Check if the string contains markdown 
+        if re.match(r"^```json\s*", text) and re.search(r"\s*```$", text):
+            # Remove leading ```json
+            text = re.sub(r"^```json\s*", "", text) 
+            # Remove trailing ```
+            text = re.sub(r"\s*```$", "", text) 
+        return text
+    except Exception as e:
+        # Log the error 
+        st.error(f"Error cleaning markdown: {e}") 
+        return None
+
+def _merge_dicts(data1, data2):
+    """
+    Recursively merges two data structures.
+
+    Handles merging of dictionaries and lists. 
+    For dictionaries, if a key exists in both and both values are dictionaries 
+    or lists, they are merged recursively. Otherwise, the value from data2 is used.
+    For lists, the lists are concatenated.
+
+    Args:
+        data1: The first data structure (dictionary or list).
+        data2: The second data structure (dictionary or list).
+
+    Returns:
+        The merged data structure.
+
+    Raises:
+        ValueError: If the data types are not supported for merging.
+    """
+    if isinstance(data1, dict) and isinstance(data2, dict):
+        for key, value in data2.items():
+            if key in data1 and isinstance(data1[key], (dict, list)) and isinstance(value, type(data1[key])):
+                _merge_dicts(data1[key], value)
+            else:
+                data1[key] = value
+        return data1
+    elif isinstance(data1, list) and isinstance(data2, list):
+        return data1 + data2
+    else:
+        raise ValueError("Unsupported data types for merging")
+
+def create_json(metadata, content):
+    """
+    Creates a JSON string combining metadata and content.
+
+    Args:
+        metadata: A dictionary containing metadata information.
+        content: A dictionary containing the quiz content.
+
+    Returns:
+        A string representing the combined JSON data.
+    """
+
+    # Create metadata with timestamp
+    metadata = {
+        "subject": metadata.get("subject", ""),
+        "topic": metadata.get("topic", ""),
+        "num_questions": metadata.get("num_questions", 0),
+        "exam_type": metadata.get("exam_type", ""),
+        "timestamp": datetime.datetime.now().isoformat()
+    }
+
+    # Combine metadata and content
+    combined_data = {"metadata": metadata, "content": content}
+
+    # Convert to JSON string
+    json_string = json.dumps(combined_data, indent=4)
+
+    return json_string
+
+def create_pdf(data):
+    """
+    Creates a PDF file with text wrapping for quiz content, supporting multiple question types.
+    """
+    try:
+        # Load the JSON data
+        data = json.loads(data)
+
+        if 'metadata' not in data or 'content' not in data:
+            st.error("Error: Invalid data format. Missing 'metadata' or 'content' keys.")
+            return None
+
+        metadata = data['metadata']
+        content = data['content']
+
+        # Validate metadata
+        required_metadata_keys = ['subject', 'topic', 'exam_type', 'num_questions']
+        if not all(key in metadata for key in required_metadata_keys):
+            st.error("Error: Invalid metadata format. Missing required keys.")
+            return None
+
+        # Create a unique filename with timestamp
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        pdf_filename = f"quiz_output_{timestamp}.pdf"
+        temp_dir = tempfile.gettempdir()
+        pdf_path = os.path.join(temp_dir, pdf_filename)
+
+        c = canvas.Canvas(pdf_path, pagesize=A4)
+        c.setFont("Helvetica", 10)
+
+        styles = getSampleStyleSheet()
+        text_style = styles['Normal']
+
+        # Starting position
+        margin_left = 50
+        y_position = 750
+        line_height = 12  # Adjusted for tighter spacing
+        frame_width = 500
+        first_page = True
+
+        def wrap_text_draw(text, x, y):
+            """
+            Wraps and draws text using ReportLab's Paragraph for automatic line breaks.
+            """
+            p = Paragraph(text, text_style)
+            width, height = p.wrap(frame_width, y)
+            p.drawOn(c, x, y - height)
+            return height
+
+        # Print metadata once on the first page
+        if first_page:
+            for key, label in [("subject", "Subject"), ("topic", "Topic"),
+                                ("exam_type", "Type"), ("num_questions", "Number of Questions")]:
+                c.drawString(margin_left, y_position, f"{label}: {metadata[key]}")
+                y_position -= line_height
+            y_position -= line_height
+            first_page = False
+
+        # Render questions and options
+        for idx, q in enumerate(content):
+            if not isinstance(q, dict):
+                st.error(f"Error: Invalid question format at index {idx}. Skipping...")
+                continue
+
+            question_text = f"{idx + 1}. {q.get('question', q.get('statement', ''))}"
+            height = wrap_text_draw(question_text, margin_left, y_position)
+            y_position -= (height + line_height)
+
+            if y_position < 50:
+                c.showPage()
+                c.setFont("Helvetica", 10)
+                y_position = 750
+
+            # Handle specific exam types
+            exam_type = metadata['exam_type']
+
+            if exam_type == "Multiple Choice":
+                for option_idx, option in enumerate(q['options'], ord('a')):
+                    option_text = f"{chr(option_idx)}) {option}"
+                    height = wrap_text_draw(option_text, margin_left + 20, y_position)
+                    y_position -= (height + line_height)
+
+                    if y_position < 50:
+                        c.showPage()
+                        c.setFont("Helvetica", 10)
+                        y_position = 750
+
+                # Print correct answer
+                correct_answer_text = f"Correct Answer: {q['correct_answer']}"
+                height = wrap_text_draw(correct_answer_text, margin_left + 20, y_position)
+                y_position -= (height + line_height)
+
+            elif exam_type == "True or False":
+                for option in q['options']:
+                    height = wrap_text_draw(option, margin_left + 20, y_position)
+                    y_position -= (height + line_height)
+
+                    if y_position < 50:
+                        c.showPage()
+                        c.setFont("Helvetica", 10)
+                        y_position = 750
+
+                correct_answer_text = f"Correct Answer: {q['correct_answer']}"
+                height = wrap_text_draw(correct_answer_text, margin_left + 20, y_position)
+                y_position -= (height + line_height)
+
+            elif exam_type in ["Short Response", "Essay Type"]:
+                answer_text = f"Correct Answer: {q['correct_answer']}"
+                height = wrap_text_draw(answer_text, margin_left + 20, y_position)
+                y_position -= (height + line_height)
+
+            if y_position < 50:
+                c.showPage()
+                c.setFont("Helvetica", 10)
+                y_position = 750
+
+        # Add a footer
+        notice = "This exam was generated by the WVSU Exam Maker (c) 2025 West Visayas State University"
+        c.drawString(margin_left, y_position, notice)
+
+        c.save()
+        return pdf_path
+
+    except Exception as e:
+        st.error(f"Error creating PDF: {e}")
+        return None
+    
+def generate_quiz_content(data):
+    """
+    Separates the metadata and content from a JSON string containing exam data.
+    Creates a markdown formatted text that contains the exam metadata and 
+    enumerates the questions, options and answers nicely formatted for readability.
+
+    Args:
+      data: A JSON string containing the exam data.
+
+    Returns:
+      A markdown formatted string.
+    """
+    data = json.loads(data)
+    metadata = data["metadata"]
+    content = data["content"]
+    exam_type = metadata["exam_type"]
+    if exam_type == "Multiple Choice":
+        md_text = f"""# {metadata['subject']} - {metadata['topic']}
+
+**Exam Type:** {metadata['exam_type']}  
+**Number of Questions:** {metadata['num_questions']}  
+**Timestamp:** {metadata['timestamp']}
+
+---
+
+"""
+        for i, q in enumerate(content):
+            md_text += f"""Question {i+1}:
+            {q['question']}
+
+"""
+            for j, option in enumerate(q['options'], ord('a')):
+                md_text += f"""{chr(j)}. {option}  
+
+"""
+            md_text += f"""**Correct Answer:** {q['correct_answer']}
+
+---
+
+"""
+        md_text += """This exam was generated by the WVSU Exam Maker
+            (c) 2025 West Visayas State University
+"""
+            
+    elif exam_type == "True or False":
+        md_text = f"""# {metadata['subject']} - {metadata['topic']}
+
+**Exam Type:** {metadata['exam_type']}  
+**Number of Questions:** {metadata['num_questions']}  
+**Timestamp:** {metadata['timestamp']}
+
+---
+
+"""
+
+        for i, q in enumerate(content):
+            md_text += f"""Statement {i+1}:
+
+{q['statement']}
+
+"""
+            for j, option in enumerate(q['options'], ord('a')):
+                md_text += f"""{option}  
+"""
+
+            md_text += f"""**Correct Answer:** {q['correct_answer']}
+
+---
+"""
+        md_text += """This exam was generated by the WVSU Exam Maker
+(c) 2025 West Visayas State University"""
+
+    elif exam_type == "Short Response" or exam_type == "Essay Type":
+        md_text = f"""# {metadata['subject']} - {metadata['topic']}
+
+**Exam Type:** {metadata['exam_type']}  
+**Number of Questions:** {metadata['num_questions']}  
+**Timestamp:** {metadata['timestamp']}
+
+---
+
+"""
+
+        for i, q in enumerate(content):
+            md_text += f"""Question {i+1}:
+
+{q['question']}
+
+"""
+            md_text += f"""**Correct Answer:** {q['correct_answer']}
+
+---
+"""
+        md_text += """This exam was generated by the WVSU Exam Maker
+(c) 2025 West Visayas State University"""
+
+    return md_text
+    
+def generate_metadata(subject, topic, num_questions, exam_type):
+    """Generates quiz metadata as a dictionary combining num_questions, 
+    exam_type, and timestamp.
+
+    Args:
+        num_questions: The number of questions in the exam (int).
+        exam_type: The type of exam (str).
+
+    Returns:
+        A dictionary containing the quiz metadata.
+    """
+
+    # Format the timestamp
+    timestamp = datetime.datetime.now()
+    formatted_timestamp = timestamp.strftime("%Y-%m-%d %H:%M:%S") 
+    
+    metadata = {
+        "subject": subject,
+        "topic": topic,
+        "num_questions": num_questions,
+        "exam_type": exam_type,
+        "timestamp": formatted_timestamp
+    }
+
+    return metadata
+
+def generate_text(uploaded_file, mime_type, prompt):
+    """Generates text based on the uploaded file and prompt."""
+    try:
+        if st.session_state.is_new_file:
+            # Upload the file with the correct MIME type
+            file_data = genai.upload_file(uploaded_file, mime_type=mime_type)
+
+            # Send file and prompt to Gemini API
+            chat = st.session_state.chat
+            response = chat.send_message(
+                [
+                    prompt, 
+                    file_data
+                ],
+                stream=enable_stream  
+            )
+            st.session_state.is_new_file = False
+        else:
+            # continue chat without sending the file again
+            # Send a text prompt to Gemini API
+            chat = st.session_state.chat
+            response = chat.send_message(
+                [
+                    prompt
+                ],
+                stream=enable_stream  
+            )
+
+        return response.text
+    
+    except Exception as e:
+        st.error(f"An error occurred while generating text: {e}")
+        return None
+
+def show_multimodal():
+    st.subheader("Multimodal")
+    username = st.session_state["username"]
+    st.write(f"Welcome, {username}! This page allows you to generate questions based on an image or PDF file.")
+
+    # Display username and logout button on every page
+    st.sidebar.write(f"Current user: {st.session_state['username']}")
+    
+    # we dont use the system instruction for now
+    #system_instruction = get_system_instruction(username)
+
+    # File uploader with allowed types
+    uploaded_file = st.file_uploader("Choose an image or PDF...", type=["jpg", "jpeg", "png", "pdf"])
+
+    if uploaded_file is not None:
+        # Determine file type
+        file_type = uploaded_file.type
+        if file_type.startswith('image'):
+            # Display the uploaded image
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Uploaded Image.", use_container_width=True)
+            mime_type = "image/jpeg"  # Use a consistent MIME type for images
+            # Display a message for PDF upload
+            st.write("Image file was uploaded. Questions will be generated based on its contents.")
+        elif file_type == 'application/pdf':
+            # Display a message for PDF upload
+            st.write("PDF file uploaded. Questions will be generated based on its contents.")
+            mime_type = "application/pdf"
+        else:
+            st.error("Unsupported file type. Please upload an image or PDF.")
+            st.stop()
+
+    # User inputs
+    # Course selection
+    course = st.text_input("Enter Course", 
+                        "e.g.,Bachelor of Secondary Education")
+
+    # Year level selection
+    year_level = st.selectbox("Select Year Level", 
+                            ["1st Year", 
+                            "2nd Year", 
+                            "3rd Year", 
+                            "4th Year"])
+
+    # Subject selection
+    subject = st.text_input("Enter Subject", 
+                        "e.g.,The Teaching Profession, Facilitating Learner-Centered Teaching")
+
+    # Topic selection
+    topic = st.text_input("Enter Topic", 
+                        "e.g., Teacher as a professional, Introduction to Learner-Centered Teaching")
+
+    # Question type selection
+    question_type = st.selectbox("Select Question Type", 
+                                ["Multiple Choice", 
+                                "True or False", 
+                                "Short Response", 
+                                "Essay Type"])
+
+    difficulty = st.selectbox("Select Difficulty",["easy","average","hard"])
+
+    #number of questions to generate
+    if question_type != "Essay Type":
+        num_questions = st.selectbox("Number of Questions to Generate",
+                                [10, 20, 30, 40, 50])  
+    else:
+        num_questions = st.selectbox("Number of Questions to Generate",
+                                [1, 2, 3, 4, 5]) 
+
+    # Combine user inputs into a prompt
+    prompt = f"""Refer to the uploaded document. Generate a {question_type} question for a {year_level} {course} student
+                    in {subject} on the topic of {topic} with a {difficulty} difficulty level.
+                    The questions should require higher order thinking skills. 
+                    """
+
+    if question_type == "Multiple Choice":    
+        prompt += """Provide 4 choices. Provide the correct answer in the format 'Answer: A'.
+        Use the following JSON format for each question:
+        [{
+        "question": "Your question here?",
+        "options": ["Option A", "Option B", "Option C", "Option D"],
+        "correct_answer": "full text of the correct answer"
+        }, ... more questions]
+        Ensure that the response only contains the JSON array of questions and nothing else.
+        """
+    elif question_type == "True or False":
+        prompt += """Indicate whether the statement is true or false. Keep the statement brief and concise.
+                    Use the following JSON format for each question:
+                    [{
+                    "statement": "Your statement here",
+                    "options": ["True", "False"],
+                    "correct_answer": True"
+                    }, ... more questions]
+                    Ensure that the response only contains the JSON array of questions and nothing else.    
+                    """   
+    elif question_type == "Short Response":
+        prompt += """Create question that require a word or short phrase as answer.  Use the following JSON format for each question:
+                    [{
+                    "question": "Your question here?",
+                    "correct_answer": A word or phrase"
+                    },  ... more questions]
+                    Ensure that the response only contains the JSON array of questions and nothing else.
+                    """
+    elif question_type == "Essay Type":
+        prompt += """Create questions that require a short essay between 300 to 500 words. 
+                    Provide a detailed answer. Use the following JSON format for each question:
+                    [{
+                    "question": "Your question here?",
+                    "correct_answer": The essay answer goes here."
+                    }, ... more questions]
+                    Ensure that the response only contains the JSON array of questions and nothing else.
+                    """
+
+    if not question_type == "Essay Type":
+        prompt += f"Generate 10 questions. Do not repeat questions you have already given in previous prompts. Exclude markdown tags in the response."
+    else:
+        prompt += f" Generate {num_questions} questions. Do not repeat questions you have already given in previous prompts. Exclude markdown tags in the response"  
+
+    full_quiz = ""    
+    
+    # Send button
+    if st.button("Generate Questions"):
+        
+
+        if not uploaded_file:
+            
+            st.warning("Please upload an image or PDF and enter a prompt.")
+            st.stop()               
+        else:
+            if question_type == "Essay Type":
+                #prompt once
+                with st.spinner('Generating questions...'):
+                    full_quiz = _clean_markdown(generate_text(uploaded_file, mime_type, prompt))  
+
+            else:
+                if num_questions == 10:
+
+                    #prompt once
+                    with st.spinner('Generating questions...'):
+                        full_quiz = _clean_markdown(generate_text(uploaded_file, mime_type, prompt))
+                else:
+                    #prompt multiple times
+                    times = num_questions//10
+                    for i in range(times):
+                        with st.spinner('Generating questions...'):
+                            response = generate_text(uploaded_file, mime_type, prompt)  
+
+                            if i==0:
+                                full_quiz = _clean_markdown(response)
+                            else:                        
+                                full_quiz = merge_json_strings(full_quiz, response) 
+
+        metadata = generate_metadata(subject, topic, num_questions, question_type)
+
+        try:
+            # Attempt to load the string as JSON to validate it            
+            content = json.loads(full_quiz)
+        except json.JSONDecodeError:
+            st.error("Error: Invalid JSON string for quiz content.")
+            st.stop()
+
+        json_string = create_json(metadata, content)
+
+        quiz_markdown = generate_quiz_content(json_string)
+        st.markdown(quiz_markdown)
+
+        pdf_path = create_pdf(json_string)
+        
+        if pdf_path:
+            """Click the button to download the generated PDF."""
+            try:
+                with open(pdf_path, "rb") as f:
+                    st.download_button("Download PDF", f, file_name=os.path.basename(pdf_path))
+            except Exception as e:
+                st.error(f"Error handling file download: {e}")
+        else:
+            st.error("Failed to generate the PDF. Please try again.")
+
+        #record the prompt for monitoring
+        save_user_prompt(username, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "Multimodal")
+
+if st.session_state["authenticated"]:
+    show_multimodal()   
+else:
+    if not st.session_state["is_starting"]:
+        st.write("You are not authenticated. Please log in to access this page.")   

pages/4_Settings.py

@@ -0,0 +1,43 @@
+import streamlit as st
+import sqlite3
+
+def get_system_instruction(username):
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('SELECT instruction FROM system_instructions WHERE username=?', (username,))
+    instruction = c.fetchone()
+    conn.close()
+    if instruction:
+        return instruction[0]
+    else:
+        return "Default system instruction."
+
+def save_system_instruction(username, instruction):
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('SELECT * FROM system_instructions WHERE username=?', (username,))
+    existing_instruction = c.fetchone()
+    if existing_instruction:
+        c.execute('UPDATE system_instructions SET instruction=? WHERE username=?', (instruction, username))
+    else:
+        c.execute('INSERT INTO system_instructions(username, instruction) VALUES (?,?)', (username, instruction))
+    conn.commit()
+    conn.close()
+
+def show_settings():
+    st.subheader("Settings")
+    username = st.session_state["username"]
+    system_instruction = get_system_instruction(username)
+    st.write("System Instruction:")
+    instruction = st.text_area("", value=system_instruction, height=200)
+    if st.button("Save Changes"):
+        save_system_instruction(username, instruction)
+        st.success("System instruction saved successfully.")
+
+    st.write("Note: System instruction is not used in this version of the app.")
+
+if st.session_state["authenticated"]:
+    show_settings()   
+else:
+    if not st.session_state["is_starting"]:
+        st.write("You are not authenticated. Please log in to access this page.") 

pdfutils.py

@@ -0,0 +1,397 @@
+import json
+import re
+from reportlab.platypus import Paragraph, Frame, Spacer
+from reportlab.lib.styles import getSampleStyleSheet
+import datetime
+from reportlab.lib.styles import getSampleStyleSheet
+import streamlit as st
+import tempfile
+import os
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import A4, letter 
+
+ENABLE_STREAM = False
+
+def merge_json_strings(json_str1, json_str2):
+    """
+    Merges two JSON strings into one, handling potential markdown tags.
+
+    Args:
+        json_str1: The first JSON string, potentially with markdown tags.
+        json_str2: The second JSON string, potentially with markdown tags.
+
+    Returns:
+        A cleaned JSON string representing the merged JSON objects.
+    """
+
+    # Clean the JSON strings by removing markdown tags
+    cleaned_json_str1 = clean_markdown(json_str1)
+    cleaned_json_str2 = clean_markdown(json_str2)
+
+    try:
+        # Parse the cleaned JSON strings into Python dictionaries
+        data1 = json.loads(cleaned_json_str1)
+        data2 = json.loads(cleaned_json_str2)
+
+        # Merge the dictionaries
+        merged_data = _merge_dicts(data1, data2)
+
+        # Convert the merged dictionary back into a JSON string
+        return json.dumps(merged_data, indent=2)
+    except json.JSONDecodeError as e:
+        return f"Error decoding JSON: {e}"
+    
+def clean_markdown(text):
+    """
+    Removes markdown tags from a string if they exist. 
+    Otherwise, returns the original string unchanged.
+
+    Args:
+        text: The input string.
+
+    Returns:
+        The string with markdown tags removed, or the original string 
+        if no markdown tags were found.
+    """
+    try:
+        # Check if the string contains markdown 
+        if re.match(r"^```json\s*", text) and re.search(r"\s*```$", text):
+            # Remove leading ```json
+            text = re.sub(r"^```json\s*", "", text) 
+            # Remove trailing ```
+            text = re.sub(r"\s*```$", "", text) 
+        return text
+    except Exception as e:
+        # Log the error 
+        st.error(f"Error cleaning markdown: {e}") 
+        return None
+
+def _merge_dicts(data1, data2):
+    """
+    Recursively merges two data structures.
+
+    Handles merging of dictionaries and lists. 
+    For dictionaries, if a key exists in both and both values are dictionaries 
+    or lists, they are merged recursively. Otherwise, the value from data2 is used.
+    For lists, the lists are concatenated.
+
+    Args:
+        data1: The first data structure (dictionary or list).
+        data2: The second data structure (dictionary or list).
+
+    Returns:
+        The merged data structure.
+
+    Raises:
+        ValueError: If the data types are not supported for merging.
+    """
+    if isinstance(data1, dict) and isinstance(data2, dict):
+        for key, value in data2.items():
+            if key in data1 and isinstance(data1[key], (dict, list)) and isinstance(value, type(data1[key])):
+                _merge_dicts(data1[key], value)
+            else:
+                data1[key] = value
+        return data1
+    elif isinstance(data1, list) and isinstance(data2, list):
+        return data1 + data2
+    else:
+        raise ValueError("Unsupported data types for merging")
+
+def create_json(metadata, content):
+    """
+    Creates a JSON string combining metadata and content.
+
+    Args:
+        metadata: A dictionary containing metadata information.
+        content: A dictionary containing the quiz content.
+
+    Returns:
+        A string representing the combined JSON data.
+    """
+
+    # Create metadata with timestamp
+    metadata = {
+        "subject": metadata.get("subject", ""),
+        "topic": metadata.get("topic", ""),
+        "num_questions": metadata.get("num_questions", 0),
+        "exam_type": metadata.get("exam_type", ""),
+        "timestamp": datetime.datetime.now().isoformat()
+    }
+
+    # Combine metadata and content
+    combined_data = {"metadata": metadata, "content": content}
+
+    # Convert to JSON string
+    json_string = json.dumps(combined_data, indent=4)
+
+    return json_string
+
+def create_pdf(data):
+    """
+    Creates a PDF file with text wrapping for quiz content, supporting multiple question types.
+    """
+    try:
+        # Load the JSON data
+        data = json.loads(data)
+
+        if 'metadata' not in data or 'content' not in data:
+            st.error("Error: Invalid data format. Missing 'metadata' or 'content' keys.")
+            return None
+
+        metadata = data['metadata']
+        content = data['content']
+
+        # Validate metadata
+        required_metadata_keys = ['subject', 'topic', 'exam_type', 'num_questions']
+        if not all(key in metadata for key in required_metadata_keys):
+            st.error("Error: Invalid metadata format. Missing required keys.")
+            return None
+
+        # Create a unique filename with timestamp
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        pdf_filename = f"quiz_output_{timestamp}.pdf"
+        temp_dir = tempfile.gettempdir()
+        pdf_path = os.path.join(temp_dir, pdf_filename)
+
+        c = canvas.Canvas(pdf_path, pagesize=A4)
+        c.setFont("Helvetica", 10)
+
+        styles = getSampleStyleSheet()
+        text_style = styles['Normal']
+
+        # Starting position
+        margin_left = 50
+        y_position = 750
+        line_height = 12  # Adjusted for tighter spacing
+        frame_width = 500
+        first_page = True
+
+        def wrap_text_draw(text, x, y):
+            """
+            Wraps and draws text using ReportLab's Paragraph for automatic line breaks.
+            """
+            p = Paragraph(text, text_style)
+            width, height = p.wrap(frame_width, y)
+            p.drawOn(c, x, y - height)
+            return height
+
+        # Print metadata once on the first page
+        if first_page:
+            for key, label in [("subject", "Subject"), ("topic", "Topic"),
+                                ("exam_type", "Type"), ("num_questions", "Number of Questions")]:
+                c.drawString(margin_left, y_position, f"{label}: {metadata[key]}")
+                y_position -= line_height
+            y_position -= line_height
+            first_page = False
+
+        # Render questions and options
+        for idx, q in enumerate(content):
+            if not isinstance(q, dict):
+                st.error(f"Error: Invalid question format at index {idx}. Skipping...")
+                continue
+
+            question_text = f"{idx + 1}. {q.get('question', q.get('statement', ''))}"
+            height = wrap_text_draw(question_text, margin_left, y_position)
+            y_position -= (height + line_height)
+
+            if y_position < 50:
+                c.showPage()
+                c.setFont("Helvetica", 10)
+                y_position = 750
+
+            # Handle specific exam types
+            exam_type = metadata['exam_type']
+
+            if exam_type == "Multiple Choice":
+                for option_idx, option in enumerate(q['options'], ord('a')):
+                    option_text = f"{chr(option_idx)}) {option}"
+                    height = wrap_text_draw(option_text, margin_left + 20, y_position)
+                    y_position -= (height + line_height)
+
+                    if y_position < 50:
+                        c.showPage()
+                        c.setFont("Helvetica", 10)
+                        y_position = 750
+
+                # Print correct answer
+                correct_answer_text = f"Correct Answer: {q['correct_answer']}"
+                height = wrap_text_draw(correct_answer_text, margin_left + 20, y_position)
+                y_position -= (height + line_height)
+
+            elif exam_type == "True or False":
+                for option in q['options']:
+                    height = wrap_text_draw(option, margin_left + 20, y_position)
+                    y_position -= (height + line_height)
+
+                    if y_position < 50:
+                        c.showPage()
+                        c.setFont("Helvetica", 10)
+                        y_position = 750
+
+                correct_answer_text = f"Correct Answer: {q['correct_answer']}"
+                height = wrap_text_draw(correct_answer_text, margin_left + 20, y_position)
+                y_position -= (height + line_height)
+
+            elif exam_type in ["Short Response", "Essay Type"]:
+                answer_text = f"Correct Answer: {q['correct_answer']}"
+                height = wrap_text_draw(answer_text, margin_left + 20, y_position)
+                y_position -= (height + line_height)
+
+            if y_position < 50:
+                c.showPage()
+                c.setFont("Helvetica", 10)
+                y_position = 750
+
+        # Add a footer
+        notice = "This exam was generated by the WVSU Exam Maker (c) 2025 West Visayas State University"
+        c.drawString(margin_left, y_position, notice)
+
+        c.save()
+        return pdf_path
+
+    except Exception as e:
+        st.error(f"Error creating PDF: {e}")
+        return None
+
+def generate_quiz_content(data):
+    """
+    Separates the metadata and content from a JSON string containing exam data.
+    Creates a markdown formatted text that contains the exam metadata and 
+    enumerates the questions, options and answers nicely formatted for readability.
+
+    Args:
+      data: A JSON string containing the exam data.
+
+    Returns:
+      A markdown formatted string.
+    """
+    data = json.loads(data)
+    metadata = data["metadata"]
+    content = data["content"]
+    exam_type = metadata["exam_type"]
+    if exam_type == "Multiple Choice":
+        md_text = f"""# {metadata['subject']} - {metadata['topic']}
+
+**Exam Type:** {metadata['exam_type']}  
+**Number of Questions:** {metadata['num_questions']}  
+**Timestamp:** {metadata['timestamp']}
+
+---
+
+"""
+        for i, q in enumerate(content):
+            md_text += f"""Question {i+1}:
+            {q['question']}
+
+"""
+            for j, option in enumerate(q['options'], ord('a')):
+                md_text += f"""{chr(j)}. {option}  
+
+"""
+            md_text += f"""**Correct Answer:** {q['correct_answer']}
+
+---
+
+"""
+        md_text += """This exam was generated by the WVSU Exam Maker
+            (c) 2025 West Visayas State University
+"""
+            
+    elif exam_type == "True or False":
+        md_text = f"""# {metadata['subject']} - {metadata['topic']}
+
+**Exam Type:** {metadata['exam_type']}  
+**Number of Questions:** {metadata['num_questions']}  
+**Timestamp:** {metadata['timestamp']}
+
+---
+
+"""
+
+        for i, q in enumerate(content):
+            md_text += f"""Statement {i+1}:
+
+{q['statement']}
+
+"""
+            for j, option in enumerate(q['options'], ord('a')):
+                md_text += f"""{option}  
+"""
+
+            md_text += f"""**Correct Answer:** {q['correct_answer']}
+
+---
+"""
+        md_text += """This exam was generated by the WVSU Exam Maker
+(c) 2025 West Visayas State University"""
+
+    elif exam_type == "Short Response" or exam_type == "Essay Type":
+        md_text = f"""# {metadata['subject']} - {metadata['topic']}
+
+**Exam Type:** {metadata['exam_type']}  
+**Number of Questions:** {metadata['num_questions']}  
+**Timestamp:** {metadata['timestamp']}
+
+---
+
+"""
+
+        for i, q in enumerate(content):
+            md_text += f"""Question {i+1}:
+
+{q['question']}
+
+"""
+            md_text += f"""**Correct Answer:** {q['correct_answer']}
+
+---
+"""
+        md_text += """This exam was generated by the WVSU Exam Maker
+(c) 2025 West Visayas State University"""
+
+    return md_text
+    
+def generate_metadata(subject, topic, num_questions, exam_type):
+    """Generates quiz metadata as a dictionary combining num_questions, 
+    exam_type, and timestamp.
+
+    Args:
+        num_questions: The number of questions in the exam (int).
+        exam_type: The type of exam (str).
+
+    Returns:
+        A dictionary containing the quiz metadata.
+    """
+
+    # Format the timestamp
+    timestamp = datetime.datetime.now()
+    formatted_timestamp = timestamp.strftime("%Y-%m-%d %H:%M:%S") 
+    
+    metadata = {
+        "subject": subject,
+        "topic": topic,
+        "num_questions": num_questions,
+        "exam_type": exam_type,
+        "timestamp": formatted_timestamp
+    }
+
+    return metadata
+
+def generate_text(prompt):
+    """Generates text based on the  prompt."""
+    try:
+            
+        # Send a text prompt to Gemini API
+        chat = st.session_state.chat
+        response = chat.send_message(
+            [
+                prompt
+            ],
+            stream=ENABLE_STREAM  
+        )
+
+        return response.text
+   
+    except Exception as e:
+        st.error(f"An error occurred while generating text: {e}")
+        return None

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+passlib
+bcrypt==3.2.0
+google-generativeai
+reportlab