Update download_api.py

download_api.py

@@ -31,6 +31,18 @@ app.add_middleware(
 # Global variable to track if processing is running
 processing_thread = None
 
+def log_message(message):
+    """Add a log message with timestamp"""
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    log_entry = f"[{timestamp}] {message}"
+    processing_status["logs"].append(log_entry)
+    
+    # Keep only the last 100 logs
+    if len(processing_status["logs"]) > 100:
+        processing_status["logs"] = processing_status["logs"][-100:]
+    
+    print(log_entry)
+
 @app.on_event("startup")
 async def startup_event():
     """Run the processing loop in the background when the API starts"""
@@ -44,17 +56,20 @@ async def startup_event():
 @app.get("/")
 async def root():
     """Root endpoint with API information"""
-    return {
-        "message": "Cursor Tracking API",
-        "version": "1.0.0",
-        "endpoints": {
-            "/status": "Get processing status",
-            "/cursor-data": "List all cursor tracking JSON files",
-            "/cursor-data/{filename}": "Get specific cursor tracking data",
-            "/start-processing": "Start the RAR processing pipeline",
-            "/stop-processing": "Stop the RAR processing pipeline"
-        }
-    }
+    return send_file(os.path.join(BASE_DIR, 'index.html'))
+
+
+@app.route('/<path:filename>')
+def serve_static(filename):
+    """Serve static files (CSS, JS, etc.)"""
+    if filename in ['style.css', 'script.js']:
+        return send_from_directory(BASE_DIR, filename)
+    return send_from_directory(BASE_DIR, filename)
+
+@app.route('/status')
+def get_status():
+    """Get current processing status"""
+    return jsonify({"processing_status": processing_status})
 
 @app.get("/status")
 async def get_status():
@@ -89,6 +104,20 @@ async def list_cursor_data():
         "folder_path": CURSOR_TRACKING_OUTPUT_FOLDER
     }
 
+from fastapi.encoders import jsonable_encoder
+
+class SafeJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        try:
+            if isinstance(obj, float):
+                if obj != obj:  # Check for NaN
+                    return None
+                if obj == float('inf') or obj == float('-inf'):
+                    return None
+            return super().default(obj)
+        except:
+            return None
+
 @app.get("/cursor-data/{filename}")
 async def get_cursor_data(filename: str):
     """Get specific cursor tracking data by filename"""
@@ -104,18 +133,34 @@ async def get_cursor_data(filename: str):
         with open(file_path, "r") as f:
             data = json.load(f)
         
+        # Clean the data of any NaN or infinity values
+        def clean_floats(obj):
+            if isinstance(obj, float):
+                if obj != obj:  # NaN
+                    return None
+                if obj == float('inf') or obj == float('-inf'):
+                    return None
+                return obj
+            elif isinstance(obj, dict):
+                return {k: clean_floats(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [clean_floats(v) for v in obj]
+            return obj
+        
+        cleaned_data = clean_floats(data)
+        
         # Add metadata
         file_stats = os.stat(file_path)
         response_data = {
             "filename": filename,
             "file_size_bytes": file_stats.st_size,
             "modified_time": time.ctime(file_stats.st_mtime),
-            "total_frames": len(data),
-            "cursor_active_frames": len([frame for frame in data if frame.get("cursor_active", False)]),
-            "data": data
+            "total_frames": len(cleaned_data),
+            "cursor_active_frames": len([frame for frame in cleaned_data if frame.get("cursor_active", False)]),
+            "data": cleaned_data
         }
         
-        return response_data
+        return JSONResponse(content=jsonable_encoder(response_data))
         
     except json.JSONDecodeError:
         raise HTTPException(status_code=500, detail=f"Invalid JSON in file {filename}")
@@ -123,7 +168,7 @@ async def get_cursor_data(filename: str):
         raise HTTPException(status_code=500, detail=f"Error reading file {filename}: {str(e)}")
 
 @app.post("/start-processing")
-async def start_processing(background_tasks: BackgroundTasks):
+async def start_processing(background_tasks: BackgroundTasks, start_index: int = 0):
     """Start the RAR processing pipeline in the background"""
     global processing_thread
     
@@ -134,11 +179,11 @@ async def start_processing(background_tasks: BackgroundTasks):
         return {"message": "Processing is already running", "status": "already_running"}
     
     # Start processing in a background thread
-    processing_thread = threading.Thread(target=main_processing_loop)
+    processing_thread = threading.Thread(target=main_processing_loop, args=(start_index,))
     processing_thread.daemon = True
     processing_thread.start()
     
-    return {"message": "Processing started in background", "status": "started"}
+    return {"message": f"Processing started in background from index {start_index}", "status": "started"}
 
 @app.post("/stop-processing")
 async def stop_processing():
@@ -169,20 +214,42 @@ async def get_cursor_data_summary(filename: str):
         with open(file_path, "r") as f:
             data = json.load(f)
         
+        # Clean the data first
+        def clean_floats(obj):
+            if isinstance(obj, float):
+                if obj != obj:  # NaN
+                    return None
+                if obj == float('inf') or obj == float('-inf'):
+                    return None
+                return obj
+            elif isinstance(obj, dict):
+                return {k: clean_floats(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [clean_floats(v) for v in obj]
+            return obj
+        
+        cleaned_data = clean_floats(data)
+        
         # Calculate summary statistics
-        total_frames = len(data)
-        cursor_active_frames = len([frame for frame in data if frame.get("cursor_active", False)])
+        total_frames = len(cleaned_data)
+        cursor_active_frames = len([frame for frame in cleaned_data if frame.get("cursor_active", False)])
         cursor_inactive_frames = total_frames - cursor_active_frames
         
         # Get unique templates used
         templates_used = set()
         confidence_scores = []
         
-        for frame in data:
+        for frame in cleaned_data:
             if frame.get("cursor_active", False) and frame.get("template"):
                 templates_used.add(frame["template"])
                 if frame.get("confidence") is not None:
-                    confidence_scores.append(frame["confidence"])
+                    # Ensure confidence is a valid number
+                    try:
+                        conf = float(frame["confidence"])
+                        if not (conf != conf or conf == float('inf') or conf == float('-inf')):
+                            confidence_scores.append(conf)
+                    except (ValueError, TypeError):
+                        pass
         
         # Calculate confidence statistics
         avg_confidence = sum(confidence_scores) / len(confidence_scores) if confidence_scores else 0
@@ -208,7 +275,7 @@ async def get_cursor_data_summary(filename: str):
             }
         }
         
-        return summary
+        return JSONResponse(content=jsonable_encoder(summary))
         
     except json.JSONDecodeError:
         raise HTTPException(status_code=500, detail=f"Invalid JSON in file {filename}")
@@ -233,4 +300,3 @@ if __name__ == "__main__":
     )
 
 
-