Update main.py

main.py

@@ -15,11 +15,6 @@ from pathlib import Path
 import smtplib
 from email.message import EmailMessage
 
-from fastapi import FastAPI, HTTPException, BackgroundTasks
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-import uvicorn
-
 # ==== CONFIGURATION ====
 HF_TOKEN = os.getenv("HF_TOKEN", "")
 SOURCE_REPO_ID = os.getenv("SOURCE_REPO", "Fred808/BG1")
@@ -85,7 +80,7 @@ def log_message(message: str):
 def log_failed_file(filename: str, error: str):
     """Log failed files to persistent file"""
     with open(FAILED_FILES_LOG, "a") as f:
-        f.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} - {filename}: {error}\n")
+        f.write(f"{time.strftime("%Y-%m-%d %H:%M:%S")} - {filename}: {error}\n")
 
 def get_disk_usage(path: str) -> Dict[str, float]:
     """Get disk usage statistics in GB"""
@@ -194,7 +189,7 @@ def extract_with_retry(rar_path: str, output_dir: str, max_retries: int = 2) ->
         rar_path = first_part_path
         log_message(f"📦 Processing multi-part RAR starting with: {first_part}")
     
-    for attempt in range(max_retries):
+    for attempt in max_retries:
         try:
             # Test RAR first
             test_cmd = ["unrar", "t", rar_path]
@@ -584,226 +579,19 @@ def main_processing_loop():
         processing_status["is_running"] = False
         cleanup_temp_files()
 
+# Expose necessary functions and variables for download_api.py
+__all__ = [
+    "main_processing_loop",
+    "processing_status",
+    "CURSOR_TRACKING_OUTPUT_FOLDER",
+    "CURSOR_TEMPLATES_DIR",
+    "log_message",
+    "send_email_with_attachment",
+    "track_cursor",
+    "extract_frames",
+    "DEFAULT_FPS",
+    "CURSOR_THRESHOLD",
+    "ensure_dir"
+]
 
-# FastAPI App Definition
-app = FastAPI(title="Cursor Tracking API", description="API to access cursor tracking results", version="1.0.0")
-
-# Add CORS middleware to allow cross-origin requests
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Allows all origins
-    allow_credentials=True,
-    allow_methods=["*"],  # Allows all methods
-    allow_headers=["*"],
-)
-
-# Global variable to track if processing is running
-processing_thread = None
-
-@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"
-        }
-    }
-
-@app.get("/status")
-async def get_status():
-    """Get current processing status"""
-    return {
-        "processing_status": processing_status,
-        "cursor_tracking_folder": CURSOR_TRACKING_OUTPUT_FOLDER,
-        "folder_exists": os.path.exists(CURSOR_TRACKING_OUTPUT_FOLDER)
-    }
-
-@app.get("/cursor-data")
-async def list_cursor_data():
-    """List all available cursor tracking JSON files"""
-    if not os.path.exists(CURSOR_TRACKING_OUTPUT_FOLDER):
-        return {"files": [], "message": "Cursor tracking output folder does not exist yet"}
-    
-    json_files = []
-    for file in os.listdir(CURSOR_TRACKING_OUTPUT_FOLDER):
-        if file.endswith(".json"):
-            file_path = os.path.join(CURSOR_TRACKING_OUTPUT_FOLDER, file)
-            file_stats = os.stat(file_path)
-            json_files.append({
-                "filename": file,
-                "size_bytes": file_stats.st_size,
-                "modified_time": time.ctime(file_stats.st_mtime),
-                "download_url": f"/cursor-data/{file}"
-            })
-    
-    return {
-        "files": json_files,
-        "total_files": len(json_files),
-        "folder_path": CURSOR_TRACKING_OUTPUT_FOLDER
-    }
-
-@app.get("/cursor-data/{filename}")
-async def get_cursor_data(filename: str):
-    """Get specific cursor tracking data by filename"""
-    if not filename.endswith(".json"):
-        raise HTTPException(status_code=400, detail="File must be a JSON file")
-    
-    file_path = os.path.join(CURSOR_TRACKING_OUTPUT_FOLDER, filename)
-    
-    if not os.path.exists(file_path):
-        raise HTTPException(status_code=404, detail=f"File {filename} not found")
-    
-    try:
-        with open(file_path, "r") as f:
-            data = json.load(f)
-        
-        # 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
-        }
-        
-        return response_data
-        
-    except json.JSONDecodeError:
-        raise HTTPException(status_code=500, detail=f"Invalid JSON in file {filename}")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error reading file {filename}: {str(e)}")
-
-def run_processing_in_background():
-    """Run the main processing loop in a background thread"""
-    global processing_thread
-    try:
-        main_processing_loop()
-    except Exception as e:
-        print(f"Processing error: {e}")
-    finally:
-        processing_thread = None
-
-@app.post("/start-processing")
-async def start_processing(background_tasks: BackgroundTasks):
-    """Start the RAR processing pipeline in the background"""
-    global processing_thread
-    
-    if processing_thread and processing_thread.is_alive():
-        return {"message": "Processing is already running", "status": "already_running"}
-    
-    if processing_status["is_running"]:
-        return {"message": "Processing is already running", "status": "already_running"}
-    
-    # Start processing in a background thread
-    processing_thread = threading.Thread(target=run_processing_in_background)
-    processing_thread.daemon = True
-    processing_thread.start()
-    
-    return {"message": "Processing started in background", "status": "started"}
-
-@app.post("/stop-processing")
-async def stop_processing():
-    """Stop the RAR processing pipeline"""
-    global processing_thread
-    
-    if not processing_status["is_running"] and (not processing_thread or not processing_thread.is_alive()):
-        return {"message": "No processing is currently running", "status": "not_running"}
-    
-    # Note: This is a graceful stop request. The actual stopping depends on the processing loop
-    # checking the processing_status["is_running"] flag
-    processing_status["is_running"] = False
-    
-    return {"message": "Stop signal sent to processing pipeline", "status": "stop_requested"}
-
-@app.get("/cursor-data/{filename}/summary")
-async def get_cursor_data_summary(filename: str):
-    """Get a summary of cursor tracking data without the full frame data"""
-    if not filename.endswith(".json"):
-        raise HTTPException(status_code=400, detail="File must be a JSON file")
-    
-    file_path = os.path.join(CURSOR_TRACKING_OUTPUT_FOLDER, filename)
-    
-    if not os.path.exists(file_path):
-        raise HTTPException(status_code=404, detail=f"File {filename} not found")
-    
-    try:
-        with open(file_path, "r") as f:
-            data = json.load(f)
-        
-        # Calculate summary statistics
-        total_frames = len(data)
-        cursor_active_frames = len([frame for frame in 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:
-            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"])
-        
-        # Calculate confidence statistics
-        avg_confidence = sum(confidence_scores) / len(confidence_scores) if confidence_scores else 0
-        max_confidence = max(confidence_scores) if confidence_scores else 0
-        min_confidence = min(confidence_scores) if confidence_scores else 0
-        
-        file_stats = os.stat(file_path)
-        
-        summary = {
-            "filename": filename,
-            "file_size_bytes": file_stats.st_size,
-            "modified_time": time.ctime(file_stats.st_mtime),
-            "total_frames": total_frames,
-            "cursor_active_frames": cursor_active_frames,
-            "cursor_inactive_frames": cursor_inactive_frames,
-            "cursor_detection_rate": cursor_active_frames / total_frames if total_frames > 0 else 0,
-            "templates_used": list(templates_used),
-            "confidence_stats": {
-                "average": avg_confidence,
-                "maximum": max_confidence,
-                "minimum": min_confidence,
-                "total_measurements": len(confidence_scores)
-            }
-        }
-        
-        return summary
-        
-    except json.JSONDecodeError:
-        raise HTTPException(status_code=500, detail=f"Invalid JSON in file {filename}")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error reading file {filename}: {str(e)}")
-
-if __name__ == "__main__":
-    # Start the processing in a background thread first
-    log_message("🚀 Starting RAR extraction, frame extraction, and cursor tracking pipeline in background...")
-    processing_thread = threading.Thread(target=main_processing_loop)
-    processing_thread.daemon = True
-    processing_thread.start()
-
-    # Then start the FastAPI server
-    print("Starting Cursor Tracking FastAPI Server...")
-    print("API Documentation will be available at: http://localhost:8000/docs")
-    print("API Root endpoint: http://localhost:8000/")
-    
-    # Ensure the cursor tracking output folder exists
-    os.makedirs(CURSOR_TRACKING_OUTPUT_FOLDER, exist_ok=True)
-    
-    uvicorn.run(
-        app, 
-        host="0.0.0.0", 
-        port=8000, 
-        log_level="info",
-        reload=False  # Set to False for production
-    )