Update app.py

app.py

@@ -1,220 +1,189 @@
-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
+from fastapi.staticfiles import StaticFiles
+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,
-    log_message
+    log_message,
+    FRAMES_OUTPUT_FOLDER  # Add this import for frames directory
+)
+
+# FastAPI App Definition
+app = FastAPI(title="Video Analysis API", 
+             description="API to access video frame analysis results and extracted images", 
+             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 start_processing_gradio(start_index: int = 0):
-    global processing_thread
+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)
     
-    if processing_thread and processing_thread.is_alive():
-        return "Processing is already running"
+    # Keep only the last 100 logs
+    if len(processing_status["logs"]) > 100:
+        processing_status["logs"] = processing_status["logs"][-100:]
     
-    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}"
+    print(log_entry)
 
-def stop_processing_gradio():
+@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_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"
+    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()
 
-def get_status_gradio():
+@app.get("/")
+async def root():
+    """Root endpoint that returns basic info"""
+    return {
+        "message": "Video Analysis API",
+        "status": "running",
+        "endpoints": {
+            "/status": "Get processing status",
+            "/courses": "List all available course folders",
+            "/images/{course_folder}": "List images in a course folder",
+            "/images/{course_folder}/{frame_filename}": "Get specific frame image",
+            "/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)
+        "frames_folder": FRAMES_OUTPUT_FOLDER,
+        "frames_folder_exists": os.path.exists(FRAMES_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)
+# ===== NEW IMAGE SERVING ENDPOINTS =====
+
+@app.get("/images/{course_folder}/{frame_filename}")
+async def get_frame_image(course_folder: str, frame_filename: str):
+    """
+    Serve extracted frame images from course folders
+    
+    Args:
+        course_folder: The course folder name (e.g., "course1_video1_mp4_frames")
+        frame_filename: The frame file name (e.g., "0001.png")
+    """
+    # Construct the full path to the image
+    image_path = os.path.join(FRAMES_OUTPUT_FOLDER, course_folder, frame_filename)
+    
+    # Check if file exists
+    if not os.path.exists(image_path):
+        raise HTTPException(status_code=404, detail=f"Image not found: {course_folder}/{frame_filename}")
+    
+    # Verify it's an image file
+    if not frame_filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+        raise HTTPException(status_code=400, detail="File must be an image (PNG, JPG, JPEG)")
+    
+    # Return the image file
+    return FileResponse(image_path)
+
+@app.get("/images/{course_folder}")
+async def list_course_images(course_folder: str):
+    """
+    List all available images in a specific course folder
+    
+    Args:
+        course_folder: The course folder name
+    """
+    folder_path = os.path.join(FRAMES_OUTPUT_FOLDER, course_folder)
+    
+    if not os.path.exists(folder_path):
+        raise HTTPException(status_code=404, detail=f"Course folder not found: {course_folder}")
+    
+    # Get all image files
+    image_files = []
+    for file in os.listdir(folder_path):
+        if file.lower().endswith(('.png', '.jpg', '.jpeg')):
+            file_path = os.path.join(folder_path, file)
             file_stats = os.stat(file_path)
-            json_files.append({
+            image_files.append({
                 "filename": file,
                 "size_bytes": file_stats.st_size,
                 "modified_time": time.ctime(file_stats.st_mtime),
+                "url": f"/images/{course_folder}/{file}"
             })
     
-    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)
+    return {
+        "course_folder": course_folder,
+        "total_images": len(image_files),
+        "images": image_files
+    }
 
-# Gradio Interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Video Analysis Interface")
+@app.get("/courses")
+async def list_all_courses():
+    """
+    List all available course folders with their image counts
+    """
+    if not os.path.exists(FRAMES_OUTPUT_FOLDER):
+        return {"courses": [], "message": "Frames output folder does not exist yet"}
+    
+    courses = []
+    for folder in os.listdir(FRAMES_OUTPUT_FOLDER):
+        folder_path = os.path.join(FRAMES_OUTPUT_FOLDER, folder)
+        if os.path.isdir(folder_path):
+            # Count image files
+            image_count = len([f for f in os.listdir(folder_path) 
+                             if f.lower().endswith(('.png', '.jpg', '.jpeg'))])
+            courses.append({
+                "course_folder": folder,
+                "image_count": image_count,
+                "images_url": f"/images/{folder}",
+                "sample_image_url": f"/images/{folder}/0001.png" if image_count > 0 else None
+            })
     
-    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)
+    return {
+        "total_courses": len(courses),
+        "courses": courses
+    }
 
-    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)
+    # 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(FRAMES_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
+    )