printing extracted text8

main.py

@@ -280,87 +280,103 @@ def compute_answers():
         query_file = request.files.get('query_file')
         if not query_file:
             error_msg = "Missing query file"
-            notification_queue.put({
-                "type": "error",
-                "message": error_msg
-            })
+            log_print(error_msg, "ERROR")
             return jsonify({"error": error_msg}), 400
         
-        queries = query_file.read().decode('utf-8').splitlines()
-        logger.info(f"Received queries: {queries}")
+        # Read and validate query file
+        try:
+            queries = query_file.read().decode('utf-8').splitlines()
+            queries = [q.strip() for q in queries if q.strip()]
+            if not queries:
+                error_msg = "Query file is empty"
+                log_print(error_msg, "ERROR")
+                return jsonify({"error": error_msg}), 400
+            log_print(f"Successfully read {len(queries)} queries")
+        except Exception as e:
+            error_msg = f"Error reading query file: {str(e)}"
+            log_print(error_msg, "ERROR")
+            return jsonify({"error": error_msg}), 400
         
         file_type = request.form.get('file_type')
-        ans_csv_file = request.files.get('ans_csv_file')
+        log_print(f"Processing file type: {file_type}")
         
         if file_type == "csv":
-            ans_csv_file = ans_csv_file.read().decode('utf-8').splitlines()
-            c_answers = []
-            for i in ans_csv_file:
-                c_answers.append(i.split('\\n'))
-            logger.info(f"Processed CSV answers: {c_answers}")
-            return jsonify({"answers": c_answers}), 200
-        
-        try:
-            c_answers = []
+            ans_csv_file = request.files.get('ans_csv_file')
+            if not ans_csv_file:
+                error_msg = "Missing answer CSV file"
+                log_print(error_msg, "ERROR")
+                return jsonify({"error": error_msg}), 400
             
-            if file_type == 'pdf':
-                # Create a temporary directory for PDF files
-                pdf_dir = tempfile.mkdtemp()
-                os.makedirs(pdf_dir, exist_ok=True)
-                
-                # Save uploaded PDF files
-                pdf_files = []
-                for file in request.files.getlist('pdf_files[]'):
-                    if file.filename.endswith('.pdf'):
-                        filename = secure_filename(file.filename)
-                        filepath = os.path.join(pdf_dir, filename)
-                        file.save(filepath)
-                        pdf_files.append(filepath)
+            try:
+                # Read and process CSV answers
+                log_print("Reading CSV answer file...")
+                ans_csv_content = ans_csv_file.read().decode('utf-8').splitlines()
+                c_answers = []
+                for line in ans_csv_content:
+                    if line.strip():  # Skip empty lines
+                        answers = [ans.strip() for ans in line.split('\\n') if ans.strip()]
+                        c_answers.append(answers)
                 
-                if not pdf_files:
-                    return jsonify({"error": "No PDF files uploaded"}), 400
+                if not c_answers:
+                    error_msg = "No valid answers found in CSV file"
+                    log_print(error_msg, "ERROR")
+                    return jsonify({"error": error_msg}), 400
                 
-                logger.info(f"Processing {len(pdf_files)} PDF files")
+                log_print(f"Successfully processed {len(c_answers)} answers from CSV")
+                return jsonify({"answers": c_answers}), 200
                 
-                # Process PDFs
+            except Exception as e:
+                error_msg = f"Error processing CSV file: {str(e)}"
+                log_print(error_msg, "ERROR")
+                return jsonify({"error": error_msg}), 400
+        
+        elif file_type == 'pdf':
+            # Create a temporary directory for PDF files
+            pdf_dir = tempfile.mkdtemp()
+            os.makedirs(pdf_dir, exist_ok=True)
+            
+            # Save uploaded PDF files
+            pdf_files = []
+            for file in request.files.getlist('pdf_files[]'):
+                if file.filename.endswith('.pdf'):
+                    filename = secure_filename(file.filename)
+                    filepath = os.path.join(pdf_dir, filename)
+                    file.save(filepath)
+                    pdf_files.append(filepath)
+            
+            if not pdf_files:
+                return jsonify({"error": "No PDF files uploaded"}), 400
+            
+            logger.info(f"Processing {len(pdf_files)} PDF files")
+            
+            # Process PDFs
+            for pdf_file in pdf_files:
+                database_creation(pdf_file)
+            
+            # Generate answers
+            for query in queries:
+                ans = []
                 for pdf_file in pdf_files:
-                    database_creation(pdf_file)
-                
-                # Generate answers
-                for query in queries:
-                    ans = []
-                    for pdf_file in pdf_files:
-                        ans.append(answer_generation(pdf_file, query))
-                    c_answers.append(ans)
-                
-                # Clean up PDF directory
-                try:
-                    shutil.rmtree(pdf_dir)
-                except Exception as e:
-                    logger.warning(f"Could not clean up PDF directory: {e}")
-                
-            else:
-                return jsonify({"error": "Unsupported file type"}), 400
-                
+                    ans.append(answer_generation(pdf_file, query))
+                c_answers.append(ans)
+            
+            # Clean up PDF directory
+            try:
+                shutil.rmtree(pdf_dir)
+            except Exception as e:
+                logger.warning(f"Could not clean up PDF directory: {e}")
+            
             logger.info(f"Generated answers: {c_answers}")
             return jsonify({"answers": c_answers}), 200
         
-        except Exception as e:
-            logger.error(f"Error processing files: {str(e)}")
-            error_msg = str(e)
-            notification_queue.put({
-                "type": "error",
-                "message": error_msg
-            })
-            return jsonify({"error": error_msg}), 500
+        else:
+            error_msg = "Unsupported file type"
+            log_print(error_msg, "ERROR")
+            return jsonify({"error": error_msg}), 400
             
     except Exception as e:
-        logger.error(f"Error in compute_answers: {str(e)}")
-        error_msg = str(e)
-        notification_queue.put({
-            "type": "error",
-            "message": error_msg
-        })
+        error_msg = f"Error in compute_answers: {str(e)}"
+        log_print(error_msg, "ERROR")
         return jsonify({"error": error_msg}), 500
 
 def validate_folder_structure(files):

templates/2.html

@@ -1052,46 +1052,49 @@
 
         async function computeAnswers() {
             try {
-                showLoading();
+                showLogModal();
+                addLogMessage("Starting answer computation...", "info");
+                
                 const fileType = document.getElementById('file-type').value;
                 const queryfile = document.getElementById('query-file').files[0];
-                const anscsvFile = document.getElementById('csv-file').files[0];
-                const pdfFiles = document.getElementById('pdf-files').files;
-
+                
                 if (!queryfile) {
+                    addLogMessage("Error: Please upload a query file first!", "error");
                     notificationSystem.error("Please upload a query file first!");
-                    hideLoading();
                     return;
                 }
 
-                notificationSystem.info("Processing files...");
+                addLogMessage("Processing files...", "info");
                 const formData = new FormData();
                 formData.append('file_type', fileType);
                 formData.append('query_file', queryfile);
 
                 if (fileType === 'csv') {
+                    const anscsvFile = document.getElementById('csv-file').files[0];
                     if (!anscsvFile) {
+                        addLogMessage("Error: Please upload a CSV file for answers!", "error");
                         notificationSystem.error("Please upload a CSV file for answers!");
-                        hideLoading();
                         return;
                     }
                     formData.append('ans_csv_file', anscsvFile);
-                    notificationSystem.info("Processing CSV file...");
+                    addLogMessage("Processing CSV file...", "info");
                 } else if (fileType === 'pdf') {
+                    const pdfFiles = document.getElementById('pdf-files').files;
                     if (!pdfFiles || pdfFiles.length < 2) {
+                        addLogMessage("Error: Please upload at least 2 PDF files!", "error");
                         notificationSystem.error("Please upload at least 2 PDF files!");
-                        hideLoading();
                         return;
                     }
                     for (let file of pdfFiles) {
                         formData.append('pdf_files[]', file);
                     }
-                    notificationSystem.info(`Processing ${pdfFiles.length} PDF files...`);
+                    addLogMessage(`Processing ${pdfFiles.length} PDF files...`, "info");
                 }
 
                 const computeBtn = document.getElementById('compute-btn');
                 computeBtn.disabled = true;
 
+                addLogMessage("Sending request to server...", "info");
                 const response = await fetch('/compute_answers', { 
                     method: 'POST', 
                     body: formData 
@@ -1107,12 +1110,15 @@
                 }
 
                 if (result.answers) {
+                    addLogMessage("Successfully received answers from server", "success");
+                    
                     // Check for empty answers
                     const emptyAnswers = result.answers.filter(answer => 
                         !answer || (Array.isArray(answer) && answer.every(a => !a || a.trim() === ''))
                     );
 
                     if (emptyAnswers.length > 0) {
+                        addLogMessage(`Warning: ${emptyAnswers.length} empty answer(s) detected`, "warning");
                         notificationSystem.warning(`Warning: ${emptyAnswers.length} empty answer(s) detected. Please check your input files.`);
                     }
 
@@ -1133,17 +1139,19 @@
                                 : [firstValidAnswer]
                         });
                     } else {
+                        addLogMessage("Warning: No valid answers found in the input files", "warning");
                         notificationSystem.warning("No valid answers found in the input files.");
                     }
                     
                     displayAnswers(result.answers);
+                    addLogMessage("Successfully displayed answers!", "success");
                     notificationSystem.success("Successfully generated answers!");
                 } else {
                     throw new Error('No answers received from server');
                 }
 
             } catch (error) {
-                console.error('Error:', error);
+                addLogMessage(`Error: ${error.message}`, "error");
                 notificationSystem.error('Error: ' + error.message);
             } finally {
                 hideLoading();