Improve error handling in both frontend and backend

app.py

@@ -5,6 +5,8 @@ from pathlib import Path
 import uuid
 import pandas as pd # Added for CSV parsing
 from werkzeug.utils import secure_filename # Added for security
+import traceback
+import sys
 
 app = Flask(__name__)
 # Use absolute paths for robustness within Docker/HF Spaces
@@ -20,6 +22,15 @@ app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg', 'tif', 'tiff'}
 UPLOAD_FOLDER.mkdir(parents=True, exist_ok=True)
 RESULT_FOLDER.mkdir(parents=True, exist_ok=True)
 
+# Global error handler to ensure JSON responses
+@app.errorhandler(Exception)
+def handle_exception(e):
+    # Log the exception
+    print(f"Unhandled exception: {str(e)}")
+    print(traceback.format_exc())
+    # Return JSON instead of HTML for HTTP errors
+    return jsonify({"error": "Server error", "log": str(e)}), 500
+
 def allowed_file(filename):
     return '.' in filename and \
            filename.rsplit('.', 1)[1].lower() in app.config['ALLOWED_EXTENSIONS']
@@ -30,160 +41,172 @@ def index():
 
 @app.route('/process', methods=['POST'])
 def process_images():
-    if 'files' not in request.files:
-        return jsonify({"error": "No file part"}), 400
-
-    files = request.files.getlist('files')
-    input_mode = request.form.get('input_mode', 'single') # Get from form data
-    confidence = request.form.get('confidence_threshold', '0.6') # Get from form data
-
-    if not files or files[0].filename == '':
-        return jsonify({"error": "No selected file"}), 400
-
-    # Create a unique job directory within results
-    job_id = str(uuid.uuid4())
-    job_input_dir = RESULT_FOLDER / job_id / 'input' # Save inputs within job dir
-    job_output_dir = RESULT_FOLDER / job_id / 'output' # Save outputs within job dir
-    job_input_dir.mkdir(parents=True, exist_ok=True)
-    job_output_dir.mkdir(parents=True, exist_ok=True)
-
-    saved_files = []
-    error_files = []
-
-    for file in files:
-        if file and allowed_file(file.filename):
-            filename = secure_filename(file.filename)
-            save_path = job_input_dir / filename
-            file.save(str(save_path))
-            saved_files.append(save_path)
-        elif file:
-            error_files.append(file.filename)
-
-    if not saved_files:
-         return jsonify({"error": f"No valid files uploaded. Invalid files: {error_files}"}), 400
-
-    # --- Prepare and Run nemaquant.py ---
-    # Determine input target for nemaquant.py
-    if input_mode == 'single' and len(saved_files) == 1:
-        input_target = str(saved_files[0])
-        img_mode_arg = 'file' # nemaquant uses file/dir, not single/directory
-    elif input_mode == 'directory' and len(saved_files) >= 1:
-        input_target = str(job_input_dir) # Pass the directory containing the images
-        img_mode_arg = 'dir'
-    else:
-        # Mismatch between mode and number of files
-        return jsonify({"error": f"Input mode '{input_mode}' requires {'1 file' if input_mode == 'single' else '1 or more files'}, but received {len(saved_files)}."}), 400
-
-
-    output_csv = job_output_dir / f"{job_id}_results.csv"
-    annotated_dir = job_output_dir # Save annotated images directly in job output dir
-
-    cmd = [
-        'python', str(APP_ROOT / 'nemaquant.py'),
-        '-i', input_target,
-        '-w', str(WEIGHTS_FILE), # Use absolute path
-        '-o', str(output_csv),
-        '-a', str(annotated_dir),
-        '--conf', confidence
-    ]
-
-    # We don't need --key or XY mode for this web interface initially
-
     try:
-        print(f"Running command: {' '.join(cmd)}") # Log the command
-        print(f"Input directory contents: {os.listdir(str(job_input_dir))}")
-        print(f"Weights file exists: {os.path.exists(str(WEIGHTS_FILE))}")
-        
-        # Run the script, capture output and errors
-        # Timeout might be needed for long processes on shared infrastructure like HF Spaces
-        result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=300) # 5 min timeout
-        status_log = f"NemaQuant Output:\n{result.stdout}\nNemaQuant Errors:\n{result.stderr}"
-        print(status_log) # Log script output
-        
-        # Check output directory after command runs
-        print(f"Output directory exists: {os.path.exists(str(job_output_dir))}")
-        if os.path.exists(str(job_output_dir)):
-            print(f"Output directory contents: {os.listdir(str(job_output_dir))}")
-        
-        # Check output file
-        print(f"Output CSV exists: {os.path.exists(str(output_csv))}")
-
-        # --- Parse Results ---
-        if not output_csv.exists():
-             raise FileNotFoundError(f"Output CSV not found at {output_csv}")
-
-        df = pd.read_csv(output_csv)
-        # Expect columns like 'filename', 'num_eggs' (based on nemaquant.py)
-        # Find corresponding annotated images
-        results_list = []
-        for index, row in df.iterrows():
-            original_filename = row.get('filename', '')
-            num_eggs = row.get('num_eggs', 'N/A')
-            # Construct expected annotated filename (based on nemaquant.py logic)
-            stem = Path(original_filename).stem
-            suffix = Path(original_filename).suffix
-            annotated_filename = f"{stem}_annotated{suffix}"
-            annotated_path = annotated_dir / annotated_filename
+        if 'files' not in request.files:
+            return jsonify({"error": "No file part"}), 400
+
+        files = request.files.getlist('files')
+        input_mode = request.form.get('input_mode', 'single') # Get from form data
+        confidence = request.form.get('confidence_threshold', '0.6') # Get from form data
+
+        if not files or files[0].filename == '':
+            return jsonify({"error": "No selected file"}), 400
+
+        # Create a unique job directory within results
+        job_id = str(uuid.uuid4())
+        job_input_dir = RESULT_FOLDER / job_id / 'input' # Save inputs within job dir
+        job_output_dir = RESULT_FOLDER / job_id / 'output' # Save outputs within job dir
+        job_input_dir.mkdir(parents=True, exist_ok=True)
+        job_output_dir.mkdir(parents=True, exist_ok=True)
+
+        saved_files = []
+        error_files = []
+
+        for file in files:
+            if file and allowed_file(file.filename):
+                filename = secure_filename(file.filename)
+                save_path = job_input_dir / filename
+                file.save(str(save_path))
+                saved_files.append(save_path)
+            elif file:
+                error_files.append(file.filename)
+
+        if not saved_files:
+             return jsonify({"error": f"No valid files uploaded. Invalid files: {error_files}"}), 400
+
+        # --- Prepare and Run nemaquant.py ---
+        # Determine input target for nemaquant.py
+        if input_mode == 'single' and len(saved_files) == 1:
+            input_target = str(saved_files[0])
+            img_mode_arg = 'file' # nemaquant uses file/dir, not single/directory
+        elif input_mode == 'directory' and len(saved_files) >= 1:
+            input_target = str(job_input_dir) # Pass the directory containing the images
+            img_mode_arg = 'dir'
+        else:
+            # Mismatch between mode and number of files
+            return jsonify({"error": f"Input mode '{input_mode}' requires {'1 file' if input_mode == 'single' else '1 or more files'}, but received {len(saved_files)}."}), 400
+
+
+        output_csv = job_output_dir / f"{job_id}_results.csv"
+        annotated_dir = job_output_dir # Save annotated images directly in job output dir
+
+        cmd = [
+            'python', str(APP_ROOT / 'nemaquant.py'),
+            '-i', input_target,
+            '-w', str(WEIGHTS_FILE), # Use absolute path
+            '-o', str(output_csv),
+            '-a', str(annotated_dir),
+            '--conf', confidence
+        ]
+
+        # We don't need --key or XY mode for this web interface initially
+
+        try:
+            print(f"Running command: {' '.join(cmd)}") # Log the command
+            print(f"Input directory contents: {os.listdir(str(job_input_dir))}")
+            print(f"Weights file exists: {os.path.exists(str(WEIGHTS_FILE))}")
+            print(f"Weights file size: {os.path.getsize(str(WEIGHTS_FILE)) if os.path.exists(str(WEIGHTS_FILE)) else 'File not found'} bytes")
             
-            print(f"Looking for annotated file: {annotated_path}, exists: {annotated_path.exists()}")
-
-            results_list.append({
-                "filename": original_filename,
-                "num_eggs": num_eggs,
-                # Pass relative path within job dir for frontend URL construction
-                "annotated_filename": annotated_filename if annotated_path.exists() else None,
+            # Run the script, capture output and errors
+            # Timeout might be needed for long processes on shared infrastructure like HF Spaces
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=300) # 5 min timeout
+            status_log = f"NemaQuant Output:\n{result.stdout}\nNemaQuant Errors:\n{result.stderr}"
+            print(status_log) # Log script output
+            
+            # Check output directory after command runs
+            print(f"Output directory exists: {os.path.exists(str(job_output_dir))}")
+            if os.path.exists(str(job_output_dir)):
+                print(f"Output directory contents: {os.listdir(str(job_output_dir))}")
+            
+            # Check output file
+            print(f"Output CSV exists: {os.path.exists(str(output_csv))}")
+
+            # --- Parse Results ---
+            if not output_csv.exists():
+                 raise FileNotFoundError(f"Output CSV not found at {output_csv}")
+
+            df = pd.read_csv(output_csv)
+            # Expect columns like 'filename', 'num_eggs' (based on nemaquant.py)
+            # Find corresponding annotated images
+            results_list = []
+            for index, row in df.iterrows():
+                original_filename = row.get('filename', '')
+                num_eggs = row.get('num_eggs', 'N/A')
+                # Construct expected annotated filename (based on nemaquant.py logic)
+                stem = Path(original_filename).stem
+                suffix = Path(original_filename).suffix
+                annotated_filename = f"{stem}_annotated{suffix}"
+                annotated_path = annotated_dir / annotated_filename
+                
+                print(f"Looking for annotated file: {annotated_path}, exists: {annotated_path.exists()}")
+
+                results_list.append({
+                    "filename": original_filename,
+                    "num_eggs": num_eggs,
+                    # Pass relative path within job dir for frontend URL construction
+                    "annotated_filename": annotated_filename if annotated_path.exists() else None,
+                })
+
+            return jsonify({
+                "status": "success",
+                "job_id": job_id,
+                "results": results_list,
+                "log": status_log,
+                "error_files": error_files # Report files that were not processed
             })
 
-        return jsonify({
-            "status": "success",
-            "job_id": job_id,
-            "results": results_list,
-            "log": status_log,
-            "error_files": error_files # Report files that were not processed
-        })
-
-    except subprocess.CalledProcessError as e:
-        error_message = f"Error running NemaQuant:\nExit Code: {e.returncode}\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}"
-        print(error_message)
-        return jsonify({"error": "Processing failed", "log": error_message}), 500
-    except subprocess.TimeoutExpired as e:
-        error_message = f"Error running NemaQuant: Process timed out after {e.timeout} seconds.\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}"
-        print(error_message)
-        return jsonify({"error": "Processing timed out", "log": error_message}), 500
-    except FileNotFoundError as e:
-        error_message = f"Error processing results: {e}"
-        print(error_message)
-        return jsonify({"error": "Could not find output file", "log": error_message}), 500
+        except subprocess.CalledProcessError as e:
+            error_message = f"Error running NemaQuant:\nExit Code: {e.returncode}\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}"
+            print(error_message)
+            return jsonify({"error": "Processing failed", "log": error_message}), 500
+        except subprocess.TimeoutExpired as e:
+            error_message = f"Error running NemaQuant: Process timed out after {e.timeout} seconds.\nSTDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}"
+            print(error_message)
+            return jsonify({"error": "Processing timed out", "log": error_message}), 500
+        except FileNotFoundError as e:
+            error_message = f"Error processing results: {e}"
+            print(error_message)
+            return jsonify({"error": "Could not find output file", "log": error_message}), 500
+        except Exception as e:
+            error_message = f"An unexpected error occurred: {str(e)}\n"
+            error_message += traceback.format_exc()
+            print(error_message)
+            return jsonify({"error": "An unexpected error occurred", "log": error_message}), 500
     except Exception as e:
-        error_message = f"An unexpected error occurred: {str(e)}\n"
-        import traceback
-        error_message += traceback.format_exc()
+        # High-level exception handler for the entire route
+        error_message = f"Global process error: {str(e)}\n{traceback.format_exc()}"
         print(error_message)
-        return jsonify({"error": "An unexpected error occurred", "log": error_message}), 500
+        return jsonify({"error": "Server error", "log": error_message}), 500
 
 
 @app.route('/results/<job_id>/<path:filename>')
 def download_file(job_id, filename):
-    # Construct the full path to the file within the job's output directory
-    # Use secure_filename on the incoming filename part for safety? Maybe not needed if we trust our generated paths.
-    # Crucially, validate job_id and filename to prevent directory traversal.
-    # A simple check: ensure job_id is a valid UUID format and filename doesn't contain '..'
-    try:
-        uuid.UUID(job_id, version=4) # Validate UUID format
-    except ValueError:
-        return "Invalid job ID format", 400
-
-    if '..' in filename or filename.startswith('/'):
-        return "Invalid filename", 400
-
-    file_dir = RESULT_FOLDER / job_id / 'output'
-    # Use send_from_directory for security (handles path joining and prevents traversal above the specified directory)
-    print(f"Attempting to send file: {filename} from directory: {file_dir}")
     try:
-        return send_from_directory(str(file_dir), filename, as_attachment=False) # Display images inline
-    except FileNotFoundError:
-        print(f"File not found: {file_dir / filename}")
-        return "File not found", 404
+        # Construct the full path to the file within the job's output directory
+        # Use secure_filename on the incoming filename part for safety? Maybe not needed if we trust our generated paths.
+        # Crucially, validate job_id and filename to prevent directory traversal.
+        # A simple check: ensure job_id is a valid UUID format and filename doesn't contain '..'
+        try:
+            uuid.UUID(job_id, version=4) # Validate UUID format
+        except ValueError:
+            return jsonify({"error": "Invalid job ID format"}), 400
+
+        if '..' in filename or filename.startswith('/'):
+            return jsonify({"error": "Invalid filename"}), 400
+
+        file_dir = RESULT_FOLDER / job_id / 'output'
+        # Use send_from_directory for security (handles path joining and prevents traversal above the specified directory)
+        print(f"Attempting to send file: {filename} from directory: {file_dir}")
+        try:
+            return send_from_directory(str(file_dir), filename, as_attachment=False) # Display images inline
+        except FileNotFoundError:
+            print(f"File not found: {file_dir / filename}")
+            return jsonify({"error": "File not found"}), 404
+    except Exception as e:
+        # Catch-all exception handler
+        error_message = f"File serving error: {str(e)}"
+        print(error_message)
+        return jsonify({"error": "Server error", "log": error_message}), 500
 
 
 if __name__ == '__main__':
@@ -193,4 +216,14 @@ if __name__ == '__main__':
         print("Please ensure 'weights.pt' is in the application root directory.")
         exit(1) # Exit if weights are missing
 
+    # Log startup information
+    print("----- NemaQuant Flask App Starting -----")
+    print(f"Working directory: {os.getcwd()}")
+    print(f"Python version: {sys.version}")
+    print(f"Weights file: {WEIGHTS_FILE}")
+    print(f"Weights file exists: {os.path.exists(str(WEIGHTS_FILE))}")
+    if os.path.exists(str(WEIGHTS_FILE)):
+        print(f"Weights file size: {os.path.getsize(str(WEIGHTS_FILE))} bytes")
+    print("---------------------------------------")
+
     app.run(debug=True, host='0.0.0.0', port=7860) # Port 7860 is common for HF Spaces 

static/script.js

@@ -83,6 +83,17 @@ document.addEventListener('DOMContentLoaded', () => {
             progress.value = 100;
             progressText.textContent = '100%';
 
+            // First check if the response is valid
+            const contentType = response.headers.get('content-type');
+            if (!contentType || !contentType.includes('application/json')) {
+                // Handle non-JSON response
+                const textResponse = await response.text();
+                logStatus(`Error: Server returned non-JSON response: ${textResponse.substring(0, 200)}...`);
+                processingStatus.textContent = 'Error: Server returned invalid format';
+                throw new Error('Server returned non-JSON response');
+            }
+
+            // Now we can safely parse JSON
             const data = await response.json();
 
             if (response.ok) {