removing time out errro

main.py

@@ -313,6 +313,15 @@ def validate_folder_structure(files):
 @app.route('/compute_marks', methods=['POST'])
 def compute_marks():
     try:
+        # Wait for initialization to complete
+        if not initialization_complete.is_set():
+            wait_for_initialization()
+            if not initialization_complete.is_set():
+                return jsonify({
+                    "error": "Server initialization",
+                    "message": "Server is still initializing. Please try again in a moment."
+                }), 503
+
         # Get correct answers
         correct_answers = request.form.getlist('correct_answers[]')
         log_print(f"Received correct answers: {correct_answers}")
@@ -346,6 +355,18 @@ def compute_marks():
                 "message": "No files uploaded"
             }), 400
 
+        # Check total file size
+        total_size = sum(len(file.read()) for file in files)
+        for file in files:
+            file.seek(0)  # Reset file pointers after reading
+            
+        max_size = 15 * 1024 * 1024  # 15MB
+        if total_size > max_size:
+            return jsonify({
+                "error": "File size limit exceeded",
+                "message": f"Total file size must be less than 15MB (current size: {total_size / 1024 / 1024:.1f}MB)"
+            }), 413
+
         # Validate folder structure
         is_valid, message = validate_folder_structure(files)
         log_print(f"Folder structure validation: {message}")
@@ -641,8 +662,19 @@ if __name__ == '__main__':
         for directory in essential_dirs:
             ensure_directory(directory)
         
-        # Start the Flask app
+        # Configure server for long-running requests
+        app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
+        app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024  # Increase to 50MB
+        
+        # Start the Flask app with increased timeout
+        from werkzeug.serving import run_simple
         port = int(os.environ.get('PORT', 7860))
-        app.run(host='0.0.0.0', port=port, debug=False)
+        run_simple('0.0.0.0', port, app, 
+                  use_reloader=False, 
+                  threaded=True,
+                  request_handler=None,
+                  passthrough_errors=True,
+                  ssl_context=None,
+                  socket_timeout=600)  # 10 minute timeout
     finally:
         cleanup_temp_files()

templates/index.html

@@ -1177,17 +1177,19 @@
                     return;
                 }
 
-                notificationSystem.info(`Processing ${selectedFiles.size} student files...`);
+                notificationSystem.info(`Processing ${selectedFiles.size} student files. This may take several minutes...`);
                 
                 const computeBtn = document.getElementById('compute-marks-btn');
                 computeBtn.disabled = true;
 
                 const formData = new FormData();
                 
+                // Add each answer as a separate correct_answers[] entry
                 answerValues.forEach((answer, index) => {
                     formData.append('correct_answers[]', answer);
                 });
 
+                // Add files with their folder structure
                 let validFiles = 0;
                 selectedFiles.forEach((fileInfo, path) => {
                     if (fileInfo.file.type.startsWith('image/')) {
@@ -1200,46 +1202,62 @@
                     throw new Error("No valid image files found in the uploaded folder");
                 }
 
-                notificationSystem.info(`Processing ${validFiles} valid image files...`);
+                notificationSystem.info(`Uploading and processing ${validFiles} files. Please be patient...`);
                 
-                const response = await fetch('/compute_marks', {
-                    method: 'POST',
-                    headers: {
-                        'Accept': 'application/json'
-                    },
-                    body: formData
-                });
+                // Update loading message
+                document.querySelector('.loading-text').innerHTML = `
+                    Processing ${validFiles} files...<br>
+                    This may take several minutes depending on the number of files.<br>
+                    Please keep this window open.
+                `;
 
-                const responseText = await response.text();
-                let result;
                 try {
-                    result = JSON.parse(responseText);
-                } catch (e) {
-                    console.error('Error parsing JSON:', e);
-                    throw new Error('Invalid JSON response from server');
-                }
+                    const controller = new AbortController();
+                    const response = await fetch('/compute_marks', {
+                        method: 'POST',
+                        body: formData,
+                        signal: controller.signal,
+                        // Remove timeout, let the browser handle connection timeouts
+                        keepalive: true
+                    });
 
-                if (result.error) {
-                    throw new Error(result.message || result.error);
-                }
+                    if (!response.ok) {
+                        const errorData = await response.json();
+                        throw new Error(errorData.message || `Server error: ${response.status}`);
+                    }
 
-                if (!result.results) {
-                    throw new Error('No results found in server response');
-                }
+                    const result = await response.json();
+                    
+                    if (result.error) {
+                        throw new Error(result.message || result.error);
+                    }
+
+                    if (!result.results) {
+                        throw new Error('No results found in server response');
+                    }
 
-                displayMarks(result.results);
-                notificationSystem.success("Successfully computed marks!");
+                    displayMarks(result.results);
+                    notificationSystem.success("Successfully computed marks!");
 
-                if (result.failed_files && result.failed_files.length > 0) {
-                    const failedMessage = result.failed_files
-                        .map(f => `${f.file}: ${f.error}`)
-                        .join('\n');
-                    notificationSystem.warning(`Some files failed to process:\n${failedMessage}`);
+                    if (result.failed_files && result.failed_files.length > 0) {
+                        const failedMessage = result.failed_files
+                            .map(f => `${f.file}: ${f.error}`)
+                            .join('\n');
+                        notificationSystem.warning(`Some files failed to process:\n${failedMessage}`);
+                    }
+
+                } catch (fetchError) {
+                    console.error('Fetch error:', fetchError);
+                    if (!navigator.onLine) {
+                        throw new Error('No internet connection. Please check your connection and try again.');
+                    } else {
+                        throw new Error(`Server error: ${fetchError.message}`);
+                    }
                 }
 
             } catch (error) {
                 console.error('Error details:', error);
-                notificationSystem.error('Error computing marks: ' + error.message);
+                notificationSystem.error(error.message || 'Error computing marks. Please try again.');
             } finally {
                 hideLoading();
                 const computeBtn = document.getElementById('compute-marks-btn');
@@ -1247,6 +1265,71 @@
             }
         }
 
+        // Add this helper function to check file size
+        function getFileSizeMB(file) {
+            return file.size / (1024 * 1024);
+        }
+
+        // Add this function to handle folder uploads
+        async function handleFolderUpload(event) {
+            try {
+                const files = event.target.files;
+                if (!files || files.length === 0) {
+                    notificationSystem.error("No files selected");
+                    return;
+                }
+
+                // Clear previous files
+                selectedFiles.clear();
+                
+                let totalSize = 0;
+                const maxTotalSize = 15; // Maximum total size in MB
+                const maxFileSize = 2; // Maximum size per file in MB
+
+                // Process each file
+                for (const file of files) {
+                    const fileSize = getFileSizeMB(file);
+                    
+                    // Check individual file size
+                    if (fileSize > maxFileSize) {
+                        notificationSystem.warning(`File ${file.name} is too large (${fileSize.toFixed(1)}MB). Maximum size is ${maxFileSize}MB.`);
+                        continue;
+                    }
+
+                    // Check total size
+                    if (totalSize + fileSize > maxTotalSize) {
+                        notificationSystem.warning(`Total file size limit of ${maxTotalSize}MB exceeded. Some files were not added.`);
+                        break;
+                    }
+
+                    // Add file if it's an image
+                    if (file.type.startsWith('image/')) {
+                        const fullPath = file.webkitRelativePath || file.name;
+                        selectedFiles.set(fullPath, {
+                            file: file,
+                            fullPath: fullPath
+                        });
+                        totalSize += fileSize;
+                    } else {
+                        notificationSystem.warning(`File ${file.name} is not an image file and was skipped.`);
+                    }
+                }
+
+                // Update UI with selected files
+                updateFileTree();
+                
+                if (selectedFiles.size > 0) {
+                    notificationSystem.success(`Successfully loaded ${selectedFiles.size} image files.`);
+                } else {
+                    notificationSystem.error("No valid image files were found in the selected folder.");
+                }
+
+            } catch (error) {
+                console.error('Error handling folder upload:', error);
+                notificationSystem.error('Error processing folder: ' + error.message);
+            }
+        }
+
         function displayMarks(results) {
             const tableBody = document.getElementById('marks-table-body');
             if (!tableBody) {