Update app.py

app.py

@@ -1,267 +1,220 @@
-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
-
-import torch
-
-
-# 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
-    )
+import gradio as gr
+import os
+import json
+import time
+import threading
+from datetime import datetime
+
+# Import from vision_analyzer (previously cursor_tracker)
+from vision_analyzer import (
+    main_processing_loop,
+    processing_status,
+    ANALYSIS_OUTPUT_FOLDER,
+    log_message
+)
+
+# Global variable to track if processing is running
+processing_thread = None
+
+def start_processing_gradio(start_index: int = 0):
+    global processing_thread
+    
+    if processing_thread and processing_thread.is_alive():
+        return "Processing is already running"
+    
+    if processing_status["is_running"]:
+        return "Processing is 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 f"Processing started in background from index {start_index}"
+
+def stop_processing_gradio():
+    global processing_thread
+    
+    if not processing_status["is_running"] and (not processing_thread or not processing_thread.is_alive()):
+        return "No processing is currently running"
+    
+    # Note: This is a graceful stop request
+    processing_status["is_running"] = False
+    
+    return "Stop signal sent to processing pipeline"
+
+def get_status_gradio():
+    return {
+        "processing_status": processing_status,
+        "analysis_folder": ANALYSIS_OUTPUT_FOLDER,
+        "folder_exists": os.path.exists(ANALYSIS_OUTPUT_FOLDER)
+    }
+
+def list_analysis_data_gradio():
+    if not os.path.exists(ANALYSIS_OUTPUT_FOLDER):
+        return "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),
+            })
+    
+    return json.dumps({
+        "files": json_files,
+        "total_files": len(json_files),
+        "folder_path": ANALYSIS_OUTPUT_FOLDER
+    }, indent=2)
+
+def get_analysis_data_gradio(filename: str):
+    if not filename.endswith(".json"):
+        return "File must be a JSON file"
+    
+    file_path = os.path.join(ANALYSIS_OUTPUT_FOLDER, filename)
+    
+    if not os.path.exists(file_path):
+        return 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 json.dumps(response_data, indent=2)
+        
+    except json.JSONDecodeError:
+        return f"Invalid JSON in file {filename}"
+    except Exception as e:
+        return f"Error reading file {filename}: {str(e)}"
+
+def get_full_analysis_data_gradio(filename: str):
+    if not filename.endswith(".json"):
+        return "File must be a JSON file"
+    
+    file_path = os.path.join(ANALYSIS_OUTPUT_FOLDER, filename)
+    
+    if not os.path.exists(file_path):
+        return 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 json.dumps(data, indent=2)
+        
+    except json.JSONDecodeError:
+        return f"Invalid JSON in file {filename}"
+    except Exception as e:
+        return f"Error reading file {filename}: {str(e)}"
+
+def get_analysis_summary_gradio(filename: str):
+    if not filename.endswith(".json"):
+        return "File must be a JSON file"
+    
+    file_path = os.path.join(ANALYSIS_OUTPUT_FOLDER, filename)
+    
+    if not os.path.exists(file_path):
+        return 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 json.dumps({
+            "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", "")
+        }, indent=2)
+        
+    except json.JSONDecodeError:
+        return f"Invalid JSON in file {filename}"
+    except Exception as e:
+        return f"Error reading file {filename}: {str(e)}"
+
+# Ensure the analysis output folder exists
+os.makedirs(ANALYSIS_OUTPUT_FOLDER, exist_ok=True)
+
+# Gradio Interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Video Analysis Interface")
+    
+    with gr.Tab("Processing Control"):
+        gr.Markdown("## Start/Stop Video Processing")
+        start_index_input = gr.Number(label="Start Index", value=0, precision=0)
+        start_btn = gr.Button("Start Processing")
+        stop_btn = gr.Button("Stop Processing")
+        processing_output = gr.Textbox(label="Processing Status")
+        
+        start_btn.click(start_processing_gradio, inputs=start_index_input, outputs=processing_output)
+        stop_btn.click(stop_processing_gradio, outputs=processing_output)
+
+    with gr.Tab("Analysis Data"):
+        gr.Markdown("## View Analysis Data")
+        list_data_btn = gr.Button("List All Analysis Files")
+        list_data_output = gr.JSON(label="Available Analysis Files")
+        
+        list_data_btn.click(list_analysis_data_gradio, outputs=list_data_output)
+        
+        gr.Markdown("### Get Specific Analysis Data")
+        filename_input = gr.Textbox(label="Filename (e.g., video_analysis.json)")
+        get_data_btn = gr.Button("Get Analysis Data (Summary)")
+        get_full_data_btn = gr.Button("Get Full Analysis Data")
+        get_summary_btn = gr.Button("Get Analysis Summary")
+        specific_data_output = gr.JSON(label="Analysis Data")
+        
+        get_data_btn.click(get_analysis_data_gradio, inputs=filename_input, outputs=specific_data_output)
+        get_full_data_btn.click(get_full_analysis_data_gradio, inputs=filename_input, outputs=specific_data_output)
+        get_summary_btn.click(get_analysis_summary_gradio, inputs=filename_input, outputs=specific_data_output)
+
+    with gr.Tab("Current Status"):
+        gr.Markdown("## Current Processing Status")
+        status_btn = gr.Button("Refresh Status")
+        status_output = gr.JSON(label="Current Status")
+        
+        status_btn.click(get_status_gradio, outputs=status_output)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)