Update app files and add gitignore

.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+weights.pt
+weights_nemaquant.v1.onnx
+results/ 

README.md

@@ -1,90 +1,190 @@
 ---
-title: Nemaquant Flask
-emoji: 🏆
+title: NemaQuant
+emoji: 🔬
 colorFrom: indigo
 colorTo: blue
 sdk: docker
-pinned: false
+license: apache-2.0
+short_description: "YOLO-based nematode egg detection with real-time processing"
+tags:
+  - microscopy
+  - object-detection
+  - yolo
+  - biology
+  - image-processing
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# NemaQuant Flask App
 
-# NemaQuant Flask App for Hugging Face Spaces
+A modern web application for automated nematode egg detection and counting using deep learning. This application provides an intuitive interface to process microscope images and identify nematode eggs using the YOLO object detection model.
 
-This repository contains a Flask application designed to provide a web interface for the `nemaquant.py` script, allowing users to upload images and run nematode egg detection via a Hugging Face Space.
+## Quick Performance Guide
+- **Free Tier** (2 vCPU): 19 images ≈ 1:13 minutes
+- **CPU Upgrade** ($0.03/hr): 3-4x faster
+- **GPU Option** ($0.40/hr): 8-10x faster
+
+Process 500 images for:
+- FREE on basic tier (≈ 35 min)
+- $0.09 with CPU upgrade (≈ 10 min)
+- $0.03 with GPU (≈ 4 min)
+
+## Features
+
+- **Multiple Input Modes**:
+  - Single image processing
+  - Batch processing of multiple images
+  - Directory/folder processing
+- **Real-time Progress Tracking**: Monitor processing progress for large batches
+- **Interactive Results**:
+  - Sortable results table
+  - Pagination for large datasets
+  - Export functionality for annotated images
+- **Flexible Image Support**:
+  - Supports PNG, JPG, JPEG, TIF, and TIFF formats
+  - Automatic conversion of TIF/TIFF to PNG for web viewing
+- **Confidence Threshold Adjustment**: Fine-tune detection sensitivity
+- **Batch Export**: Download all annotated images as a ZIP file
 
 ## Project Structure
 
 ```
 /
-├── app.py                  # Main Flask application logic
-├── nemaquant.py            # Original image analysis script
-├── requirements.txt        # Python dependencies
-├── Dockerfile              # Docker configuration for HF Spaces
-├── README.md               # This file
+├── app.py                  # Flask application with REST endpoints and core logic
+├── nemaquant.py           # YOLO-based image analysis script
+├── requirements.txt       # Python dependencies
+├── Dockerfile            # Container configuration
+├── README.md            
 ├── templates/
-│   └── index.html          # HTML template for the frontend
+│   └── index.html        # Modern, responsive web interface
 ├── static/
-│   ├── style.css           # CSS styles
-│   └── script.js           # JavaScript for frontend interactions
-├── uploads/                # Directory for user-uploaded files (created automatically)
-├── results/                # Directory for output files (created automatically)
-└── weights.pt              # YOLO model weights (Ensure this is present or downloaded)
+│   ├── style.css        # CSS styling
+│   └── script.js        # Frontend interactivity and async processing
+└── weights.pt           # YOLO model weights (required)
 ```
 
-## Hugging Face Space Setup
-
-1.  **Create a new Space:** Go to [huggingface.co/new-space](https://huggingface.co/new-space).
-2.  **Owner & Space Name:** Choose your username/organization and a name for the space (e.g., `nemaquant-demo`).
-3.  **License:** Select an appropriate license (e.g., Apache 2.0).
-4.  **SDK:** Select **Docker**. Choose the **Blank** template.
-5.  **Hardware:** Select appropriate hardware (e.g., CPU Basic should be sufficient initially, but might need upgrading depending on model size and processing time).
-6.  **Secrets (Optional):** If your application needs API keys or other secrets, add them here.
-7.  **Create Space.**
-
-8.  **Upload Files:** Upload all the files from this repository to your new Hugging Face Space repository. You can do this via the web interface or using Git:
-    ```bash
-    # Clone your new space repository
-    git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
-    cd YOUR_SPACE_NAME
-
-    # Add all your project files (ensure you have weights.pt)
-    # ... copy files here ...
-
-    # Commit and push
-    git add .
-    git commit -m "Initial commit of NemaQuant app"
-    git push
-    ```
-
-9.  **Model Weights (`weights.pt`):**
-    *   Make sure the `weights.pt` file required by `nemaquant.py` is included in the root directory of your repository.
-    *   If the weights file is large, consider using Git LFS (Large File Storage). Enable LFS in your Space settings under the "Settings" tab.
-        ```bash
-        # Install git-lfs if you haven't already
-        git lfs install
-        git lfs track "*.pt" # Track the weights file
-        git add .gitattributes # Add the tracking file
-        git add weights.pt
-        git commit -m "Add weights file using LFS"
-        git push
-        ```
-
-10. **Building:** The Space will automatically start building the Docker image based on your `Dockerfile`. Monitor the build logs.
-
-11. **Running:** Once built, the application should start automatically. You can access it via the public URL provided for your Space.
-
-## Local Development (Optional)
-
-1.  **Install Docker:** Make sure you have Docker installed and running.
-2.  **Build the image:**
-    ```bash
-    docker build -t nemaquant-flask .
-    ```
-3.  **Run the container:**
-    ```bash
-    docker run -p 7860:7860 -v $(pwd)/results:/app/results nemaquant-flask
-    ```
-    *   This maps port 7860 from the container to your host machine.
-    *   It also mounts the local `results` directory into the container's `/app/results` directory, so you can easily access generated files.
-4.  Open your browser to `http://localhost:7860`.
+## Technical Requirements
+
+- Python 3.9+
+- Key Dependencies:
+  - Flask >= 2.0.0
+  - PyTorch >= 2.0.0
+  - Ultralytics >= 8.0.0
+  - OpenCV Python >= 4.7.0
+  - Pandas >= 1.5.0
+  - NumPy >= 1.21.0
+
+## Setup and Deployment
+
+### Local Development
+
+1. **Clone the Repository**:
+   ```bash
+   git clone <repository-url>
+   cd nemaquant-flask
+   ```
+
+2. **Install Dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Prepare Model Weights**:
+   - Place your `weights.pt` file in the root directory
+   - Ensure it's a compatible YOLO model trained for egg detection
+
+4. **Run the Application**:
+   ```bash
+   python app.py
+   ```
+   The application will be available at `http://localhost:7860`
+
+### Docker Deployment
+
+1. **Build the Container**:
+   ```bash
+   docker build -t nemaquant-flask .
+   ```
+
+2. **Run the Container**:
+   ```bash
+   docker run -p 7860:7860 -v $(pwd)/results:/app/results nemaquant-flask
+   ```
+
+### Hugging Face Spaces Deployment
+
+1. Create a new Space on [Hugging Face](https://huggingface.co/new-space)
+2. Select Docker as the SDK
+3. Configure the Space:
+   - Set app_port to 7860
+   - Enable Git LFS for the weights file
+4. Push your code:
+   ```bash
+   git lfs install
+   git lfs track "*.pt"
+   git add .gitattributes weights.pt
+   git add .
+   git commit -m "Initial deployment"
+   git push
+   ```
+
+## Usage
+
+1. **Select Input Mode**:
+   - Choose between single image, multiple images, or folder processing
+   - For folder mode, ensure images follow the expected structure
+
+2. **Upload Images**:
+   - Drag and drop or use the file browser
+   - Supported formats: PNG, JPG, JPEG, TIF, TIFF
+
+3. **Configure Processing**:
+   - Adjust confidence threshold if needed (default: 0.6)
+   - Click "Process Images" to start
+
+4. **View Results**:
+   - Monitor real-time progress
+   - View detected egg counts in the results table
+   - Sort and paginate through results
+   - Download annotated images individually or as a batch
+
+## Processing Time & Cost Estimates
+
+### Free Tier (CPU Basic - 2 vCPU, 16GB RAM)
+- **Processing Time**:
+  - 19 images: ~1:13 (actual measured time)
+  - 100 images: ~6-7 minutes
+  - 500 images: ~30-35 minutes
+- **Cost**: FREE
+- **Limitations**: 
+  - Slower processing speed
+  - 48 hour inactivity timeout
+  - Shared resources may affect performance
+  - Processing time may increase with server load
+
+### CPU Upgrade Option (8 vCPU, 32GB RAM)
+- **Processing Time** (estimated 3-4x faster than free tier):
+  - 100 images: ~2 minutes
+  - 500 images: ~10 minutes
+- **Cost**:
+  - $0.03/hour for CPU Upgrade
+  - Estimated cost for 100 images: ~$0.03
+  - Estimated cost for 500 images: ~$0.09 (0.17 hours * $0.03/hour)
+
+### GPU Options (Optional)
+- **Nvidia T4 Small (4 vCPU, 16GB VRAM)**:
+  - Processing Time (estimated 8-10x faster than free tier):
+    - 100 images: ~45 seconds
+    - 500 images: ~4 minutes
+  - Cost: $0.40/hour (~$0.01 for 100 images, ~$0.03 for 500 images)
+
+**Note**: These estimates are approximate and may vary based on:
+- Image size and complexity
+- Server load and availability
+- Network conditions for upload/download
+- Time of day (free tier performance varies with overall platform usage)
+
+For most users, the free tier is sufficient for small to medium batches (< 200 images), while the CPU upgrade offers a good balance of cost and performance for larger datasets. GPU options are recommended only for time-sensitive processing of large batches or when processing thousands of images.
+
+## License
+
+[Specify your license here]

app.py

@@ -3,47 +3,41 @@ import subprocess
 import os
 from pathlib import Path
 import uuid
-import pandas as pd # Added for CSV parsing
-from werkzeug.utils import secure_filename # Added for security
+import pandas as pd
+from werkzeug.utils import secure_filename
 import traceback
 import sys
 import re
 from PIL import Image
 import io
-import threading # Add threading
-import time # Add time
-import zipfile # Add zipfile for image export
-from datetime import datetime # Add datetime for timestamps
+import threading
+import time
+from datetime import datetime
+import zipfile
 
 app = Flask(__name__)
-# Use absolute paths for robustness within Docker/HF Spaces
+
 APP_ROOT = Path(__file__).parent
-UPLOAD_FOLDER = APP_ROOT / 'uploads' # Keep separate upload folder initially
+UPLOAD_FOLDER = APP_ROOT / 'uploads'
 RESULT_FOLDER = APP_ROOT / 'results'
-WEIGHTS_FILE = APP_ROOT / 'weights.pt' # Assuming weights are in root
+WEIGHTS_FILE = APP_ROOT / 'weights.pt'
 app.config['UPLOAD_FOLDER'] = str(UPLOAD_FOLDER)
 app.config['RESULT_FOLDER'] = str(RESULT_FOLDER)
 app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg', 'tif', 'tiff'}
 
-# Ensure upload and result folders exist
 UPLOAD_FOLDER.mkdir(parents=True, exist_ok=True)
 RESULT_FOLDER.mkdir(parents=True, exist_ok=True)
 
-# Dictionary to store job status
 job_status = {}
 
-# 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']
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in app.config['ALLOWED_EXTENSIONS']
 
 @app.route('/')
 def index():
@@ -57,16 +51,14 @@ def process_images():
             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
+        input_mode = request.form.get('input_mode', 'single')
+        confidence = request.form.get('confidence_threshold', '0.6')
 
         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())
-        # Save inputs directly into job output dir to simplify cleanup/access
-        job_output_dir = RESULT_FOLDER / job_id # Combine input/output
+        job_output_dir = RESULT_FOLDER / job_id
         job_output_dir.mkdir(parents=True, exist_ok=True)
 
         saved_files = []
@@ -75,7 +67,7 @@ def process_images():
         for file in files:
             if file and allowed_file(file.filename):
                 filename = secure_filename(file.filename)
-                save_path = job_output_dir / filename # Save directly into job dir
+                save_path = job_output_dir / filename
                 file.save(str(save_path))
                 saved_files.append(save_path)
             elif file:
@@ -84,32 +76,20 @@ def process_images():
         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 == 'files' or input_mode == 'folder': # Treat 'files' as 'dir' if multiple files
-            input_target = str(job_output_dir) # Process all files in the job dir
-            img_mode_arg = 'dir' # Always use dir mode now? Check nemaquant.py
+        if input_mode in ['files', 'folder']:
+            input_target = str(job_output_dir)
+            img_mode_arg = 'dir'
         elif input_mode == 'single':
-             if len(saved_files) == 1:
-                 input_target = str(saved_files[0])
-                 img_mode_arg = 'file' # Use file mode only if explicitly single and one file
-             else:
-                 # Handle case where 'single' is selected but multiple files uploaded
-                 # Option 1: Error out
-                 # return jsonify({"error": "Single file mode selected, but multiple files uploaded."}), 400
-                 # Option 2: Process only the first file
-                 input_target = str(saved_files[0])
-                 img_mode_arg = 'file'
-                 print(f"Warning: Single file mode selected, processing only the first file: {saved_files[0].name}")
-        else: # Should not happen if frontend validates
-             return jsonify({"error": f"Invalid input mode: {input_mode}"}), 400
-
-        # Define output paths within the job directory
-        output_csv = job_output_dir / f"results.csv" # Simplified CSV name
-        annotated_dir = job_output_dir # Annotations saved in the same place
+            input_target = str(saved_files[0])
+            img_mode_arg = 'file'
+        else:
+            return jsonify({"error": f"Invalid input mode: {input_mode}"}), 400
+
+        output_csv = job_output_dir / "results.csv"
+        annotated_dir = job_output_dir
 
         cmd = [
-            sys.executable, # Use the same python interpreter
+            sys.executable,
             str(APP_ROOT / 'nemaquant.py'),
             '-i', input_target,
             '-w', str(WEIGHTS_FILE),
@@ -120,96 +100,65 @@ def process_images():
 
         print(f"[{job_id}] Prepared command: {' '.join(cmd)}")
 
-        # Initialize job status
-        job_status[job_id] = {"status": "starting", "progress": 0, "log": "Job initiated", "results": None, "error": None}
+        job_status[job_id] = {
+            "status": "starting",
+            "progress": 0,
+            "log": "Job initiated",
+            "results": None,
+            "error": None
+        }
 
-        # Run in background thread
         thread = threading.Thread(target=run_nemaquant_background, args=(job_id, cmd, job_output_dir, output_csv, input_mode))
         thread.start()
 
-        # Return immediately with job ID
         return jsonify({
             "status": "processing",
             "job_id": job_id,
-             "initial_log": f"Job '{job_id}' started. Input mode: {input_mode}. Files saved in results/{job_id}/. Polling for progress..."
+            "initial_log": f"Job '{job_id}' started. Input mode: {input_mode}. Files saved in results/{job_id}/. Polling for progress..."
         })
 
-    except Exception as e: # Catch setup errors before thread starts
+    except Exception as e:
         error_message = f"Error starting process: {str(e)}\\n{traceback.format_exc()}"
         print(error_message)
-        # Ensure a job_id isn't lingering if setup failed badly
-        # if 'job_id' in locals() and job_id in job_status: del job_status[job_id] # Might be too aggressive
         return jsonify({"error": "Failed to start processing", "log": error_message}), 500
 
-
-# --- New Progress Endpoint ---
 @app.route('/progress/<job_id>')
 def get_progress(job_id):
-    global job_status
     status = job_status.get(job_id)
-    if status:
-        return jsonify(status)
-    else:
-        return jsonify({"status": "error", "error": "Job ID not found"}), 404
-
+    return jsonify(status) if status else (jsonify({"status": "error", "error": "Job ID not found"}), 404)
 
 @app.route('/results/<job_id>/<path:filename>')
 def download_file(job_id, filename):
     try:
         try:
-            uuid.UUID(job_id, version=4) # Validate UUID format
+            uuid.UUID(job_id, version=4)
         except ValueError:
             return jsonify({"error": "Invalid job ID format"}), 400
 
         if '..' in filename or filename.startswith('/'):
             return jsonify({"error": "Invalid filename"}), 400
 
-        # Construct the absolute path to the file within the specific job's output directory
         safe_filename = secure_filename(filename)
-        try:
-            uuid.UUID(job_id, version=4)
-        except ValueError:
-            print(f"Invalid job ID format requested: {job_id}")
-            return jsonify({"error": "Invalid job ID"}), 400
-
         file_dir = Path(app.config['RESULT_FOLDER']) / job_id
-
-        # Prevent path traversal
         file_path = (file_dir / safe_filename).resolve()
-        if not str(file_path).startswith(str(file_dir.resolve())):
-             print(f"Attempted path traversal: {job_id}/{filename}")
-             return jsonify({"error": "Invalid file path"}), 400
 
-        print(f"Serving file: {file_path}")
+        if not str(file_path).startswith(str(file_dir.resolve())):
+            print(f"Attempted path traversal: {job_id}/{filename}")
+            return jsonify({"error": "Invalid file path"}), 400
 
         if not file_path.is_file():
-            print(f"File not found: {file_path}")
             if not file_dir.exists():
-                print(f"Job directory not found: {file_dir}")
                 return jsonify({"error": f"Job directory {job_id} not found"}), 404
             files_in_dir = list(file_dir.iterdir())
-            print(f"Files in job directory {file_dir}: {files_in_dir}")
             return jsonify({"error": f"File '{filename}' not found in job '{job_id}'. Available: {[f.name for f in files_in_dir]}"}), 404
 
-        # Handle TIF/TIFF files by converting to PNG
         if filename.lower().endswith(('.tif', '.tiff')):
             try:
-                # Open the TIF image
                 with Image.open(file_path) as img:
-                    # Convert to RGB if necessary
-                    if img.mode in ('RGBA', 'LA') or (img.mode == 'P' and 'transparency' in img.info):
-                        img = img.convert('RGBA')
-                    else:
-                        img = img.convert('RGB')
-                    
-                    # Create a BytesIO object to hold the PNG data
+                    img = img.convert('RGBA') if img.mode in ('RGBA', 'LA') or (img.mode == 'P' and 'transparency' in img.info) else img.convert('RGB')
                     img_byte_arr = io.BytesIO()
-                    # Save as PNG to the BytesIO object
                     img.save(img_byte_arr, format='PNG')
-                    # Seek to the beginning of the BytesIO object
                     img_byte_arr.seek(0)
-                    
-                    # Return the PNG image
                     return send_file(
                         img_byte_arr,
                         mimetype='image/png',
@@ -220,67 +169,47 @@ def download_file(job_id, filename):
                 print(f"Error converting TIF to PNG: {e}")
                 return jsonify({"error": "Could not convert TIF image"}), 500
 
-        # For non-TIF files, serve as normal
         mime_type = None
         if safe_filename.lower().endswith(('.png', '.jpg', '.jpeg')):
             try:
                 with Image.open(file_path) as img:
-                    format = img.format
-                    if format == 'JPEG': mime_type = 'image/jpeg'
-                    elif format == 'PNG': mime_type = 'image/png'
-                print(f"Detected MIME type: {mime_type} for {safe_filename}")
+                    mime_type = 'image/jpeg' if img.format == 'JPEG' else 'image/png'
             except Exception as img_err:
-                print(f"Could not determine MIME type for {safe_filename} using PIL: {img_err}")
-                pass
+                print(f"Could not determine MIME type for {safe_filename}: {img_err}")
 
         if safe_filename.lower() == "results.csv":
             mime_type = 'text/csv'
 
-        try:
-            return send_file(str(file_path), mimetype=mime_type)
-        except Exception as send_err:
-            print(f"Error sending file {file_path}: {send_err}")
-            return jsonify({"error": "Could not send file"}), 500
+        return send_file(str(file_path), mimetype=mime_type)
     except Exception as e:
         error_message = f"File serving error: {str(e)}"
         print(error_message)
         return jsonify({"error": "Server error", "log": error_message}), 500
 
-
 @app.route('/export_images/<job_id>')
 def export_images(job_id):
     try:
         try:
-            uuid.UUID(job_id, version=4) # Validate UUID format
+            uuid.UUID(job_id, version=4)
         except ValueError:
             return jsonify({"error": "Invalid job ID format"}), 400
 
-        # Get the job directory
         job_dir = Path(app.config['RESULT_FOLDER']) / job_id
         if not job_dir.exists():
             return jsonify({"error": f"Job directory {job_id} not found"}), 404
 
-        # Find all annotated images
         annotated_files = list(job_dir.glob('*_annotated.*'))
         if not annotated_files:
             return jsonify({"error": "No annotated images found"}), 404
 
-        # Create a BytesIO object to store the ZIP file
         memory_file = io.BytesIO()
-        
-        # Create the ZIP file
         with zipfile.ZipFile(memory_file, 'w', zipfile.ZIP_DEFLATED) as zf:
             for file_path in annotated_files:
-                # Add file to the ZIP with just its name as the archive path
                 zf.write(file_path, file_path.name)
         
-        # Seek to the beginning of the BytesIO object
         memory_file.seek(0)
-        
-        # Generate timestamp for the filename
         timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
         
-        # Send the ZIP file with timestamp in name
         return send_file(
             memory_file,
             mimetype='application/zip',
@@ -293,95 +222,76 @@ def export_images(job_id):
         print(error_message)
         return jsonify({"error": "Server error", "log": error_message}), 500
 
-
-# --- Helper function to run NemaQuant in background ---
 def run_nemaquant_background(job_id, cmd, job_output_dir, output_csv, input_mode):
     global job_status
     try:
         print(f"[{job_id}] Starting NemaQuant process...")
-        job_status[job_id] = {"status": "running", "progress": 5, "log": "Starting NemaQuant...", "results": None, "error": None}
+        job_status[job_id] = {
+            "status": "running",
+            "progress": 5,
+            "log": "Starting NemaQuant...",
+            "results": None,
+            "error": None
+        }
 
-        # Use Popen for non-blocking execution
         process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1, universal_newlines=True)
 
-        # --- Monitor stdout for progress (Example: simple line counting) ---
         stdout_log = []
         stderr_log = []
-        total_lines_estimate = 50 # Heuristic: estimate total lines for progress
+        total_lines_estimate = 50
         lines_processed = 0
-        last_reported_progress = 5 # Start after initial 5%
+        last_reported_progress = 5
 
-        # Monitor stdout
         if process.stdout:
             for line in iter(process.stdout.readline, ''):
                 line_strip = line.strip()
                 lines_processed += 1
                 stdout_log.append(line_strip)
-                print(f"[{job_id}] STDOUT: {line_strip}") # Log in real-time
+                print(f"[{job_id}] STDOUT: {line_strip}")
 
-                # Check for PROGRESS marker
                 if line_strip.startswith("PROGRESS:"):
                     try:
                         progress_val = int(line_strip.split(":")[1].strip())
-                        # Ensure progress only increases and stays within bounds (5-95)
                         last_reported_progress = max(last_reported_progress, min(progress_val, 95))
                         job_status[job_id]["progress"] = last_reported_progress
-                        print(f"[{job_id}] Parsed progress: {last_reported_progress}%")
                     except (IndexError, ValueError):
-                        print(f"[{job_id}] Warning: Could not parse progress line: {line_strip}")
-                        # Fallback to line counting if parsing fails
                         progress_percent = min(90, 5 + int((lines_processed / total_lines_estimate) * 85))
                         job_status[job_id]["progress"] = max(last_reported_progress, progress_percent)
                         last_reported_progress = job_status[job_id]["progress"]
                 else:
-                    # Fallback: Update progress based on line count if no marker
                     progress_percent = min(90, 5 + int((lines_processed / total_lines_estimate) * 85))
                     job_status[job_id]["progress"] = max(last_reported_progress, progress_percent)
                     last_reported_progress = job_status[job_id]["progress"]
 
-                # Update log snippet (always)
-                job_status[job_id]["log"] = "\n".join(stdout_log[-5:]) # Keep last 5 lines for status
+                job_status[job_id]["log"] = "\n".join(stdout_log[-5:])
 
-        # Monitor stderr
         if process.stderr:
-             for line in iter(process.stderr.readline, ''):
-                 stderr_log.append(line.strip())
-                 print(f"[{job_id}] STDERR: {line.strip()}") # Log errors in real-time
+            for line in iter(process.stderr.readline, ''):
+                stderr_log.append(line.strip())
+                print(f"[{job_id}] STDERR: {line.strip()}")
 
         process.stdout.close()
         if process.stderr:
             process.stderr.close()
         return_code = process.wait()
 
-        # Join logs first to avoid f-string syntax error
         stdout_str = "\n".join(stdout_log)
         stderr_str = "\n".join(stderr_log)
         full_log = f"NemaQuant Output:\n{stdout_str}\nNemaQuant Errors:\n{stderr_str}"
-        job_status[job_id]["log"] = full_log # Store full log at the end
-
-        print(f"[{job_id}] NemaQuant script return code: {return_code}")
+        job_status[job_id]["log"] = full_log
 
         if return_code != 0:
-             raise subprocess.CalledProcessError(return_code, cmd, output=stdout_str, stderr=stderr_str)
+            raise subprocess.CalledProcessError(return_code, cmd, output=stdout_str, stderr=stderr_str)
 
-        job_status[job_id]["progress"] = 95 # Mark as almost done before parsing results
+        job_status[job_id]["progress"] = 95
 
-        # --- Check for and Parse Results ---
-        print(f"[{job_id}] Checking output directory: {job_output_dir}")
-        if os.path.exists(job_output_dir):
-            print(f"[{job_id}] Output directory contents: {os.listdir(job_output_dir)}")
-        print(f"[{job_id}] Checking for output CSV: {output_csv}")
-
-        # Simplified fallback check
         if not output_csv.exists():
-             csv_files = list(job_output_dir.glob('*.csv'))
-             if csv_files:
-                 print(f"[{job_id}] Original CSV not found, using alternate: {csv_files[0]}")
-                 output_csv = csv_files[0]
-             else:
-                 raise FileNotFoundError(f"Output CSV not found at {output_csv} and no alternatives found.")
-
-        # --- Parse Results ---
+            csv_files = list(job_output_dir.glob('*.csv'))
+            if csv_files:
+                output_csv = csv_files[0]
+            else:
+                raise FileNotFoundError(f"Output CSV not found at {output_csv} and no alternatives found.")
+
         df = pd.read_csv(output_csv)
         results_list = []
         
@@ -412,89 +322,64 @@ def run_nemaquant_background(job_id, cmd, job_output_dir, output_csv, input_mode
             "results": results_list,
             "error": None
         }
-        print(f"[{job_id}] Processing successful.")
 
     except subprocess.CalledProcessError as e:
-        # Construct error message carefully, avoiding f-string backslash issue again
         stdout_err = e.output if e.output else ""
         stderr_err = e.stderr if e.stderr else ""
         error_message = f"Error running NemaQuant:\nExit Code: {e.returncode}\nSTDOUT:\n{stdout_err}\nSTDERR:\n{stderr_err}"
-        print(f"[{job_id}] {error_message}")
-        # Ensure log is updated even on error, using the potentially partial log from job_status
-        current_log = job_status[job_id].get("log", "") # Get log captured so far
+        current_log = job_status[job_id].get("log", "")
         job_status[job_id] = {"status": "error", "progress": 100, "log": current_log, "results": None, "error": error_message}
     except FileNotFoundError as e:
         error_message = f"Error processing results: {e}"
-        print(f"[{job_id}] {error_message}")
         job_status[job_id] = {"status": "error", "progress": 100, "log": job_status[job_id].get("log", ""), "results": None, "error": error_message}
-    except Exception as e: # Catch any other unexpected errors
+    except Exception as e:
         error_message = f"An unexpected error occurred: {str(e)}\\n{traceback.format_exc()}"
-        print(f"[{job_id}] {error_message}")
         job_status[job_id] = {"status": "error", "progress": 100, "log": job_status[job_id].get("log", ""), "results": None, "error": error_message}
 
-
-# --- Add startup diagnostics ---
 def print_startup_info():
     print("----- NemaQuant Flask App Starting -----")
     print(f"Working directory: {os.getcwd()}")
-    # Fix: Perform replace before the f-string
     python_version_single_line = sys.version.replace('\n', ' ')
     print(f"Python version: {python_version_single_line}")
     print(f"Weights file: {WEIGHTS_FILE}")
     print(f"Weights file exists: {WEIGHTS_FILE.exists()}")
+    
     if WEIGHTS_FILE.exists():
         try:
             print(f"Weights file size: {WEIGHTS_FILE.stat().st_size} bytes")
         except Exception as e:
             print(f"Could not get weights file size: {e}")
-    else:
-         print("Weights file size: N/A")
 
-    # Check if running inside a container (basic check)
     is_container = os.path.exists('/.dockerenv') or 'DOCKER_HOST' in os.environ
     print(f"Running in container: {is_container}")
+    
     if is_container:
-        print("Container environment detected:")
         try:
             user_info = f"{os.getuid()}:{os.getgid()}"
             print(f"User running process: {user_info}")
-        except AttributeError: # os.getuid/gid not available on Windows
+        except AttributeError:
             print("User running process: UID/GID not available on this OS")
         
-        # Check permissions (use absolute paths inside container context)
-        container_upload_path = "/app/uploads"
-        container_results_path = "/app/results"
-        for path_str in [container_upload_path, container_results_path]:
+        for path_str in ["/app/uploads", "/app/results"]:
             path_obj = Path(path_str)
             if path_obj.exists():
-                 stat_info = path_obj.stat()
-                 permissions = oct(stat_info.st_mode)[-3:]
-                 owner = f"{stat_info.st_uid}:{stat_info.st_gid}"
-                 print(f"Permissions for {path_str}: {permissions}")
-                 print(f"Owner for {path_str}: {owner}")
+                stat_info = path_obj.stat()
+                permissions = oct(stat_info.st_mode)[-3:]
+                owner = f"{stat_info.st_uid}:{stat_info.st_gid}"
+                print(f"Permissions for {path_str}: {permissions}")
+                print(f"Owner for {path_str}: {owner}")
             else:
-                 print(f"Directory {path_str} does not exist.")
+                print(f"Directory {path_str} does not exist.")
 
-    print("---------------------------------------")
-    # Check NemaQuant script details
     nemaquant_script = APP_ROOT / 'nemaquant.py'
     print(f"NemaQuant script exists: {nemaquant_script.exists()}")
     if nemaquant_script.exists():
-         try:
+        try:
             permissions = oct(nemaquant_script.stat().st_mode)[-3:]
             print(f"NemaQuant script permissions: {permissions}")
-            # Check if executable
-            # is_executable = os.access(str(nemaquant_script), os.X_OK)
-            # print(f"NemaQuant script is executable: {is_executable}") # This might be unreliable depending on FS/user
-         except Exception as e:
+        except Exception as e:
             print(f"Could not get NemaQuant script details: {e}")
 
-    print("---------------------------------------")
-
-
 if __name__ == '__main__':
-    print_startup_info() # Print info before starting server
-    # Use 0.0.0.0 to be accessible within Docker network
-    # Use a port other than 5000 if needed, e.g., 7860 for HF Spaces compatibility
-    # Turn off debug mode for production or use a WSGI server like gunicorn
-    app.run(host='0.0.0.0', port=7860, debug=True) # Keep debug for now 
+    print_startup_info()
+    app.run(host='0.0.0.0', port=7860, debug=True) 

static/script.js

@@ -74,16 +74,9 @@ document.addEventListener('DOMContentLoaded', () => {
 
     // File Upload Handling
     function handleFiles(files) {
-        // Log the selected files
-        // logStatus(`Selected ${files.length} file(s):`);
-        // Array.from(files).forEach(file => {
-        //     logStatus(`- ${file.name} (${formatFileSize(file.size)})`);
-        // });
         const allowedTypes = ['image/png', 'image/jpeg', 'image/jpg', 'image/tiff', 'image/tif'];
         const validFiles = Array.from(files).filter(file => {
-            // For folder mode, check if file is in a subdirectory
             if (inputMode.value === 'folder') {
-                // Only include files with valid types and exclude any hidden files
                 return allowedTypes.includes(file.type) && 
                        file.webkitRelativePath && 
                        !file.webkitRelativePath.startsWith('.');
@@ -94,7 +87,6 @@ document.addEventListener('DOMContentLoaded', () => {
 
         if (invalidFiles.length > 0) {
             logStatus(`Warning: Skipped ${invalidFiles.length} invalid files. Only PNG, JPG, and TIFF are supported.`);
-            // Log each invalid file
             invalidFiles.forEach(file => {
                 logStatus(`- Skipped: ${file.name} (invalid type: ${file.type || 'unknown'})`);
             });
@@ -159,8 +151,7 @@ document.addEventListener('DOMContentLoaded', () => {
 
     dropZone.addEventListener('drop', (e) => {
         const dt = e.dataTransfer;
-        const files = dt.files;
-        handleFiles(files);
+        handleFiles(dt.files);
     });
 
     // Click to upload

static/style.css

@@ -1,7 +1,7 @@
 /* Modern, consistent styling for NemaQuant */
 
 :root {
-    --primary-color: #2563eb; /* Modern blue */
+    --primary-color: #2563eb;
     --primary-hover: #1d4ed8;
     --secondary-color: #64748b;
     --secondary-hover: #475569;