import streamlit as st from langchain_groq import ChatGroq from langchain_core.output_parsers import StrOutputParser from langchain_core.prompts import ChatPromptTemplate from dotenv import load_dotenv import pytesseract from PIL import Image import pdfplumber import docx from io import BytesIO import logging from docx import Document from fpdf import FPDF import cv2 import numpy as np # Load environment variables load_dotenv() # Initialize logging logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s") # Initialize LLM llm = ChatGroq(temperature=0.5, groq_api_key="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", model_name="llama3-8b-8192") # OCR Configuration for Pytesseract pytesseract.pytesseract.tesseract_cmd = r"/usr/bin/tesseract" # Adjust to your system's path # Enhanced OCR with configurable language option and multi-image support def extract_text_from_images(images, lang="eng"): ocr_text = "" for image in images: try: ocr_text += pytesseract.image_to_string(image, lang=lang).strip() + "\n" except Exception as e: logging.error(f"Error in OCR: {e}") return ocr_text.strip() # Function to extract formulas using Tesseract OCR def extract_formula_using_tesseract(image_path): # Open image image = Image.open(image_path) # Convert image to grayscale gray_image = cv2.cvtColor(np.array(image), cv2.COLOR_BGR2GRAY) # Apply thresholding to improve accuracy for formulas _, thresh_image = cv2.threshold(gray_image, 150, 255, cv2.THRESH_BINARY_INV) # Use pytesseract to extract LaTeX formula custom_oem_psm_config = r'--oem 3 --psm 6' # PSM 6 is used for block text extracted_text = pytesseract.image_to_string(thresh_image, config=custom_oem_psm_config) return extracted_text # Function to extract text, images, tables, and formulas from PDF def extract_pdf_data(pdf_path): data = {"text": "", "tables": [], "images": []} try: with pdfplumber.open(pdf_path) as pdf: for page in pdf.pages: data["text"] += page.extract_text() or "" tables = page.extract_tables() for table in tables: data["tables"].append(table) for image in page.images: base_image = pdf.extract_image(image["object_number"]) image_obj = Image.open(BytesIO(base_image["image"])) data["images"].append(image_obj) except Exception as e: logging.error(f"Error processing PDF: {e}") return data # Function to extract text from DOCX files def extract_docx_data(docx_file): try: doc = docx.Document(docx_file) text = "\n".join([para.text.strip() for para in doc.paragraphs if para.text.strip()]) return text except Exception as e: logging.error(f"Error extracting DOCX content: {e}") return "" # Function to extract text from plain text files def extract_text_file_data(text_file): try: return text_file.read().decode("utf-8").strip() except Exception as e: logging.error(f"Error extracting TXT content: {e}") return "" # Function to process extracted content (PDF, DOCX, etc.) def process_content(file_data, file_type, lang="eng"): text = "" images = [] formulas = "" if file_type == "pdf": pdf_data = extract_pdf_data(file_data) text = process_pdf_content(pdf_data) images = pdf_data["images"] elif file_type == "docx": text = extract_docx_data(file_data) elif file_type == "txt": text = extract_text_file_data(file_data) elif file_type in ["png", "jpg", "jpeg"]: image = Image.open(file_data) images.append(image) # Extract OCR text and formulas from images ocr_text = extract_text_from_images(images, lang) formulas = "" for image in images: formulas += extract_formula_using_tesseract(image) + "\n" return text + "\n" + ocr_text + "\n" + formulas # Function to process PDF content def process_pdf_content(pdf_data): ocr_text = extract_text_from_images(pdf_data["images"]) combined_text = pdf_data["text"] + ocr_text table_text = "" for table in pdf_data["tables"]: table_rows = [" | ".join(str(cell) if cell else "" for cell in row) for row in table] table_text += "\n".join(table_rows) + "\n" return (combined_text + "\n" + table_text).strip() # Function to generate questions def generate_questions(question_type, subject_name, instructor, class_name, institution, syllabus_context, num_questions, difficulty_level): prompt_template = f""" Based on the following syllabus content, generate {num_questions} {question_type} questions. Ensure the questions are directly derived from the provided syllabus content. Subject: {subject_name} Instructor: {instructor} Class: {class_name} Institution: {institution} Syllabus Content: {syllabus_context} Difficulty Levels: - Remember: {difficulty_level.get('Remember', 0)} - Understand: {difficulty_level.get('Understand', 0)} - Apply: {difficulty_level.get('Apply', 0)} - Analyze: {difficulty_level.get('Analyze', 0)} - Evaluate: {difficulty_level.get('Evaluate', 0)} - Create: {difficulty_level.get('Create', 0)} Format questions as follows: Q1. ________________ Q2. ________________ ... """ chain = (ChatPromptTemplate.from_template(prompt_template) | llm | StrOutputParser()) try: return chain.invoke({}) except Exception as e: logging.error(f"Error generating {question_type} questions: {e}") return "" # Function to generate answers def generate_answers(questions, syllabus_context): prompt = f""" Based on the provided syllabus content, generate detailed answers for the following questions. The answers must only be based on the syllabus content. Syllabus Content: {syllabus_context} Questions: {questions} Format answers as follows: Answer 1: ________________ Answer 2: ________________ ... """ chain = (ChatPromptTemplate.from_template(prompt) | llm | StrOutputParser()) try: return chain.invoke({}) except Exception as e: logging.error(f"Error generating answers: {e}") return "" # Function to download as DOCX def download_as_docx(content, file_name="output.docx"): doc = Document() for line in content.split("\n"): doc.add_paragraph(line) buffer = BytesIO() doc.save(buffer) buffer.seek(0) return buffer # Function to download as PDF def download_as_pdf(content, file_name="output.pdf"): pdf = FPDF() pdf.add_page() pdf.set_font("Arial", size=12) for line in content.split("\n"): pdf.cell(200, 10, txt=line, ln=True) buffer = BytesIO() pdf.output(buffer) buffer.seek(0) return buffer # Streamlit app with enhanced UI and multi-image upload support st.title("Bloom's Taxonomy Based Exam Paper Developer") st.markdown(""" ### A powerful tool to generate exam questions and answers using AI, based on syllabus content and Bloom's Taxonomy principles. """) # Sidebar Clear Data Button if st.sidebar.button("Clear All Data"): st.session_state.clear() st.success("All data has been cleared. You can now upload a new syllabus.") # Upload Syllabus and Multiple Images uploaded_file = st.sidebar.file_uploader( "Upload Syllabus (PDF, DOCX, TXT)", type=["pdf", "docx", "txt"] ) uploaded_images = st.sidebar.file_uploader( "Upload Supplementary Images (PNG, JPG, JPEG)", type=["png", "jpg", "jpeg"], accept_multiple_files=True ) # Sidebar Inputs for Subject Name, Instructor, Class, and Institution subject_name = st.sidebar.text_input("Enter Subject Name", "Subject Name") instructor_name = st.sidebar.text_input("Enter Instructor Name", "Instructor Name") class_name = st.sidebar.text_input("Enter Class Name", "Class Name") institution_name = st.sidebar.text_input("Enter Institution Name", "Institution Name") # Language Option for OCR ocr_lang = st.sidebar.selectbox("Select OCR Language", ["eng", "spa", "fra", "deu", "ita"]) # Process uploaded file and images if uploaded_file or uploaded_images: # Clear session state when new files are uploaded if "uploaded_filename" in st.session_state and st.session_state.uploaded_filename != uploaded_file.name: st.session_state.clear() st.success("Previous data cleared. Processing new file...") st.session_state.uploaded_filename = uploaded_file.name if uploaded_file else None # Process syllabus file if uploaded_file: file_type = uploaded_file.type.split("/")[-1] if file_type in ["pdf", "docx", "txt"]: syllabus_text = process_content(uploaded_file, file_type, lang=ocr_lang) st.session_state.syllabus_text = syllabus_text else: st.error("Unsupported file type. Please upload PDF, DOCX, or TXT files.") # Process images if uploaded_images: image_text = extract_text_from_images([Image.open(img) for img in uploaded_images], lang=ocr_lang) st.session_state.syllabus_text = st.session_state.get("syllabus_text", "") + "\n" + image_text # Preview of Syllabus if "syllabus_text" in st.session_state: st.markdown("### Preview of Extracted Syllabus Content") st.text_area("Extracted Syllabus Content", st.session_state.syllabus_text, height=300) # Inputs for Question Generation if "syllabus_text" in st.session_state: st.markdown("### Generate Questions") question_type = st.selectbox("Select Question Type", ["Multiple Choice", "Short Answer", "Essay"]) num_questions = st.number_input("Number of Questions", min_value=1, max_value=50, value=10) difficulty_levels = { "Remember": st.slider("Remember (%)", 0, 100, 20), "Understand": st.slider("Understand (%)", 0, 100, 20), "Apply": st.slider("Apply (%)", 0, 100, 20), "Analyze": st.slider("Analyze (%)", 0, 100, 20), "Evaluate": st.slider("Evaluate (%)", 0, 100, 10), "Create": st.slider("Create (%)", 0, 100, 10), } if st.button("Generate Questions"): with st.spinner("Generating questions..."): questions = generate_questions( question_type, subject_name, instructor_name, class_name, institution_name, st.session_state.syllabus_text, num_questions, difficulty_levels, ) st.session_state.generated_questions = questions st.success("Questions generated successfully!") # Display Generated Questions if "generated_questions" in st.session_state: st.markdown("### Generated Questions") st.text_area("Questions", st.session_state.generated_questions, height=300) if st.button("Generate Answers"): with st.spinner("Generating answers..."): answers = generate_answers( st.session_state.generated_questions, st.session_state.syllabus_text, ) st.session_state.generated_answers = answers st.success("Answers generated successfully!") # Display Generated Answers if "generated_answers" in st.session_state: st.markdown("### Generated Answers") st.text_area("Answers", st.session_state.generated_answers, height=300) # Download Options if "generated_questions" in st.session_state or "generated_answers" in st.session_state: st.markdown("### Download Options") download_choice = st.radio("Select Download Format", ["DOCX", "PDF", "TXT"]) content_to_download = "" if "generated_questions" in st.session_state: content_to_download += "Generated Questions:\n" + st.session_state.generated_questions + "\n\n" if "generated_answers" in st.session_state: content_to_download += "Generated Answers:\n" + st.session_state.generated_answers + "\n\n" if download_choice == "DOCX": download_buffer = download_as_docx(content_to_download) st.download_button("Download DOCX", download_buffer, file_name="exam_questions_and_answers.docx", mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document") elif download_choice == "PDF": download_buffer = download_as_pdf(content_to_download) st.download_button("Download PDF", download_buffer, file_name="exam_questions_and_answers.pdf", mime="application/pdf") elif download_choice == "TXT": st.download_button("Download TXT", content_to_download, file_name="exam_questions_and_answers.txt", mime="text/plain")