exam_maker_mirror2 / pdfutils.py
louiecerv's picture
sync to remote
821850b
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