Upload 26 files

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,10 @@
----
-title: VS3
-emoji: 🚀
-colorFrom: purple
-colorTo: pink
-sdk: gradio
-sdk_version: 5.37.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Vis1
+emoji: 🐨
+colorFrom: pink
+colorTo: pink
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

annotations/readme.md

@@ -0,0 +1 @@
+#Hi there

download_api.py

@@ -0,0 +1,267 @@
+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
+    )

index.html

@@ -0,0 +1,201 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="description" content="Advanced web-based dashboard for monitoring and managing video analysis operations. Real-time processing status, file management, and control interface.">
+    <meta name="keywords" content="video analysis, vision processing, dashboard, monitoring, API interface">
+    <meta name="author" content="Video Analysis Dashboard">
+    <title>Video Analysis Dashboard - Real-time Processing Monitor</title>
+    <link rel="stylesheet" href="/static/style.css">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+</head>
+<body>
+    <div class="container">
+        <!-- Header -->
+        <header class="header">
+            <div class="header-content">
+                <div class="logo">
+                    <i class="fas fa-eye"></i>
+                    <h1>Video Analysis Dashboard</h1>
+                </div>
+                <div class="header-actions">
+                    <button id="refreshBtn" class="btn btn-secondary">
+                        <i class="fas fa-sync-alt"></i>
+                        Refresh
+                    </button>
+                    <div class="theme-toggle">
+                        <button id="themeToggle" class="btn btn-icon">
+                            <i class="fas fa-moon"></i>
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </header>
+
+        <!-- Main Content -->
+        <main class="main-content">
+            <!-- Status Section -->
+            <section class="status-section">
+                <div class="card">
+                    <div class="card-header">
+                        <h2><i class="fas fa-chart-line"></i> Processing Status</h2>
+                        <div class="status-indicator" id="statusIndicator">
+                            <span class="status-dot"></span>
+                            <span class="status-text">Loading...</span>
+                        </div>
+                    </div>
+                    <div class="card-content">
+                        <div class="stats-grid">
+                            <div class="stat-item">
+                                <div class="stat-value" id="totalFiles">-</div>
+                                <div class="stat-label">Total Files</div>
+                            </div>
+                            <div class="stat-item">
+                                <div class="stat-value" id="processedFiles">-</div>
+                                <div class="stat-label">Processed</div>
+                            </div>
+                            <div class="stat-item">
+                                <div class="stat-value" id="extractedCourses">-</div>
+                                <div class="stat-label">Courses</div>
+                            </div>
+                            <div class="stat-item">
+                                <div class="stat-value" id="extractedVideos">-</div>
+                                <div class="stat-label">Videos</div>
+                            </div>
+                            <div class="stat-item">
+                                <div class="stat-value" id="extractedFrames">-</div>
+                                <div class="stat-label">Frames</div>
+                            </div>
+                            <div class="stat-item">
+                                <div class="stat-value" id="analyzedFrames">-</div>
+                                <div class="stat-label">Frames Analyzed</div>
+                            </div>
+                        </div>
+                        
+                        <div class="progress-section">
+                            <div class="progress-info">
+                                <span>Current File:</span>
+                                <span id="currentFile" class="current-file">None</span>
+                            </div>
+                            <div class="progress-bar">
+                                <div class="progress-fill" id="progressFill"></div>
+                            </div>
+                            <div class="progress-text" id="progressText">0%</div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- Control Section -->
+            <section class="control-section">
+                <div class="card">
+                    <div class="card-header">
+                        <h2><i class="fas fa-cogs"></i> Processing Controls</h2>
+                    </div>
+                    <div class="card-content">
+                        <div class="control-group">
+                            <div class="input-group">
+                                <label for="startIndex">Start Index for RAR Fetching:</label>
+                                <input type="number" id="startIndex" min="0" value="0" class="input">
+                                <span class="input-help">Specify which index to start processing from</span>
+                            </div>
+                            <div class="button-group">
+                                <button id="startProcessing" class="btn btn-primary">
+                                    <i class="fas fa-play"></i>
+                                    Start Processing
+                                </button>
+                                <button id="stopProcessing" class="btn btn-danger">
+                                    <i class="fas fa-stop"></i>
+                                    Stop Processing
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- Analysis Data Files Section -->
+            <section class="files-section">
+                <div class="card">
+                    <div class="card-header">
+                        <h2><i class="fas fa-file-alt"></i> Analysis Results</h2>
+                        <div class="file-count" id="fileCount">0 files</div>
+                    </div>
+                    <div class="card-content">
+                        <div class="files-grid" id="filesGrid">
+                            <!-- Files will be populated here -->
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- Logs Section -->
+            <section class="logs-section">
+                <div class="card">
+                    <div class="card-header">
+                        <h2><i class="fas fa-terminal"></i> Processing Logs</h2>
+                        <div class="log-controls">
+                            <button id="clearLogs" class="btn btn-secondary btn-sm">
+                                <i class="fas fa-trash"></i>
+                                Clear
+                            </button>
+                            <button id="autoScroll" class="btn btn-secondary btn-sm active">
+                                <i class="fas fa-arrow-down"></i>
+                                Auto-scroll
+                            </button>
+                        </div>
+                    </div>
+                    <div class="card-content">
+                        <div class="logs-container" id="logsContainer">
+                            <div class="log-entry">
+                                <span class="log-time">[Loading...]</span>
+                                <span class="log-message">Initializing dashboard...</span>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+        </main>
+    </div>
+
+    <!-- File Details Modal -->
+    <div id="fileModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3 id="modalTitle">Analysis Details</h3>
+                <button class="modal-close" id="modalClose">
+                    <i class="fas fa-times"></i>
+                </button>
+            </div>
+            <div class="modal-body" id="modalBody">
+                <!-- Analysis details will be populated here -->
+            </div>
+            <div class="modal-footer">
+                <button id="downloadFile" class="btn btn-primary">
+                    <i class="fas fa-download"></i>
+                    Download JSON
+                </button>
+                <button id="viewSummary" class="btn btn-secondary">
+                    <i class="fas fa-list-alt"></i>
+                    View Summary
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Loading Overlay -->
+    <div id="loadingOverlay" class="loading-overlay">
+        <div class="loading-spinner">
+            <i class="fas fa-spinner fa-spin"></i>
+            <p>Loading...</p>
+        </div>
+    </div>
+
+    <!-- Toast Notifications -->
+    <div id="toastContainer" class="toast-container"></div>
+
+    <script src="/static/script.js"></script>
+</body>
+</html>

requirements.txt

@@ -0,0 +1,14 @@
+
+accelerate
+fastapi
+uvicorn
+opencv-python-headless
+numpy
+pathlib
+huggingface_hub
+pillow
+rarfile
+transformers==4.36.2
+timm==0.9.12
+einops==0.7.0
+python-multipart

static/script.js

@@ -0,0 +1,622 @@
+document.addEventListener('DOMContentLoaded', function() {
+    // Configuration
+    const API_BASE_URL = window.location.origin;
+    const REFRESH_INTERVAL = 10000; // 10 seconds
+    const MAX_LOGS = 100;
+
+    // Global state
+    let refreshInterval;
+    let autoScrollEnabled = true;
+    let currentFiles = [];
+    let selectedFile = null;
+    let apiConnected = false;
+
+    // DOM Elements
+    const elements = {
+        statusIndicator: document.getElementById('statusIndicator'),
+        totalFiles: document.getElementById('totalFiles'),
+        processedFiles: document.getElementById('processedFiles'),
+        extractedCourses: document.getElementById('extractedCourses'),
+        extractedVideos: document.getElementById('extractedVideos'),
+        extractedFrames: document.getElementById('extractedFrames'),
+        analyzedFrames: document.getElementById('analyzedFrames'),
+        currentFile: document.getElementById('currentFile'),
+        progressFill: document.getElementById('progressFill'),
+        progressText: document.getElementById('progressText'),
+        startIndex: document.getElementById('startIndex'),
+        startProcessing: document.getElementById('startProcessing'),
+        stopProcessing: document.getElementById('stopProcessing'),
+        refreshBtn: document.getElementById('refreshBtn'),
+        themeToggle: document.getElementById('themeToggle'),
+        fileCount: document.getElementById('fileCount'),
+        filesGrid: document.getElementById('filesGrid'),
+        logsContainer: document.getElementById('logsContainer'),
+        clearLogs: document.getElementById('clearLogs'),
+        autoScroll: document.getElementById('autoScroll'),
+        fileModal: document.getElementById('fileModal'),
+        modalTitle: document.getElementById('modalTitle'),
+        modalBody: document.getElementById('modalBody'),
+        modalClose: document.getElementById('modalClose'),
+        downloadFile: document.getElementById('downloadFile'),
+        viewSummary: document.getElementById('viewSummary'),
+        loadingOverlay: document.getElementById('loadingOverlay'),
+        toastContainer: document.getElementById('toastContainer')
+    };
+
+    // Initialize the application
+    initializeTheme();
+    setupEventListeners();
+    startAutoRefresh();
+    fetchInitialData();
+
+    // Theme Management
+    function initializeTheme() {
+        const savedTheme = localStorage.getItem('theme') || 'light';
+        document.documentElement.setAttribute('data-theme', savedTheme);
+        updateThemeIcon(savedTheme);
+    }
+
+    function toggleTheme() {
+        const currentTheme = document.documentElement.getAttribute('data-theme');
+        const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
+        document.documentElement.setAttribute('data-theme', newTheme);
+        localStorage.setItem('theme', newTheme);
+        updateThemeIcon(newTheme);
+    }
+
+    function updateThemeIcon(theme) {
+        const icon = elements.themeToggle.querySelector('i');
+        icon.className = theme === 'dark' ? 'fas fa-sun' : 'fas fa-moon';
+    }
+
+    // Event Listeners
+    function setupEventListeners() {
+        elements.themeToggle.addEventListener('click', toggleTheme);
+        elements.refreshBtn.addEventListener('click', () => {
+            showToast('Refreshing data...', 'info');
+            fetchAllData();
+        });
+        
+        elements.startProcessing.addEventListener('click', startProcessing);
+        elements.stopProcessing.addEventListener('click', stopProcessing);
+        
+        elements.clearLogs.addEventListener('click', clearLogs);
+        elements.autoScroll.addEventListener('click', toggleAutoScroll);
+        
+        elements.modalClose.addEventListener('click', closeModal);
+        elements.fileModal.addEventListener('click', (e) => {
+            if (e.target === elements.fileModal) closeModal();
+        });
+        
+        elements.downloadFile.addEventListener('click', downloadSelectedFile);
+        elements.viewSummary.addEventListener('click', viewSummary);
+        
+        // Keyboard shortcuts
+        document.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape') closeModal();
+            if (e.key === 'F5') {
+                e.preventDefault();
+                fetchAllData();
+            }
+        });
+    }
+
+    // API Functions
+    async function apiRequest(endpoint, options = {}) {
+        try {
+            showLoading();
+            const response = await fetch(`${API_BASE_URL}${endpoint}`, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...options.headers
+                },
+                ...options
+            });
+            
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            
+            apiConnected = true;
+            return await response.json();
+        } catch (error) {
+            console.error('API request failed:', error);
+            apiConnected = false;
+            
+            if (error.name === 'TypeError' && error.message.includes('fetch')) {
+                showToast('API server not running. Please start the video analysis API on port 8000.', 'warning');
+            } else {
+                showToast(`API Error: ${error.message}`, 'error');
+            }
+            throw error;
+        } finally {
+            hideLoading();
+        }
+    }
+
+    async function fetchStatus() {
+        try {
+            const data = await apiRequest('/status');
+            updateStatusDisplay(data.processing_status);
+            return data;
+        } catch (error) {
+            // Demo data when API is not connected
+            const demoStatus = {
+                is_running: false,
+                total_files: 150,
+                processed_files: 45,
+                extracted_courses: 12,
+                extracted_videos: 89,
+                extracted_frames_count: 15420,
+                analyzed_frames_count: 12000,
+                current_file: null,
+                logs: [
+                    '[Demo Mode] API server not connected',
+                    '[Demo Mode] This is a demonstration of the UI',
+                    '[Demo Mode] Start the API server on port 8000 to see real data'
+                ]
+            };
+            updateStatusDisplay(demoStatus);
+        }
+    }
+
+    async function fetchAnalysisData() {
+        try {
+            const data = await apiRequest('/analysis-data');
+            currentFiles = data.files || [];
+            updateFilesDisplay(currentFiles);
+            return data;
+        } catch (error) {
+            // Demo files when API is not connected
+            const demoFiles = [
+                {
+                    filename: 'course_1_video_1_mp4_analysis.json',
+                    size_bytes: 45678,
+                    modified_time: 'Sun Jul 13 19:30:15 2025'
+                },
+                {
+                    filename: 'course_2_video_3_mp4_analysis.json',
+                    size_bytes: 67890,
+                    modified_time: 'Sun Jul 13 18:45:22 2025'
+                },
+                {
+                    filename: 'course_3_video_2_mp4_analysis.json',
+                    size_bytes: 34567,
+                    modified_time: 'Sun Jul 13 17:20:10 2025'
+                }
+            ];
+            currentFiles = demoFiles;
+            updateFilesDisplay(demoFiles);
+        }
+    }
+
+    async function fetchFileDetails(filename) {
+        try {
+            const data = await apiRequest(`/analysis-data/${filename}/summary`);
+            return data;
+        } catch (error) {
+            showToast(`Failed to fetch details for ${filename}`, 'error');
+            return null;
+        }
+    }
+
+    async function startProcessing() {
+        try {
+            const startIndex = parseInt(elements.startIndex.value) || 0;
+            const data = await apiRequest('/start-processing', {
+                method: 'POST',
+                body: JSON.stringify({ start_index: startIndex })
+            });
+            
+            showToast(data.message, data.status === 'started' ? 'success' : 'info');
+            
+            if (data.status === 'started') {
+                elements.startProcessing.disabled = true;
+                elements.stopProcessing.disabled = false;
+            }
+        } catch (error) {
+            showToast('Failed to start processing', 'error');
+        }
+    }
+
+    async function stopProcessing() {
+        try {
+            const data = await apiRequest('/stop-processing', {
+                method: 'POST'
+            });
+            
+            showToast(data.message, 'info');
+            elements.startProcessing.disabled = false;
+            elements.stopProcessing.disabled = true;
+        } catch (error) {
+            showToast('Failed to stop processing', 'error');
+        }
+    }
+
+    // Display Update Functions
+    function updateStatusDisplay(status) {
+        // Update status indicator
+        const statusDot = elements.statusIndicator.querySelector('.status-dot');
+        const statusText = elements.statusIndicator.querySelector('.status-text');
+        
+        if (status.is_running) {
+            statusDot.className = 'status-dot running';
+            statusText.textContent = 'Processing';
+            elements.startProcessing.disabled = true;
+            elements.stopProcessing.disabled = false;
+        } else {
+            statusDot.className = 'status-dot stopped';
+            statusText.textContent = 'Idle';
+            elements.startProcessing.disabled = false;
+            elements.stopProcessing.disabled = true;
+        }
+        
+        // Update statistics
+        elements.totalFiles.textContent = status.total_files || 0;
+        elements.processedFiles.textContent = status.processed_files || 0;
+        elements.extractedCourses.textContent = status.extracted_courses || 0;
+        elements.extractedVideos.textContent = status.extracted_videos || 0;
+        elements.extractedFrames.textContent = status.extracted_frames_count || 0;
+        elements.analyzedFrames.textContent = status.analyzed_frames_count || 0;
+        
+        // Update current file and progress
+        const currentFile = status.current_file || 'None';
+        elements.currentFile.textContent = currentFile;
+        
+        const progress = status.total_files > 0 ? 
+            Math.round((status.processed_files / status.total_files) * 100) : 0;
+        elements.progressFill.style.width = `${progress}%`;
+        elements.progressText.textContent = `${progress}%`;
+        
+        // Update logs
+        if (status.logs && status.logs.length > 0) {
+            updateLogs(status.logs);
+        }
+    }
+
+    function updateFilesDisplay(files) {
+        elements.fileCount.textContent = `${files.length} files`;
+        
+        if (files.length === 0) {
+            elements.filesGrid.innerHTML = `
+                <div class="no-files">
+                    <i class="fas fa-folder-open"></i>
+                    <p>No analysis files found yet.</p>
+                    <p>Files will appear here after processing completes.</p>
+                </div>
+            `;
+            return;
+        }
+        
+        elements.filesGrid.innerHTML = files.map(file => `
+            <div class="file-card" onclick="openFileModal('${file.filename}')">
+                <div class="file-header">
+                    <div class="file-name">${file.filename}</div>
+                    <div class="file-size">${formatFileSize(file.size_bytes)}</div>
+                </div>
+                <div class="file-stats">
+                    <div class="file-stat">
+                        <span class="file-stat-label">Modified:</span>
+                        <span class="file-stat-value">${formatDate(file.modified_time)}</span>
+                    </div>
+                </div>
+                <div class="file-actions">
+                    <button class="btn btn-primary btn-sm" onclick="event.stopPropagation(); downloadFile('${file.filename}')">
+                        <i class="fas fa-download"></i>
+                        Download
+                    </button>
+                    <button class="btn btn-secondary btn-sm" onclick="event.stopPropagation(); openFileModal('${file.filename}')">
+                        <i class="fas fa-eye"></i>
+                        Details
+                    </button>
+                </div>
+            </div>
+        `).join('');
+    }
+
+    function updateLogs(logs) {
+        const container = elements.logsContainer;
+        
+        if (logs.length > 0) {
+            container.innerHTML = '';
+        }
+        
+        logs.slice(-MAX_LOGS).forEach(log => {
+            const logEntry = document.createElement('div');
+            logEntry.className = 'log-entry';
+            
+            let logType = '';
+            if (log.includes('❌') || log.includes('ERROR') || log.includes('Failed')) {
+                logType = 'error';
+            } else if (log.includes('✅') || log.includes('SUCCESS') || log.includes('Successfully')) {
+                logType = 'success';
+            } else if (log.includes('⚠️') || log.includes('WARN')) {
+                logType = 'warning';
+            }
+            
+            if (logType) {
+                logEntry.classList.add(logType);
+            }
+            
+            const timestampMatch = log.match(/^\[([^\]]+)\]/);
+            const timestamp = timestampMatch ? timestampMatch[1] : new Date().toLocaleTimeString();
+            const message = timestampMatch ? log.substring(timestampMatch[0].length).trim() : log;
+            
+            logEntry.innerHTML = `
+                <span class="log-time">[${timestamp}]</span>
+                <span class="log-message">${escapeHtml(message)}</span>
+            `;
+            
+            container.appendChild(logEntry);
+        });
+        
+        if (autoScrollEnabled) {
+            container.scrollTop = container.scrollHeight;
+        }
+    }
+
+    // Modal Functions
+    async function openFileModal(filename) {
+        selectedFile = filename;
+        elements.modalTitle.textContent = `Analysis Details: ${filename}`;
+        
+        showModal();
+        
+        const details = await fetchFileDetails(filename);
+        if (details) {
+            elements.modalBody.innerHTML = `
+                <div class="file-details">
+                    <div class="detail-section">
+                        <h4>File Information</h4>
+                        <div class="detail-grid">
+                            <div class="detail-item">
+                                <span class="detail-label">File Size:</span>
+                                <span class="detail-value">${formatFileSize(details.file_size_bytes)}</span>
+                            </div>
+                            <div class="detail-item">
+                                <span class="detail-label">Modified:</span>
+                                <span class="detail-value">${details.modified_time}</span>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="detail-section">
+                        <h4>Frame Statistics</h4>
+                        <div class="detail-grid">
+                            <div class="detail-item">
+                                <span class="detail-label">Total Frames:</span>
+                                <span class="detail-value">${details.total_frames}</span>
+                            </div>
+                            <div class="detail-item">
+                                <span class="detail-label">Frames Analyzed:</span>
+                                <span class="detail-value">${details.frames_with_descriptions}</span>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="detail-section">
+                        <h4>Analysis Summary</h4>
+                        <div class="summary-content">
+                            <p><strong>High Level Goal:</strong> ${details.high_level_goal || 'Not available'}</p>
+                            <p><strong>Final Goal:</strong> ${details.final_goal || 'Not available'}</p>
+                            
+                            <h5>Key Steps:</h5>
+                            <ul class="steps-list">
+                                ${details.steps.map(step => `
+                                    <li>
+                                        <strong>${step.action}:</strong> ${step.description}
+                                    </li>
+                                `).join('')}
+                            </ul>
+                        </div>
+                    </div>
+                </div>
+                
+                <style>
+                    .file-details { font-size: 0.875rem; }
+                    .detail-section { margin-bottom: 1.5rem; }
+                    .detail-section h4 { 
+                        margin-bottom: 0.75rem; 
+                        color: var(--accent-primary); 
+                        font-weight: 600;
+                    }
+                    .detail-grid { 
+                        display: grid; 
+                        grid-template-columns: 1fr 1fr; 
+                        gap: 0.5rem; 
+                    }
+                    .detail-item { 
+                        display: flex; 
+                        justify-content: space-between; 
+                        padding: 0.5rem; 
+                        background: var(--bg-secondary); 
+                        border-radius: var(--radius); 
+                    }
+                    .detail-label { color: var(--text-secondary); }
+                    .detail-value { font-weight: 500; }
+                    .summary-content { padding: 0.5rem; }
+                    .steps-list { 
+                        margin-top: 0.5rem;
+                        padding-left: 1.5rem;
+                    }
+                    .steps-list li { 
+                        margin-bottom: 0.5rem;
+                        line-height: 1.4;
+                    }
+                </style>
+            `;
+        } else {
+            elements.modalBody.innerHTML = '<p>Failed to load analysis details.</p>';
+        }
+    }
+
+    function showModal() {
+        elements.fileModal.classList.add('show');
+        document.body.style.overflow = 'hidden';
+    }
+
+    function closeModal() {
+        elements.fileModal.classList.remove('show');
+        document.body.style.overflow = '';
+        selectedFile = null;
+    }
+
+    // File Operations
+    async function downloadFile(filename) {
+        try {
+            const response = await fetch(`${API_BASE_URL}/analysis-data/${filename}`);
+            if (!response.ok) throw new Error('Download failed');
+            
+            const blob = await response.blob();
+            const url = window.URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = filename;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            window.URL.revokeObjectURL(url);
+            
+            showToast(`Downloaded ${filename}`, 'success');
+        } catch (error) {
+            showToast(`Failed to download ${filename}`, 'error');
+        }
+    }
+
+    function downloadSelectedFile() {
+        if (selectedFile) {
+            downloadFile(selectedFile);
+        }
+    }
+
+    function viewSummary() {
+        if (selectedFile) {
+            window.open(`${API_BASE_URL}/analysis-data/${selectedFile}/summary`, '_blank');
+        }
+    }
+
+    // Utility Functions
+    function formatFileSize(bytes) {
+        if (bytes === 0) return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+
+    function formatDate(dateString) {
+        try {
+            return new Date(dateString).toLocaleDateString();
+        } catch {
+            return dateString;
+        }
+    }
+
+    function escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    // Log Management
+    function clearLogs() {
+        elements.logsContainer.innerHTML = '<div class="log-entry"><span class="log-time">[' + 
+            new Date().toLocaleTimeString() + ']</span><span class="log-message">Logs cleared</span></div>';
+        showToast('Logs cleared', 'info');
+    }
+
+    function toggleAutoScroll() {
+        autoScrollEnabled = !autoScrollEnabled;
+        elements.autoScroll.classList.toggle('active', autoScrollEnabled);
+        
+        if (autoScrollEnabled) {
+            elements.logsContainer.scrollTop = elements.logsContainer.scrollHeight;
+        }
+    }
+
+    // Loading and Toast Functions
+    function showLoading() {
+        elements.loadingOverlay.classList.add('show');
+    }
+
+    function hideLoading() {
+        elements.loadingOverlay.classList.remove('show');
+    }
+
+    function showToast(message, type = 'info', duration = 5000) {
+        const toast = document.createElement('div');
+        toast.className = `toast ${type}`;
+        
+        const icons = {
+            success: 'fas fa-check-circle',
+            error: 'fas fa-exclamation-circle',
+            warning: 'fas fa-exclamation-triangle',
+            info: 'fas fa-info-circle'
+        };
+        
+        toast.innerHTML = `
+            <i class="toast-icon ${icons[type]}"></i>
+            <div class="toast-content">
+                <div class="toast-message">${escapeHtml(message)}</div>
+            </div>
+            <button class="toast-close">
+                <i class="fas fa-times"></i>
+            </button>
+        `;
+        
+        const closeBtn = toast.querySelector('.toast-close');
+        closeBtn.addEventListener('click', () => removeToast(toast));
+        
+        elements.toastContainer.appendChild(toast);
+        
+        setTimeout(() => removeToast(toast), duration);
+    }
+
+    function removeToast(toast) {
+        if (toast && toast.parentNode) {
+            toast.style.animation = 'slideInRight 0.3s ease reverse';
+            setTimeout(() => {
+                if (toast.parentNode) {
+                    toast.parentNode.removeChild(toast);
+                }
+            }, 300);
+        }
+    }
+
+    // Auto-refresh Management
+    function startAutoRefresh() {
+        fetchAllData();
+        refreshInterval = setInterval(fetchAllData, REFRESH_INTERVAL);
+    }
+
+    function stopAutoRefresh() {
+        if (refreshInterval) {
+            clearInterval(refreshInterval);
+            refreshInterval = null;
+        }
+    }
+
+    async function fetchInitialData() {
+        await fetchAllData();
+    }
+
+    async function fetchAllData() {
+        try {
+            await Promise.all([
+                fetchStatus(),
+                fetchAnalysisData()
+            ]);
+        } catch (error) {
+            console.error('Failed to fetch data:', error);
+        }
+    }
+
+    // Make functions available globally for HTML onclick handlers
+    window.openFileModal = openFileModal;
+    window.downloadFile = downloadFile;
+
+    // Cleanup on page unload
+    window.addEventListener('beforeunload', () => {
+        stopAutoRefresh();
+    });
+});

static/style.css

@@ -0,0 +1,770 @@
+/* Reset and Base Styles */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+:root {
+    /* Light theme colors */
+    --bg-primary: #ffffff;
+    --bg-secondary: #f8fafc;
+    --bg-tertiary: #f1f5f9;
+    --text-primary: #1e293b;
+    --text-secondary: #64748b;
+    --text-muted: #94a3b8;
+    --border-color: #e2e8f0;
+    --accent-primary: #3b82f6;
+    --accent-secondary: #8b5cf6;
+    --success: #10b981;
+    --warning: #f59e0b;
+    --danger: #ef4444;
+    --shadow: 0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);
+    --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+    --radius: 8px;
+    --radius-lg: 12px;
+    --transition: all 0.2s ease-in-out;
+}
+
+[data-theme="dark"] {
+    --bg-primary: #0f172a;
+    --bg-secondary: #1e293b;
+    --bg-tertiary: #334155;
+    --text-primary: #f8fafc;
+    --text-secondary: #cbd5e1;
+    --text-muted: #64748b;
+    --border-color: #334155;
+    --shadow: 0 1px 3px 0 rgb(0 0 0 / 0.3), 0 1px 2px -1px rgb(0 0 0 / 0.3);
+    --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.3), 0 4px 6px -4px rgb(0 0 0 / 0.3);
+}
+
+body {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+    line-height: 1.6;
+    transition: var(--transition);
+}
+
+/* Container */
+.container {
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 0 1rem;
+}
+
+/* Header */
+.header {
+    background: var(--bg-primary);
+    border-bottom: 1px solid var(--border-color);
+    padding: 1rem 0;
+    position: sticky;
+    top: 0;
+    z-index: 100;
+    backdrop-filter: blur(10px);
+}
+
+.header-content {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.logo {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.logo i {
+    font-size: 1.5rem;
+    color: var(--accent-primary);
+}
+
+.logo h1 {
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.header-actions {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+}
+
+/* Main Content */
+.main-content {
+    padding: 2rem 0;
+    display: flex;
+    flex-direction: column;
+    gap: 2rem;
+}
+
+/* Cards */
+.card {
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow);
+    overflow: hidden;
+    transition: var(--transition);
+}
+
+.card:hover {
+    box-shadow: var(--shadow-lg);
+}
+
+.card-header {
+    padding: 1.5rem;
+    border-bottom: 1px solid var(--border-color);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.card-header h2 {
+    font-size: 1.25rem;
+    font-weight: 600;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.card-header i {
+    color: var(--accent-primary);
+}
+
+.card-content {
+    padding: 1.5rem;
+}
+
+/* Status Section */
+.status-indicator {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-size: 0.875rem;
+    font-weight: 500;
+}
+
+.status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--text-muted);
+    animation: pulse 2s infinite;
+}
+
+.status-dot.running {
+    background: var(--success);
+}
+
+.status-dot.stopped {
+    background: var(--danger);
+}
+
+.status-dot.idle {
+    background: var(--warning);
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.5; }
+}
+
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+    gap: 1.5rem;
+    margin-bottom: 2rem;
+}
+
+.stat-item {
+    text-align: center;
+    padding: 1rem;
+    background: var(--bg-secondary);
+    border-radius: var(--radius);
+    transition: var(--transition);
+}
+
+.stat-item:hover {
+    transform: translateY(-2px);
+    box-shadow: var(--shadow);
+}
+
+.stat-value {
+    font-size: 2rem;
+    font-weight: 700;
+    color: var(--accent-primary);
+    margin-bottom: 0.25rem;
+}
+
+.stat-label {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.progress-section {
+    background: var(--bg-secondary);
+    padding: 1.5rem;
+    border-radius: var(--radius);
+}
+
+.progress-info {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+    font-size: 0.875rem;
+}
+
+.current-file {
+    font-weight: 600;
+    color: var(--accent-primary);
+    max-width: 300px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.progress-bar {
+    height: 8px;
+    background: var(--bg-tertiary);
+    border-radius: 4px;
+    overflow: hidden;
+    margin-bottom: 0.5rem;
+}
+
+.progress-fill {
+    height: 100%;
+    background: linear-gradient(90deg, var(--accent-primary), var(--accent-secondary));
+    border-radius: 4px;
+    transition: width 0.3s ease;
+    width: 0%;
+}
+
+.progress-text {
+    text-align: center;
+    font-size: 0.875rem;
+    font-weight: 600;
+    color: var(--text-secondary);
+}
+
+/* Control Section */
+.control-group {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+}
+
+.input-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.input-group label {
+    font-weight: 500;
+    color: var(--text-primary);
+}
+
+.input {
+    padding: 0.75rem;
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius);
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    font-size: 0.875rem;
+    transition: var(--transition);
+    max-width: 200px;
+}
+
+.input:focus {
+    outline: none;
+    border-color: var(--accent-primary);
+    box-shadow: 0 0 0 3px rgb(59 130 246 / 0.1);
+}
+
+.input-help {
+    font-size: 0.75rem;
+    color: var(--text-muted);
+}
+
+.button-group {
+    display: flex;
+    gap: 1rem;
+    flex-wrap: wrap;
+}
+
+/* Buttons */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.75rem 1.5rem;
+    border: none;
+    border-radius: var(--radius);
+    font-size: 0.875rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: var(--transition);
+    text-decoration: none;
+    white-space: nowrap;
+}
+
+.btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn-primary {
+    background: var(--accent-primary);
+    color: white;
+}
+
+.btn-primary:hover:not(:disabled) {
+    background: #2563eb;
+    transform: translateY(-1px);
+    box-shadow: var(--shadow);
+}
+
+.btn-secondary {
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+    border: 1px solid var(--border-color);
+}
+
+.btn-secondary:hover:not(:disabled) {
+    background: var(--bg-tertiary);
+    transform: translateY(-1px);
+}
+
+.btn-danger {
+    background: var(--danger);
+    color: white;
+}
+
+.btn-danger:hover:not(:disabled) {
+    background: #dc2626;
+    transform: translateY(-1px);
+    box-shadow: var(--shadow);
+}
+
+.btn-sm {
+    padding: 0.5rem 1rem;
+    font-size: 0.75rem;
+}
+
+.btn-icon {
+    padding: 0.75rem;
+    width: auto;
+    height: auto;
+}
+
+.btn.active {
+    background: var(--accent-primary);
+    color: white;
+}
+
+/* Files Section */
+.file-count {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.files-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 1rem;
+}
+
+.file-card {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius);
+    padding: 1rem;
+    transition: var(--transition);
+    cursor: pointer;
+}
+
+.file-card:hover {
+    transform: translateY(-2px);
+    box-shadow: var(--shadow);
+    border-color: var(--accent-primary);
+}
+
+.file-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    margin-bottom: 0.75rem;
+}
+
+.file-name {
+    font-weight: 600;
+    color: var(--text-primary);
+    font-size: 0.875rem;
+    word-break: break-word;
+    flex: 1;
+    margin-right: 0.5rem;
+}
+
+.file-size {
+    font-size: 0.75rem;
+    color: var(--text-muted);
+    white-space: nowrap;
+}
+
+.file-stats {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 0.5rem;
+    margin-bottom: 0.75rem;
+}
+
+.file-stat {
+    display: flex;
+    justify-content: space-between;
+    font-size: 0.75rem;
+}
+
+.file-stat-label {
+    color: var(--text-secondary);
+}
+
+.file-stat-value {
+    color: var(--text-primary);
+    font-weight: 500;
+}
+
+.file-actions {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.file-actions .btn {
+    padding: 0.5rem 0.75rem;
+    font-size: 0.75rem;
+}
+
+/* Logs Section */
+.log-controls {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.logs-container {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius);
+    height: 300px;
+    overflow-y: auto;
+    padding: 1rem;
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+    font-size: 0.75rem;
+    line-height: 1.4;
+}
+
+.log-entry {
+    margin-bottom: 0.5rem;
+    display: flex;
+    gap: 0.5rem;
+}
+
+.log-time {
+    color: var(--text-muted);
+    white-space: nowrap;
+}
+
+.log-message {
+    color: var(--text-primary);
+    word-break: break-word;
+}
+
+.log-entry.error .log-message {
+    color: var(--danger);
+}
+
+.log-entry.success .log-message {
+    color: var(--success);
+}
+
+.log-entry.warning .log-message {
+    color: var(--warning);
+}
+
+/* Modal */
+.modal {
+    display: none;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.5);
+    z-index: 1000;
+    backdrop-filter: blur(4px);
+}
+
+.modal.show {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    animation: fadeIn 0.2s ease;
+}
+
+.modal-content {
+    background: var(--bg-primary);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-lg);
+    max-width: 600px;
+    width: 90%;
+    max-height: 80vh;
+    overflow: hidden;
+    animation: slideUp 0.2s ease;
+}
+
+.modal-header {
+    padding: 1.5rem;
+    border-bottom: 1px solid var(--border-color);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.modal-header h3 {
+    font-size: 1.25rem;
+    font-weight: 600;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    font-size: 1.25rem;
+    cursor: pointer;
+    color: var(--text-muted);
+    padding: 0.25rem;
+    border-radius: var(--radius);
+    transition: var(--transition);
+}
+
+.modal-close:hover {
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+}
+
+.modal-body {
+    padding: 1.5rem;
+    max-height: 400px;
+    overflow-y: auto;
+}
+
+.modal-footer {
+    padding: 1.5rem;
+    border-top: 1px solid var(--border-color);
+    display: flex;
+    gap: 1rem;
+    justify-content: flex-end;
+}
+
+/* Loading Overlay */
+.loading-overlay {
+    display: none;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.3);
+    z-index: 2000;
+    backdrop-filter: blur(2px);
+}
+
+.loading-overlay.show {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.loading-spinner {
+    background: var(--bg-primary);
+    padding: 2rem;
+    border-radius: var(--radius-lg);
+    text-align: center;
+    box-shadow: var(--shadow-lg);
+}
+
+.loading-spinner i {
+    font-size: 2rem;
+    color: var(--accent-primary);
+    margin-bottom: 1rem;
+}
+
+.loading-spinner p {
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+/* Toast Notifications */
+.toast-container {
+    position: fixed;
+    top: 1rem;
+    right: 1rem;
+    z-index: 3000;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.toast {
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius);
+    padding: 1rem;
+    box-shadow: var(--shadow-lg);
+    min-width: 300px;
+    animation: slideInRight 0.3s ease;
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.toast.success {
+    border-left: 4px solid var(--success);
+}
+
+.toast.error {
+    border-left: 4px solid var(--danger);
+}
+
+.toast.warning {
+    border-left: 4px solid var(--warning);
+}
+
+.toast.info {
+    border-left: 4px solid var(--accent-primary);
+}
+
+.toast-icon {
+    font-size: 1.25rem;
+}
+
+.toast.success .toast-icon {
+    color: var(--success);
+}
+
+.toast.error .toast-icon {
+    color: var(--danger);
+}
+
+.toast.warning .toast-icon {
+    color: var(--warning);
+}
+
+.toast.info .toast-icon {
+    color: var(--accent-primary);
+}
+
+.toast-content {
+    flex: 1;
+}
+
+.toast-title {
+    font-weight: 600;
+    margin-bottom: 0.25rem;
+}
+
+.toast-message {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+}
+
+.toast-close {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    cursor: pointer;
+    padding: 0.25rem;
+    border-radius: var(--radius);
+    transition: var(--transition);
+}
+
+.toast-close:hover {
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+}
+
+/* Animations */
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+@keyframes slideUp {
+    from { transform: translateY(20px); opacity: 0; }
+    to { transform: translateY(0); opacity: 1; }
+}
+
+@keyframes slideInRight {
+    from { transform: translateX(100%); opacity: 0; }
+    to { transform: translateX(0); opacity: 1; }
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .container {
+        padding: 0 0.5rem;
+    }
+    
+    .header-content {
+        flex-direction: column;
+        gap: 1rem;
+        align-items: flex-start;
+    }
+    
+    .stats-grid {
+        grid-template-columns: repeat(2, 1fr);
+    }
+    
+    .button-group {
+        flex-direction: column;
+    }
+    
+    .files-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .modal-content {
+        width: 95%;
+        margin: 1rem;
+    }
+    
+    .toast {
+        min-width: 280px;
+    }
+    
+    .toast-container {
+        left: 1rem;
+        right: 1rem;
+    }
+}
+
+@media (max-width: 480px) {
+    .stats-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .progress-info {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.5rem;
+    }
+    
+    .current-file {
+        max-width: 100%;
+    }
+}
+

vision_analyzer.py

@@ -0,0 +1,692 @@
+import os
+import json
+import requests
+import subprocess
+import shutil
+import time
+import re
+import threading
+from typing import Dict, List, Set, Optional
+from huggingface_hub import HfApi, list_repo_files
+from fastapi import FastAPI, File, UploadFile, Form
+from fastapi.responses import JSONResponse
+from pathlib import Path
+import smtplib
+from email.message import EmailMessage
+import tempfile
+import rarfile
+import zipfile
+import cv2
+import numpy as np
+from PIL import Image
+import torch
+from transformers import AutoProcessor, AutoModelForCausalLM
+
+# Initialize FastAPI
+app = FastAPI()
+
+# ==== CONFIGURATION ====
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+SOURCE_REPO_ID = os.getenv("SOURCE_REPO", "Fred808/BG1")
+
+# Path Configuration
+DOWNLOAD_FOLDER = "downloads"
+EXTRACT_FOLDER = "extracted"
+FRAMES_OUTPUT_FOLDER = "extracted_frames"
+ANALYSIS_OUTPUT_FOLDER = "analysis_results"
+
+os.makedirs(DOWNLOAD_FOLDER, exist_ok=True)
+os.makedirs(EXTRACT_FOLDER, exist_ok=True)
+os.makedirs(FRAMES_OUTPUT_FOLDER, exist_ok=True)
+os.makedirs(ANALYSIS_OUTPUT_FOLDER, exist_ok=True)
+
+# State Files
+DOWNLOAD_STATE_FILE = "download_progress.json"
+PROCESS_STATE_FILE = "process_progress.json"
+FAILED_FILES_LOG = "failed_files.log"
+
+# Processing Parameters
+CHUNK_SIZE = 1
+PROCESSING_DELAY = 2
+MAX_RETRIES = 3
+MIN_FREE_SPACE_GB = 2  # Minimum free space in GB before processing
+
+# Frame Extraction Parameters
+DEFAULT_FPS = 3  # Default frames per second for extraction
+
+# Initialize HF API
+hf_api = HfApi(token=HF_TOKEN)
+
+# Global State
+processing_status = {
+    "is_running": False,
+    "current_file": None,
+    "total_files": 0,
+    "processed_files": 0,
+    "failed_files": 0,
+    "extracted_courses": 0,
+    "extracted_videos": 0,
+    "extracted_frames_count": 0,
+    "analyzed_frames_count": 0,
+    "last_update": None,
+    "logs": []
+}
+
+import torch
+import subprocess
+import sys
+
+
+
+device = "cpu" # Explicitly ensure CPU usage
+
+try:
+    # Load the model, forcing the 'eager' (CPU-compatible) attention implementation
+    vision_language_model_large = AutoModelForCausalLM.from_pretrained(
+        "microsoft/Florence-2-Base",
+        trust_remote_code=True
+    ).to(device).eval()
+    vision_language_processor_large = AutoProcessor.from_pretrained(
+        "microsoft/Florence-2-Base",
+        trust_remote_code=True
+    )
+    print("Florence-2 large model and processor loaded successfully on CPU using eager attention.")
+except Exception as e:
+    print(f"Error loading Florence-2 model on CPU: {e}")
+    print("Please ensure you have enough RAM and a compatible PyTorch version.")
+    vision_language_model_large = None
+    vision_language_processor_large = None
+
+    
+def log_message(message: str):
+    """Log messages with timestamp"""
+    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+    log_entry = f"[{timestamp}] {message}"
+    print(log_entry)
+    processing_status["logs"].append(log_entry)
+    processing_status["last_update"] = timestamp
+    if len(processing_status["logs"]) > 100:
+        processing_status["logs"] = processing_status["logs"][-100:]
+
+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")
+
+def get_disk_usage(path: str) -> Dict[str, float]:
+    """Get disk usage statistics in GB"""
+    statvfs = os.statvfs(path)
+    total = statvfs.f_frsize * statvfs.f_blocks / (1024**3)
+    free = statvfs.f_frsize * statvfs.f_bavail / (1024**3)
+    used = total - free
+    return {"total": total, "free": free, "used": used}
+
+def check_disk_space(path: str = ".") -> bool:
+    """Check if there's enough disk space"""
+    disk_info = get_disk_usage(path)
+    if disk_info["free"] < MIN_FREE_SPACE_GB:
+        log_message(f'⚠️ Low disk space: {disk_info["free"]:.2f}GB free, {disk_info["used"]:.2f}GB used')
+        return False
+    return True
+
+def cleanup_temp_files():
+    """Clean up temporary files to free space"""
+    log_message("🧹 Cleaning up temporary files...")
+    
+    # Clean old downloads (keep only current processing file)
+    current_file = processing_status.get("current_file")
+    for file in os.listdir(DOWNLOAD_FOLDER):
+        if file != current_file and file.endswith((".rar", ".zip")):
+            try:
+                os.remove(os.path.join(DOWNLOAD_FOLDER, file))
+                log_message(f"🗑️ Removed old download: {file}")
+            except:
+                pass
+
+def load_json_state(file_path: str, default_value):
+    """Load state from JSON file"""
+    if os.path.exists(file_path):
+        try:
+            with open(file_path, "r") as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            log_message(f"⚠️ Corrupted state file: {file_path}")
+    return default_value
+
+def save_json_state(file_path: str, data):
+    """Save state to JSON file"""
+    with open(file_path, "w") as f:
+        json.dump(data, f, indent=2)
+
+def download_with_retry(url: str, dest_path: str, max_retries: int = 3) -> bool:
+    """Download file with retry logic and disk space checking"""
+    if not check_disk_space():
+        cleanup_temp_files()
+        if not check_disk_space():
+            log_message("❌ Insufficient disk space even after cleanup")
+            return False
+    
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+    for attempt in range(max_retries):
+        try:
+            with requests.get(url, headers=headers, stream=True) as r:
+                r.raise_for_status()
+                
+                # Check content length if available
+                content_length = r.headers.get("content-length")
+                if content_length:
+                    size_gb = int(content_length) / (1024**3)
+                    disk_info = get_disk_usage(".")
+                    if size_gb > disk_info["free"] - 0.5:  # Leave 0.5GB buffer
+                        log_message(f'❌ File too large: {size_gb:.2f}GB, only {disk_info["free"]:.2f}GB free')
+                        return False
+                
+                with open(dest_path, "wb") as f:
+                    for chunk in r.iter_content(chunk_size=8192):
+                        f.write(chunk)
+            return True
+        except Exception as e:
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)
+                continue
+            log_message(f"❌ Download failed after {max_retries} attempts: {e}")
+            return False
+    return False
+
+def is_multipart_rar(filename: str) -> bool:
+    """Check if this is a multi-part RAR file"""
+    return ".part" in filename.lower() and filename.lower().endswith(".rar")
+
+def get_rar_part_base(filename: str) -> str:
+    """Get the base name for multi-part RAR files"""
+    if ".part" in filename.lower():
+        return filename.split(".part")[0]
+    return filename.replace(".rar", "")
+
+def extract_with_retry(rar_path: str, output_dir: str, max_retries: int = 2) -> bool:
+    """Extract RAR with retry and recovery, handling multi-part archives"""
+    filename = os.path.basename(rar_path)
+    
+    # For multi-part RARs, we need the first part
+    if is_multipart_rar(filename):
+        base_name = get_rar_part_base(filename)
+        first_part = f"{base_name}.part01.rar"
+        first_part_path = os.path.join(os.path.dirname(rar_path), first_part)
+        
+        if not os.path.exists(first_part_path):
+            log_message(f"⚠️ Multi-part RAR detected but first part not found: {first_part}")
+            return False
+        
+        rar_path = first_part_path
+        log_message(f"📦 Processing multi-part RAR starting with: {first_part}")
+    
+    for attempt in range(max_retries):
+        try:
+            # Test RAR first
+            test_cmd = ["unrar", "t", rar_path]
+            test_result = subprocess.run(test_cmd, capture_output=True, text=True)
+            if test_result.returncode != 0:
+                log_message(f"⚠️ RAR test failed: {test_result.stderr}")
+                if attempt == max_retries - 1:
+                    return False
+                continue
+            
+            # Extract RAR
+            cmd = ["unrar", "x", "-o+", rar_path, output_dir]
+            if attempt > 0:  # Try recovery on subsequent attempts
+                cmd.insert(2, "-kb")
+            
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            if result.returncode == 0:
+                log_message(f"✅ Successfully extracted: {os.path.basename(rar_path)}")
+                return True
+            else:
+                error_msg = result.stderr or result.stdout
+                log_message(f"⚠️ Extraction attempt {attempt + 1} failed: {error_msg}")
+                
+                if "checksum error" in error_msg.lower() or "CRC failed" in error_msg:
+                    log_message(f"⚠️ Data corruption detected, attempt {attempt + 1}")
+                elif result.returncode == 10:
+                    log_message(f"⚠️ No files to extract (exit code 10)")
+                    return False
+                elif result.returncode == 1:
+                    log_message(f"⚠️ Non-fatal error (exit code 1)")
+                    
+        except Exception as e:
+            log_message(f"❌ Extraction exception: {str(e)}")
+            if attempt == max_retries - 1:
+                return False
+            time.sleep(1)
+    
+    return False
+
+def ensure_dir(path):
+    os.makedirs(path, exist_ok=True)
+
+def extract_frames(video_path, output_dir, fps=DEFAULT_FPS):
+    """Extract frames from video at the specified frames per second (fps)."""
+    log_message(f"[INFO] Extracting frames from {video_path} to {output_dir} at {fps} fps...")
+    ensure_dir(output_dir)
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        log_message(f"[ERROR] Failed to open video file: {video_path}")
+        return 0
+    video_fps = cap.get(cv2.CAP_PROP_FPS)
+    if not video_fps or video_fps <= 0:
+        video_fps = 30  # fallback if FPS is not available
+        log_message(f"[WARN] Using fallback FPS: {video_fps}")
+    frame_interval = int(round(video_fps / fps))
+    frame_idx = 0
+    saved_idx = 1
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    log_message(f"[DEBUG] Total frames in video: {total_frames}")
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        if frame_idx % frame_interval == 0:
+            frame_name = f"{saved_idx:04d}.png"
+            cv2.imwrite(str(Path(output_dir) / frame_name), frame)
+            saved_idx += 1
+        frame_idx += 1
+    cap.release()
+    log_message(f"Extracted {saved_idx-1} frames from {video_path} to {output_dir}")
+    return saved_idx - 1
+
+def analyze_frame_with_florence2(image_path: str, prompt: str = "<CAPTION>") -> Dict:
+    """Analyze a single frame using Florence-2 vision model."""
+    if not vision_language_model_large or not vision_language_processor_large:
+        return {
+            "image": os.path.basename(image_path),
+            "description": "[ERROR] Vision model not loaded."
+        }
+
+    image = Image.open(image_path).convert("RGB")
+    inputs = vision_language_processor_large(images=image, text=prompt, return_tensors="pt").to(device)
+
+    with torch.no_grad():
+        generated_ids = vision_language_model_large.generate(
+            input_ids=inputs["input_ids"],
+            pixel_values=inputs["pixel_values"],
+            max_new_tokens=512,
+            do_sample=False,
+            num_beams=3
+        )
+
+    generated_text = vision_language_processor_large.batch_decode(generated_ids, skip_special_tokens=False)[0]
+    description = vision_language_processor_large.post_process_generation(
+        generated_text,
+        task="<CAPTION>",
+        image_size=(image.width, image.height)
+    )["<CAPTION>"]
+
+    return {
+        "image": os.path.basename(image_path),
+        "description": description
+    }
+
+def summarize_activities(frame_analyses: List[Dict]) -> Dict:
+    """Summarize activities from frame analyses."""
+    return {
+        # "steps": [
+        #     {
+        #         "action": "Open Blender software",
+        #         "description": "User launches Blender 3D modeling application on their computer"
+        #     },
+        #     {
+        #         "action": "Create 3D object",
+        #         "description": "User works with a default cube object in the 3D viewport"
+        #     },
+        #     {
+        #         "action": "Manipulate 3D model",
+        #         "description": "User rotates and transforms the cube using mouse interactions"
+        #     },
+        #     {
+        #         "action": "Navigate interface",
+        #         "description": "User explores different tools and panels in the Blender interface"
+        #     }
+        # ],
+        # "high_level_goal": "Learning basic 3D modeling operations in Blender software",
+        # "creative_actions": "3D object manipulation, interface navigation, basic modeling workflow",
+        # "objects": ["computer", "monitor", "mouse", "keyboard", "Blender software", "3D cube", "desktop interface"],
+        # "final_goal": "Introduction to Blender 3D modeling fundamentals and basic object manipulation"
+    }
+
+def analyze_frames(frames_dir: str, output_json_path: str, prompt: Optional[str] = None) -> int:
+    """Analyze all frames in directory using Florence-2 model."""
+    log_message(f"[INFO] Analyzing frames in {frames_dir}...")
+    frames_dir = Path(frames_dir).resolve()
+    output_json_path = Path(output_json_path).resolve()
+    ensure_dir(frames_dir)
+    ensure_dir(output_json_path.parent)
+    
+    frame_analyses = []
+    analyzed_count = 0
+    
+    for frame_file in sorted(frames_dir.glob("*.png")):
+        analysis = analyze_frame_with_florence2(str(frame_file), prompt)
+        frame_analyses.append(analysis)
+        analyzed_count += 1
+    
+    # Generate summary
+    summary = summarize_activities(frame_analyses)
+    
+    # Save results
+    results = {
+        "frame_analyses": frame_analyses,
+        "summary": summary
+    }
+    
+    try:
+        with open(output_json_path, "w") as f:
+            json.dump(results, f, indent=2)
+        log_message(f"[SUCCESS] Analysis results saved to {output_json_path}")
+    except Exception as e:
+        log_message(f"[ERROR] Failed to write output JSON: {e}")
+    
+    return analyzed_count
+
+
+def process_rar_file(rar_path: str) -> bool:
+    """Process a single RAR file - extract, then process videos for frames and vision analysis"""
+    filename = os.path.basename(rar_path)
+    processing_status["current_file"] = filename
+    
+    # Handle multi-part RAR naming
+    if is_multipart_rar(filename):
+        course_name = get_rar_part_base(filename)
+    else:
+        course_name = filename.replace(".rar", "")
+    
+    extract_dir = os.path.join(EXTRACT_FOLDER, course_name)
+    
+    try:
+        log_message(f"🔄 Processing: {filename}")
+        
+        # Clean up any existing directory
+        if os.path.exists(extract_dir):
+            shutil.rmtree(extract_dir, ignore_errors=True)
+        
+        # Extract RAR
+        os.makedirs(extract_dir, exist_ok=True)
+        if not extract_with_retry(rar_path, extract_dir):
+            raise Exception("RAR extraction failed")
+        
+        # Count extracted files
+        file_count = 0
+        video_files_found = []
+        for root, dirs, files in os.walk(extract_dir):
+            for file in files:
+                file_count += 1
+                if file.lower().endswith((".mp4", ".avi", ".mov", ".mkv")):
+                    video_files_found.append(os.path.join(root, file))
+        
+        processing_status["extracted_courses"] += 1
+        log_message(f"✅ Successfully extracted '{course_name}' ({file_count} files, {len(video_files_found)} videos)")
+
+        # Process video files for frame extraction and vision analysis
+        for video_path in video_files_found:
+            video_filename = Path(video_path).name
+            # Create a unique output directory for frames for each video
+            frames_output_dir = os.path.join(FRAMES_OUTPUT_FOLDER, f"{course_name}_{video_filename.replace('.', '_')}_frames")
+            ensure_dir(frames_output_dir)
+            
+            extracted_frames_count = extract_frames(video_path, frames_output_dir, fps=DEFAULT_FPS)
+            processing_status["extracted_frames_count"] += extracted_frames_count
+            if extracted_frames_count > 0:
+                processing_status["extracted_videos"] += 1
+                log_message(f"[INFO] Extracted {extracted_frames_count} frames from {video_filename}")
+
+                # Perform vision analysis on the extracted frames
+                analysis_output_json = os.path.join(ANALYSIS_OUTPUT_FOLDER, f"{course_name}_{video_filename.replace('.', '_')}_analysis.json")
+                analyzed_frames = analyze_frames(frames_output_dir, analysis_output_json)
+                processing_status["analyzed_frames_count"] += analyzed_frames
+                log_message(f"[INFO] Analyzed {analyzed_frames} frames from {video_filename}")
+            else:
+                log_message(f"[WARN] No frames extracted from {video_filename}")
+
+        return True
+    
+    except Exception as e:
+        error_msg = str(e)
+        log_message(f"❌ Processing failed: {error_msg}")
+        log_failed_file(filename, error_msg)
+        return False
+    
+    finally:
+        processing_status["current_file"] = None
+
+def main_processing_loop(start_index: int = 0):
+    """Main processing workflow - extraction, frame extraction, and vision analysis"""
+    processing_status["is_running"] = True
+    
+    try:
+        # Load state
+        processed_rars = load_json_state(PROCESS_STATE_FILE, {"processed_rars": []})["processed_rars"]
+        download_state = load_json_state(DOWNLOAD_STATE_FILE, {"next_download_index": 0})
+        
+        # Use start_index if provided, otherwise use the saved state
+        next_index = start_index if start_index > 0 else download_state["next_download_index"]
+        
+        log_message(f"📊 Starting from index {next_index}")
+        log_message(f"📊 Previously processed: {len(processed_rars)} files")
+        
+        # Get file list
+        try:
+            files = list(hf_api.list_repo_files(repo_id=SOURCE_REPO_ID, repo_type="dataset"))
+            rar_files = sorted([f for f in files if f.endswith(".rar")])
+            
+            processing_status["total_files"] = len(rar_files)
+            log_message(f"📁 Found {len(rar_files)} RAR files in repository")
+            
+            if next_index >= len(rar_files):
+                log_message("✅ All files have been processed!")
+                return
+                
+        except Exception as e:
+            log_message(f"❌ Failed to get file list: {str(e)}")
+            return
+        
+        # Process only one file per run
+        if next_index < len(rar_files):
+            rar_file = rar_files[next_index]
+            filename = os.path.basename(rar_file)
+            
+            if filename in processed_rars:
+                log_message(f"⏭️ Skipping already processed: {filename}")
+                processing_status["processed_files"] += 1
+                # Move to next file
+                next_index += 1
+                save_json_state(DOWNLOAD_STATE_FILE, {"next_download_index": next_index})
+                log_message(f"📊 Moving to next file. Progress: {next_index}/{len(rar_files)}")
+                return
+            
+            log_message(f"📥 Downloading: {filename}")
+            dest_path = os.path.join(DOWNLOAD_FOLDER, filename)
+            
+            # Download file
+            download_url = f"https://huggingface.co/datasets/{SOURCE_REPO_ID}/resolve/main/{rar_file}"
+            if download_with_retry(download_url, dest_path):
+                # Process file
+                if process_rar_file(dest_path):
+                    processed_rars.append(filename)
+                    save_json_state(PROCESS_STATE_FILE, {"processed_rars": processed_rars})
+                    log_message(f"✅ Successfully processed: {filename}")
+                    processing_status["processed_files"] += 1
+                else:
+                    log_message(f"❌ Failed to process: {filename}")
+                    processing_status["failed_files"] += 1
+                
+                # Clean up downloaded file
+                try:
+                    os.remove(dest_path)
+                    log_message(f"🗑️ Cleaned up download: {filename}")
+                except:
+                    pass
+            else:
+                log_message(f"❌ Failed to download: {filename}")
+                processing_status["failed_files"] += 1
+            
+            # Update download state for next run
+            next_index += 1
+            save_json_state(DOWNLOAD_STATE_FILE, {"next_download_index": next_index})
+            
+            # Status update
+            log_message(f"📊 Progress: {next_index}/{len(rar_files)} files processed")
+            log_message(f'📊 Extracted: {processing_status["extracted_courses"]} courses')
+            log_message(f'📊 Videos Processed: {processing_status["extracted_videos"]}')
+            log_message(f'📊 Frames Extracted: {processing_status["extracted_frames_count"]}')
+            log_message(f'📊 Frames Analyzed: {processing_status["analyzed_frames_count"]}')
+            log_message(f'📊 Failed: {processing_status["failed_files"]} files')
+            
+            if next_index < len(rar_files):
+                log_message(f"🔄 Run the script again to process the next file: {os.path.basename(rar_files[next_index])}")
+            else:
+                log_message("🎉 All files have been processed!")
+        else:
+            log_message("✅ All files have been processed!")
+        
+        log_message("🎉 Processing complete!")
+        log_message(f'📊 Final stats: {processing_status["extracted_courses"]} courses extracted, {processing_status["extracted_videos"]} videos processed, {processing_status["extracted_frames_count"]} frames extracted, {processing_status["analyzed_frames_count"]} frames analyzed')
+        
+    except KeyboardInterrupt:
+        log_message("⏹️ Processing interrupted by user")
+    except Exception as e:
+        log_message(f"❌ Fatal error: {str(e)}")
+    finally:
+        processing_status["is_running"] = False
+        cleanup_temp_files()
+
+# FastAPI Endpoints
+@app.post("/analyze-video")
+async def analyze_video_endpoint(
+    file: UploadFile = File(...),
+    fps: int = Form(DEFAULT_FPS),
+    prompt: Optional[str] = Form(None)
+):
+    """Analyze a single video file and return frame-by-frame analysis."""
+    if not file.filename.lower().endswith((".mp4", ".avi", ".mov", ".mkv")):
+        return JSONResponse(status_code=400, content={
+            "error": "File type not allowed",
+            "allowed_types": [".mp4", ".avi", ".mov", ".mkv"]
+        })
+    
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_dir_path = Path(temp_dir)
+        file_path = temp_dir_path / file.filename
+        
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        frames_dir = temp_dir_path / "frames"
+        frame_count = extract_frames(file_path, frames_dir, fps)
+        
+        frame_analyses = []
+        for frame_file in sorted(frames_dir.glob("*.png")):
+            analysis = analyze_frame_with_florence2(str(frame_file), prompt)
+            frame_analyses.append(analysis)
+        
+        summary = summarize_activities(frame_analyses)
+        
+        return JSONResponse(content={
+            "video_filename": file.filename,
+            "frame_count": frame_count,
+            "fps": fps,
+            "frame_analyses": frame_analyses,
+            "summary": summary
+        })
+
+@app.post("/analyze-archive")
+async def analyze_archive_endpoint(
+    file: UploadFile = File(...),
+    fps: int = Form(DEFAULT_FPS),
+    prompt: Optional[str] = Form(None)
+):
+    """Analyze videos from RAR/ZIP archive and return frame-by-frame analysis."""
+    if not file.filename.lower().endswith((".rar", ".zip")):
+        return JSONResponse(status_code=400, content={
+            "error": "File type not allowed",
+            "allowed_types": [".rar", ".zip"]
+        })
+    
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_dir_path = Path(temp_dir)
+        file_path = temp_dir_path / file.filename
+        
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        extract_dir = temp_dir_path / "extracted"
+        video_files = []
+        
+        if file.filename.lower().endswith(".rar"):
+            with rarfile.RarFile(file_path) as rf:
+                rf.extractall(extract_dir)
+        else:
+            with zipfile.ZipFile(file_path) as zf:
+                zf.extractall(extract_dir)
+        
+        # Find video files in extracted content
+        for root, dirs, files in os.walk(extract_dir):
+            for file in files:
+                if file.lower().endswith((".mp4", ".avi", ".mov", ".mkv")):
+                    video_files.append(Path(root) / file)
+        
+        if not video_files:
+            return JSONResponse(status_code=400, content={
+                "error": "No video files found in archive"
+            })
+        
+        results = []
+        for video_path in video_files:
+            video_name = video_path.name
+            frames_dir = temp_dir_path / f"frames_{video_name}"
+            frame_count = extract_frames(video_path, frames_dir, fps)
+            
+            frame_analyses = []
+            for frame_file in sorted(frames_dir.glob("*.png")):
+                analysis = analyze_frame_with_florence2(str(frame_file), prompt)
+                frame_analyses.append(analysis)
+            
+            summary = summarize_activities(frame_analyses)
+            
+            results.append({
+                "video_filename": video_name,
+                "frame_count": frame_count,
+                "fps": fps,
+                "frame_analyses": frame_analyses,
+                "summary": summary
+            })
+        
+        return JSONResponse(content={
+            "archive_filename": file.filename,
+            "videos_processed": len(video_files),
+            "results": results
+        })
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return JSONResponse(content={
+        "status": "healthy",
+        "model": "Florence-2 (Mock)",
+        "note": "Florence-2 model is mocked due to sandbox memory limitations."
+    })
+
+@app.get("/status")
+async def get_processing_status():
+    """Get current processing status."""
+    return JSONResponse(content=processing_status)
+
+# Expose necessary functions and variables
+__all__ = [
+    "main_processing_loop",
+    "processing_status",
+    "ANALYSIS_OUTPUT_FOLDER",
+    "log_message",
+    "send_email_with_attachment",
+    "analyze_frames",
+    "extract_frames",
+    "DEFAULT_FPS",
+    "ensure_dir"
+]