update remote

pages/2_Text_prompt.py

@@ -14,12 +14,12 @@ 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)
-enable_stream = False
 
 if "model" not in st.session_state:
     st.session_state.model = genai.GenerativeModel(MODEL_ID)
@@ -48,392 +48,6 @@ def save_user_prompt(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(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
-
 def show_text_prompt():
     st.subheader("Text Prompt")
 
@@ -537,14 +151,14 @@ def show_text_prompt():
         if question_type == "Essay Type":
             #prompt once
             with st.spinner('Generating questions...'):
-                full_quiz = _clean_markdown(generate_text(prompt))  
+                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))
+                    full_quiz = clean_markdown(generate_text(prompt))
             else:
                 #prompt multiple times
                 times = num_questions//10
@@ -553,7 +167,7 @@ def show_text_prompt():
                         response = generate_text(prompt)  
 
                         if i==0:
-                            full_quiz = _clean_markdown(response)
+                            full_quiz = clean_markdown(response)
                         else:                        
                             full_quiz = merge_json_strings(full_quiz, response) 
 

pdfutils.py

@@ -3,9 +3,14 @@ import re
 from reportlab.platypus import Paragraph, Frame, Spacer
 from reportlab.lib.styles import getSampleStyleSheet
 import datetime
-from reportlab.platypus import Paragraph, Frame, Spacer
 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):
     """
@@ -20,8 +25,8 @@ def merge_json_strings(json_str1, json_str2):
     """
 
     # Clean the JSON strings by removing markdown tags
-    cleaned_json_str1 = _clean_markdown(json_str1)
-    cleaned_json_str2 = _clean_markdown(json_str2)
+    cleaned_json_str1 = clean_markdown(json_str1)
+    cleaned_json_str2 = clean_markdown(json_str2)
 
     try:
         # Parse the cleaned JSON strings into Python dictionaries
@@ -36,7 +41,7 @@ def merge_json_strings(json_str1, json_str2):
     except json.JSONDecodeError as e:
         return f"Error decoding JSON: {e}"
     
-def _clean_markdown(text):
+def clean_markdown(text):
     """
     Removes markdown tags from a string if they exist. 
     Otherwise, returns the original string unchanged.
@@ -247,3 +252,146 @@ def create_pdf(data):
     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