Retrying gitignore update, 3rd attempt

.gitignore

@@ -1,4 +1,5 @@
 .DS_Store
 weights.pt
 weights_nemaquant.v1.onnx
-results/ 
+results/ 
+*.pyc

app.py

@@ -19,6 +19,9 @@ import zipfile
 import cv2
 import csv
 import numpy as np
+import redis
+import json
+import shutil
 
 from yolo_utils import load_model, detect_image
 
@@ -35,7 +38,8 @@ 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)
 
-job_status = {}
+# Redis client (localhost:6379, db=0, no password)
+redis_client = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)
 
 @app.errorhandler(Exception)
 def handle_exception(e):
@@ -58,40 +62,65 @@ def get_model():
         _model = load_model(WEIGHTS_FILE)
     return _model
 
+def cleanup_job(job_id):
+    # Remove files
+    upload_dir = os.path.join(app.config['UPLOAD_FOLDER'], job_id)
+    if os.path.exists(upload_dir):
+        shutil.rmtree(upload_dir)
+    # Remove Redis state
+    redis_client.delete(f"job:{job_id}")
+
+@app.route('/cleanup/<job_id>', methods=['POST'])
+def cleanup_job_endpoint(job_id):
+    cleanup_job(job_id)
+    return jsonify({'status': 'cleaned'})
+
+def get_job_state(job_id):
+    data = redis_client.get(f"job:{job_id}")
+    return json.loads(data) if data else None
+
+def set_job_state(job_id, state):
+    redis_client.set(f"job:{job_id}", json.dumps(state))
+
 all_detections = {}
 
 def process_image(args):
-    filename, image_bytes = args
+    orig_name, unique_name, image_bytes = args
     model = get_model()
     detections = detect_image(model, image_bytes, conf=0.05)
-    # Do NOT update all_detections here (worker process)
-    # Save original image to uploads for later annotation
-    img_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-    with open(img_path, 'wb') as f:
-        f.write(image_bytes)
-    return {'filename': filename, 'detections': detections}
+    # Save original image to uploads for later annotation (already saved)
+    return {'orig_name': orig_name, 'unique_name': unique_name, 'detections': detections}
 
 def async_process_images(job_id, file_data):
     try:
-        job_status[job_id] = {'status': 'running', 'progress': 0, 'results': []}
+        job_state = get_job_state(job_id)
+        job_state['status'] = 'running'
+        job_state['progress'] = 0
+        set_job_state(job_id, job_state)
         total = len(file_data)
         results = []
+        detections = {}
         with Pool(processes=min(cpu_count(), total)) as pool:
             for idx, result in enumerate(pool.imap(process_image, file_data)):
-                results.append(result)
-                # Update progress (0-100)
-                job_status[job_id]['progress'] = int((idx + 1) / total * 100)
-        # Aggregate results
-        for result in results:
-            all_detections[result['filename']] = result['detections']
-        # Add num_eggs to each result for frontend compatibility
-        for result in results:
-            result['num_eggs'] = sum(1 for d in result['detections'] if d.get('class') == 'egg')
-        job_status[job_id]['status'] = 'success'
-        job_status[job_id]['results'] = results
-        job_status[job_id]['progress'] = 100
+                results.append({
+                    'filename': result['orig_name'],
+                    'num_eggs': sum(1 for d in result['detections'] if d.get('class') == 'egg'),
+                })
+                detections[result['orig_name']] = result['detections']
+                # Update progress
+                job_state['progress'] = int((idx + 1) / total * 100)
+                set_job_state(job_id, job_state)
+        job_state['status'] = 'success'
+        job_state['results'] = results
+        job_state['detections'] = detections
+        job_state['progress'] = 100
+        set_job_state(job_id, job_state)
     except Exception as e:
-        job_status[job_id] = {'status': 'error', 'error': str(e), 'progress': 100}
+        job_state = get_job_state(job_id) or {}
+        job_state['status'] = 'error'
+        job_state['error'] = str(e)
+        job_state['progress'] = 100
+        set_job_state(job_id, job_state)
 
 @app.route('/process', methods=['POST'])
 def process_images():
@@ -99,10 +128,19 @@ def process_images():
         files = request.files.getlist('files')
         if not files or files[0].filename == '':
             return jsonify({'error': 'No files uploaded'}), 400
-
-        file_data = [(secure_filename(f.filename), f.read()) for f in files]
         job_id = str(uuid.uuid4())
-        job_status[job_id] = {'status': 'starting', 'progress': 0}
+        # Clean up any previous state for this job
+        cleanup_job(job_id)
+        filename_map, file_data = save_uploaded_files(files, job_id)
+        # Store initial job state in Redis
+        job_state = {
+            'status': 'starting',
+            'progress': 0,
+            'results': [],
+            'filename_map': filename_map,
+            'detections': {},
+        }
+        set_job_state(job_id, job_state)
         thread = Thread(target=async_process_images, args=(job_id, file_data))
         thread.daemon = True
         thread.start()
@@ -112,33 +150,33 @@ def process_images():
         print(traceback.format_exc())
         return jsonify({'error': str(e)}), 500
 
-@app.route('/annotate', methods=['POST'])
-def annotate_image():
-    data = request.json
-    filename = secure_filename(data['filename'])
-    threshold = float(data['confidence'])
-    img_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-    img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
-    detections = all_detections.get(filename, [])
-    filtered = [d for d in detections if d['score'] >= threshold]
-    # Draw boxes
-    for det in filtered:
-        x1, y1, x2, y2 = map(int, det['bbox'])
-        cv2.rectangle(img, (x1, y1), (x2, y2), (0,0,255), 3)
-    temp_path = os.path.join(tempfile.gettempdir(), 'annotated.png')
-    cv2.imwrite(temp_path, img)
-    return send_file(temp_path, mimetype='image/png')
+def save_uploaded_files(files, job_id):
+    upload_dir = os.path.join(app.config['UPLOAD_FOLDER'], job_id)
+    if os.path.exists(upload_dir):
+        shutil.rmtree(upload_dir)
+    os.makedirs(upload_dir, exist_ok=True)
+    filename_map = {}
+    file_data = []
+    for f in files:
+        orig_name = secure_filename(f.filename)
+        ext = os.path.splitext(orig_name)[1]
+        unique_name = f"{uuid.uuid4().hex}{ext}"
+        file_path = os.path.join(upload_dir, unique_name)
+        f.save(file_path)
+        filename_map[orig_name] = unique_name
+        with open(file_path, 'rb') as imgf:
+            file_data.append((orig_name, unique_name, imgf.read()))
+    return filename_map, file_data
 
 @app.route('/progress/<job_id>')
 def get_progress(job_id):
-    status = job_status.get(job_id)
-    if not status:
+    job_state = get_job_state(job_id)
+    if not job_state:
         return jsonify({"status": "error", "error": "Job ID not found"}), 404
     # Add a mapping from filename to detections for frontend plotting
-    if 'results' in status:
-        detections_by_filename = {r['filename']: r['detections'] for r in status['results']}
-        status['detections_by_filename'] = detections_by_filename
-    return jsonify(status)
+    if 'detections' in job_state:
+        job_state['detections_by_filename'] = job_state['detections']
+    return jsonify(job_state)
 
 @app.route('/results/<job_id>/<path:filename>')
 def download_file(job_id, filename):
@@ -245,12 +283,15 @@ def export_images(job_id):
 def export_csv():
     try:
         data = request.json
+        job_id = data['jobId']
         threshold = float(data.get('confidence', 0.5))
-        # all_detections: {filename: [detections]}
+        job_state = get_job_state(job_id)
+        if not job_state:
+            return jsonify({'error': 'Job not found'}), 404
         rows = []
-        for filename, detections in all_detections.items():
+        for orig_name, detections in job_state['detections'].items():
             count = sum(1 for d in detections if d['score'] >= threshold)
-            rows.append({'Filename': filename, 'EggsDetected': count})
+            rows.append({'Filename': orig_name, 'EggsDetected': count})
         timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
         output = io.StringIO()
         writer = csv.DictWriter(output, fieldnames=['Filename', 'EggsDetected'])
@@ -273,20 +314,22 @@ def export_csv():
 def export_images_post():
     try:
         data = request.json
+        job_id = data['jobId']
         threshold = float(data.get('confidence', 0.5))
-        # all_detections: {filename: [detections]}
+        job_state = get_job_state(job_id)
+        if not job_state:
+            return jsonify({'error': 'Job not found'}), 404
         memory_file = io.BytesIO()
         with zipfile.ZipFile(memory_file, 'w', zipfile.ZIP_DEFLATED) as zf:
-            for filename, detections in all_detections.items():
-                filtered = [d for d in detections if d['score'] >= threshold]
-                img_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+            for orig_name, detections in job_state['detections'].items():
+                unique_name = job_state['filename_map'][orig_name]
+                img_path = os.path.join(app.config['UPLOAD_FOLDER'], job_id, unique_name)
                 img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
+                filtered = [d for d in detections if d['score'] >= threshold]
                 for det in filtered:
                     x1, y1, x2, y2 = map(int, det['bbox'])
                     cv2.rectangle(img, (x1, y1), (x2, y2), (0,0,255), 3)
-                # Save annotated image to memory
-                is_tiff = filename.lower().endswith(('.tif', '.tiff'))
-                out_name = f"{Path(filename).stem}.png"
+                out_name = f"{Path(orig_name).stem}.png"
                 _, img_bytes = cv2.imencode('.png', img)
                 zf.writestr(out_name, img_bytes.tobytes())
         memory_file.seek(0)