Update app.py

app.py

@@ -0,0 +1,466 @@
+import streamlit as st
+import os
+import time
+import tempfile
+import subprocess
+import re
+import PyPDF2
+import docx
+from fpdf import FPDF
+from pathlib import Path
+import threading
+import queue
+import logging
+from datetime import datetime
+import io
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("streamlit_app.log"),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Set page configuration
+st.set_page_config(
+    page_title="B.Tech Assignment Solution Generator",
+    page_icon="🎓",
+    layout="wide",
+    initial_sidebar_state="expanded",
+    menu_items={
+        'About': "# B.Tech Assignment Solution Generator\nThis app processes B.Tech assignments and generates comprehensive solutions."
+    }
+)
+
+# Apply dark theme
+st.markdown("""
+<style>
+    .main {
+        background-color: #0E1117;
+        color: white;
+    }
+    .stButton>button {
+        background-color: #4CAF50;
+        color: white;
+        border-radius: 8px;
+        padding: 10px 24px;
+        font-weight: bold;
+        border: none;
+        transition-duration: 0.4s;
+    }
+    .stButton>button:hover {
+        background-color: #45a049;
+    }
+    .stTextInput>div>div>input {
+        background-color: #1E2126;
+        color: white;
+    }
+    .stMarkdown {
+        color: white;
+    }
+    .css-1cpxqw2 {
+        background-color: #262730;
+        border-radius: 10px;
+        padding: 20px;
+        margin-bottom: 20px;
+    }
+    .css-1v3fvcr {
+        background-color: #0E1117;
+    }
+    .css-18e3th9 {
+        padding-top: 2rem;
+    }
+    .css-1kyxreq {
+        justify-content: center;
+        align-items: center;
+    }
+    .stProgress > div > div > div > div {
+        background-color: #4CAF50;
+    }
+    .log-container {
+        background-color: #1E2126;
+        color: #B0B0B0;
+        padding: 15px;
+        border-radius: 8px;
+        height: 300px;
+        overflow-y: auto;
+        font-family: monospace;
+        margin-bottom: 20px;
+    }
+    .success-message {
+        color: #4CAF50;
+        font-weight: bold;
+    }
+    .error-message {
+        color: #FF5252;
+        font-weight: bold;
+    }
+    .info-message {
+        color: #2196F3;
+    }
+    .warning-message {
+        color: #FFC107;
+    }
+    .pdf-container {
+        background-color: #262730;
+        padding: 20px;
+        border-radius: 10px;
+        margin-top: 20px;
+    }
+    .download-button {
+        background-color: #2196F3;
+        color: white;
+        padding: 10px 15px;
+        border-radius: 5px;
+        text-decoration: none;
+        display: inline-block;
+        margin-top: 10px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def extract_text_from_pdf(file):
+    """Extract text from a PDF file."""
+    try:
+        pdf_reader = PyPDF2.PdfReader(file)
+        text = ""
+        for page in pdf_reader.pages:
+            text += page.extract_text() + "\n"
+        return text
+    except Exception as e:
+        logger.error(f"Error extracting text from PDF: {e}")
+        st.error(f"Error extracting text from PDF: {e}")
+        return None
+
+def extract_text_from_docx(file):
+    """Extract text from a DOCX file."""
+    try:
+        doc = docx.Document(file)
+        text = ""
+        for para in doc.paragraphs:
+            text += para.text + "\n"
+        return text
+    except Exception as e:
+        logger.error(f"Error extracting text from DOCX: {e}")
+        st.error(f"Error extracting text from DOCX: {e}")
+        return None
+
+def create_pdf(content, filename="solution.pdf"):
+    """Create a PDF file from the solution content."""
+    try:
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_auto_page_break(auto=True, margin=15)
+        
+        # Set font for title
+        pdf.set_font("Arial", "B", 16)
+        pdf.cell(0, 10, "B.Tech Assignment Solution", ln=True, align="C")
+        pdf.ln(5)
+        
+        # Set font for content
+        pdf.set_font("Arial", "", 12)
+        
+        # Process content by paragraphs
+        paragraphs = content.split('\n')
+        for para in paragraphs:
+            # Check if this is a heading (simple heuristic)
+            if para.strip() and len(para.strip()) < 100 and para.strip().isupper():
+                pdf.set_font("Arial", "B", 14)
+                pdf.cell(0, 10, para, ln=True)
+                pdf.set_font("Arial", "", 12)
+            else:
+                # Handle regular paragraph
+                pdf.multi_cell(0, 10, para)
+                pdf.ln(2)
+        
+        # Save PDF to a bytes buffer
+        pdf_buffer = io.BytesIO()
+        pdf.output(pdf_buffer)
+        pdf_buffer.seek(0)
+        
+        return pdf_buffer
+    except Exception as e:
+        logger.error(f"Error creating PDF: {e}")
+        st.error(f"Error creating PDF: {e}")
+        return None
+
+def process_log_line(line):
+    """Process a log line to determine its type and format it for display."""
+    line = line.strip()
+    if not line:
+        return None, None
+    
+    # Determine message type
+    if "ERROR" in line or "error" in line.lower():
+        msg_type = "error"
+    elif "WARNING" in line or "warning" in line.lower():
+        msg_type = "warning"
+    elif "INFO" in line or "info" in line.lower():
+        msg_type = "info"
+    else:
+        msg_type = "info"
+    
+    # Extract the important part of the message
+    # Remove timestamp and log level if present
+    match = re.search(r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3} - \w+ - \w+ - (.*)', line)
+    if match:
+        message = match.group(1)
+    else:
+        message = line
+    
+    return msg_type, message
+
+def monitor_log_file(log_file, message_queue, stop_event):
+    """Monitor the log file for new content and put it in the queue."""
+    try:
+        with open(log_file, 'r') as f:
+            # Move to the end of the file
+            f.seek(0, 2)
+            
+            while not stop_event.is_set():
+                line = f.readline()
+                if line:
+                    msg_type, message = process_log_line(line)
+                    if msg_type and message:
+                        message_queue.put((msg_type, message))
+                else:
+                    # No new line, wait a bit
+                    time.sleep(0.1)
+    except Exception as e:
+        logger.error(f"Error monitoring log file: {e}")
+        message_queue.put(("error", f"Error monitoring log file: {e}"))
+
+def run_assignment_processor(input_file_path, message_queue):
+    """Run the assignment processor and capture its output."""
+    try:
+        # Get the directory of the current script
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        
+        # Construct the path to streamlit_main.py
+        main_script = os.path.join(script_dir, "streamlit_main.py")
+        
+        # Activate virtual environment if available
+        venv_python = os.path.join(script_dir, "venv", "bin", "python")
+        if os.path.exists(venv_python):
+            python_cmd = venv_python
+        else:
+            python_cmd = "python3"
+        
+        # Run the assignment processor
+        cmd = [python_cmd, main_script, input_file_path]
+        
+        # Add log message
+        message_queue.put(("info", "Starting assignment processing..."))
+        
+        # Execute the command
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        # Capture and process output
+        for line in process.stdout:
+            msg_type, message = process_log_line(line)
+            if msg_type and message:
+                message_queue.put((msg_type, message))
+        
+        # Wait for process to complete
+        return_code = process.wait()
+        
+        if return_code != 0:
+            # Capture error output if process failed
+            error_output = process.stderr.read()
+            message_queue.put(("error", f"Process failed with return code {return_code}: {error_output}"))
+            return False
+        
+        # Add completion message
+        message_queue.put(("success", "COMPLETED B.TECH ASSIGNMENT SOLUTION PIPELINE"))
+        return True
+    except Exception as e:
+        logger.error(f"Error running assignment processor: {e}")
+        message_queue.put(("error", f"Error running assignment processor: {e}"))
+        return False
+
+def main():
+    # Header
+    st.title("B.Tech Assignment Solution Generator")
+    st.markdown("Upload your assignment file (PDF or DOCX) and get comprehensive solutions.")
+    
+    # File uploader
+    uploaded_file = st.file_uploader("Choose an assignment file", type=["pdf", "docx"])
+    
+    if uploaded_file is not None:
+        st.success(f"File uploaded: {uploaded_file.name}")
+        
+        # Extract text from the uploaded file
+        if uploaded_file.name.endswith('.pdf'):
+            text = extract_text_from_pdf(uploaded_file)
+        elif uploaded_file.name.endswith('.docx'):
+            text = extract_text_from_docx(uploaded_file)
+        else:
+            st.error("Unsupported file format. Please upload a PDF or DOCX file.")
+            return
+        
+        if text is None:
+            st.error("Failed to extract text from the file.")
+            return
+        
+        # Preview the extracted text
+        with st.expander("Preview Extracted Text", expanded=False):
+            st.text_area("Extracted Text", text, height=200)
+        
+        # Process button
+        if st.button("Generate Solution"):
+            # Create a temporary file to save the extracted text
+            with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as temp_file:
+                temp_file.write(text)
+                temp_file_path = temp_file.name
+            
+            try:
+                # Set up progress tracking
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                # Create a container for log messages
+                st.subheader("Processing Status")
+                log_container = st.empty()
+                log_messages = []
+                
+                # Create a queue for messages
+                message_queue = queue.Queue()
+                
+                # Create an event to signal thread to stop
+                stop_event = threading.Event()
+                
+                # Start a thread to monitor the log file
+                log_file = "btech_solution_system.log"
+                log_thread = threading.Thread(
+                    target=monitor_log_file,
+                    args=(log_file, message_queue, stop_event)
+                )
+                log_thread.daemon = True
+                log_thread.start()
+                
+                # Start processing in a separate thread
+                processing_thread = threading.Thread(
+                    target=run_assignment_processor,
+                    args=(temp_file_path, message_queue)
+                )
+                processing_thread.daemon = True
+                processing_thread.start()
+                
+                # Update progress and display log messages
+                start_time = time.time()
+                solution_content = None
+                
+                # Define key stages and their progress values
+                stages = {
+                    "ANALYZING QUESTIONS": 10,
+                    "RESEARCHING INFORMATION": 30,
+                    "DEVELOPING INITIAL SOLUTIONS": 50,
+                    "VERIFYING SOLUTIONS": 70,
+                    "REVISING SOLUTIONS": 85,
+                    "FORMATTING FINAL REPORT": 95,
+                    "COMPLETED": 100
+                }
+                
+                current_progress = 0
+                
+                # Update status until processing is complete
+                while processing_thread.is_alive() or not message_queue.empty():
+                    # Check for new messages
+                    try:
+                        while not message_queue.empty():
+                            msg_type, message = message_queue.get(block=False)
+                            
+                            # Update progress based on message content
+                            for stage, progress_value in stages.items():
+                                if stage in message:
+                                    current_progress = progress_value
+                                    break
+                            
+                            # Format message based on type
+                            formatted_msg = f"<div class='{msg_type}-message'>{message}</div>"
+                            log_messages.append(formatted_msg)
+                            
+                            # Keep only the last 20 messages to avoid cluttering
+                            if len(log_messages) > 20:
+                                log_messages = log_messages[-20:]
+                            
+                            # Update log display
+                            log_container.markdown(
+                                f"<div class='log-container'>{''.join(log_messages)}</div>",
+                                unsafe_allow_html=True
+                            )
+                            
+                            # Check if solution is ready
+                            if "COMPLETED B.TECH ASSIGNMENT SOLUTION PIPELINE" in message:
+                                # Try to read the solution file
+                                try:
+                                    solution_file = "solution.txt"
+                                    if os.path.exists(solution_file):
+                                        with open(solution_file, 'r') as f:
+                                            solution_content = f.read()
+                                except Exception as e:
+                                    logger.error(f"Error reading solution file: {e}")
+                                    log_messages.append(f"<div class='error-message'>Error reading solution file: {e}</div>")
+                    except queue.Empty:
+                        pass
+                    
+                    # Update progress bar
+                    progress_bar.progress(current_progress)
+                    status_text.text(f"Processing... ({current_progress}%)")
+                    
+                    # Check if processing is complete
+                    if current_progress >= 100:
+                        break
+                    
+                    # Check timeout (30 minutes)
+                    if time.time() - start_time > 1800:
+                        status_text.error("Processing timed out after 30 minutes.")
+                        break
+                    
+                    time.sleep(0.5)
+                
+                # Stop the log monitoring thread
+                stop_event.set()
+                
+                # Check if solution was found
+                if solution_content:
+                    # Update progress to 100%
+                    progress_bar.progress(100)
+                    status_text.success("Solution generated successfully!")
+                    
+                    # Display the solution
+                    st.subheader("Generated Solution")
+                    st.markdown(solution_content)
+                    
+                    # Create PDF
+                    pdf_buffer = create_pdf(solution_content)
+                    
+                    if pdf_buffer:
+                        # Provide download button for PDF
+                        st.download_button(
+                            label="Download Solution as PDF",
+                            data=pdf_buffer,
+                            file_name="btech_assignment_solution.pdf",
+                            mime="application/pdf",
+                            key="solution-pdf",
+                            help="Click to download the solution as a PDF file"
+                        )
+                else:
+                    status_text.error("Failed to generate solution.")
+            
+            finally:
+                # Clean up temporary file
+                if os.path.exists(temp_file_path):
+                    os.unlink(temp_file_path)
+
+if __name__ == "__main__":
+    main()