Update app.py

app.py

@@ -1,7 +1,268 @@
 import gradio as gr
+import os
+import json
+import time
+import threading
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, FileResponse
+import uvicorn
+from typing import Dict
+from pathlib import Path
+import subprocess
+from datetime import datetime
 
-def greet(name):
-    return "Hello " + name + "!!"
+import torch
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+
+# Import from vision_analyzer (previously cursor_tracker)
+from vision_analyzer import (
+    main_processing_loop,
+    processing_status,
+    ANALYSIS_OUTPUT_FOLDER,  # Changed from CURSOR_TRACKING_OUTPUT_FOLDER
+    log_message
+)
+
+# FastAPI App Definition
+app = FastAPI(title="Video Analysis API", 
+             description="API to access video frame analysis 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
+
+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"""
+    global processing_thread
+    if not (processing_thread and processing_thread.is_alive()):
+        log_message("🚀 Starting RAR extraction, frame extraction, and vision analysis pipeline in background...")
+        processing_thread = threading.Thread(target=main_processing_loop)
+        processing_thread.daemon = True
+        processing_thread.start()
+
+@app.get("/")
+async def root():
+    """Root endpoint that returns basic info"""
+    return {
+        "message": "Video Analysis API",
+        "status": "running",
+        "endpoints": {
+            "/status": "Get processing status",
+            "/analysis-data": "List available analysis files",
+            "/analysis-data/{filename}": "Get specific analysis data",
+            "/start-processing": "Start processing pipeline",
+            "/stop-processing": "Stop processing pipeline"
+        }
+    }
+
+@app.get("/status")
+async def get_status():
+    """Get current processing status"""
+    return {
+        "processing_status": processing_status,
+        "analysis_folder": ANALYSIS_OUTPUT_FOLDER,
+        "folder_exists": os.path.exists(ANALYSIS_OUTPUT_FOLDER)
+    }
+
+@app.get("/analysis-data")
+async def list_analysis_data():
+    """List all available analysis JSON files"""
+    if not os.path.exists(ANALYSIS_OUTPUT_FOLDER):
+        return {"files": [], "message": "Analysis output folder does not exist yet"}
+    
+    json_files = []
+    for file in os.listdir(ANALYSIS_OUTPUT_FOLDER):
+        if file.endswith(".json"):
+            file_path = os.path.join(ANALYSIS_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"/analysis-data/{file}"
+            })
+    
+    return {
+        "files": json_files,
+        "total_files": len(json_files),
+        "folder_path": ANALYSIS_OUTPUT_FOLDER
+    }
+
+@app.get("/analysis-data/{filename}")
+async def get_analysis_data(filename: str):
+    """Get specific analysis 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(ANALYSIS_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)
+        
+        # Extract summary information
+        frame_analyses = data.get("frame_analyses", [])
+        summary = data.get("summary", {})
+        
+        response_data = {
+            "filename": filename,
+            "file_size_bytes": file_stats.st_size,
+            "modified_time": time.ctime(file_stats.st_mtime),
+            "total_frames": len(frame_analyses),
+            "summary": summary,
+            "frame_samples": frame_analyses[:5]  # Return first 5 frames as samples
+        }
+        
+        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)}")
+
+@app.get("/analysis-data/{filename}/full")
+async def get_full_analysis_data(filename: str):
+    """Get the complete analysis data including all frames"""
+    if not filename.endswith(".json"):
+        raise HTTPException(status_code=400, detail="File must be a JSON file")
+    
+    file_path = os.path.join(ANALYSIS_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)
+        data["metadata"] = {
+            "filename": filename,
+            "file_size_bytes": file_stats.st_size,
+            "modified_time": time.ctime(file_stats.st_mtime)
+        }
+        
+        return 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)}")
+
+@app.post("/start-processing")
+async def start_processing(background_tasks: BackgroundTasks, start_index: int = 0):
+    """Start the 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=main_processing_loop, args=(start_index,))
+    processing_thread.daemon = True
+    processing_thread.start()
+    
+    return {"message": f"Processing started in background from index {start_index}", "status": "started"}
+
+@app.post("/stop-processing")
+async def stop_processing():
+    """Stop the 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
+    processing_status["is_running"] = False
+    
+    return {"message": "Stop signal sent to processing pipeline", "status": "stop_requested"}
+
+@app.get("/analysis-data/{filename}/summary")
+async def get_analysis_summary(filename: str):
+    """Get a summary of the analysis data"""
+    if not filename.endswith(".json"):
+        raise HTTPException(status_code=400, detail="File must be a JSON file")
+    
+    file_path = os.path.join(ANALYSIS_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)
+        
+        # Get basic statistics
+        frame_analyses = data.get("frame_analyses", [])
+        summary = data.get("summary", {})
+        
+        # Count frames with descriptions
+        frames_with_descriptions = len([f for f in frame_analyses if f.get("description")])
+        
+        file_stats = os.stat(file_path)
+        
+        return {
+            "filename": filename,
+            "file_size_bytes": file_stats.st_size,
+            "modified_time": time.ctime(file_stats.st_mtime),
+            "total_frames": len(frame_analyses),
+            "frames_with_descriptions": frames_with_descriptions,
+            "summary": summary,
+            "steps": summary.get("steps", []),
+            "high_level_goal": summary.get("high_level_goal", ""),
+            "final_goal": summary.get("final_goal", "")
+        }
+        
+    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 FastAPI server
+    print("Starting Video Analysis FastAPI Server...")
+    print("API Documentation will be available at: http://localhost:8000/docs")
+    print("API Root endpoint: http://localhost:8000/")
+    
+    # Ensure the analysis output folder exists
+    os.makedirs(ANALYSIS_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
+    )