fixed some errors

backend/app/api/routes.py

@@ -20,6 +20,7 @@ from app.models.responses import (
 )
 from app.utils.file_utils import generate_session_id
 from app.services.cleanup_service import cleanup_service
+from app.utils.helpers import convert_numpy_types
 
 logger = logging.getLogger(__name__)
 
@@ -117,6 +118,7 @@ async def analyze_video(session_id: str):
 async def process_video_direct(session_id: str):
     """Direct video processing (async background task)"""
     from app.core.video_processor import VideoProcessor
+    from app.utils.helpers import convert_numpy_types
     import json
 
     try:
@@ -129,29 +131,45 @@ async def process_video_direct(session_id: str):
         output_path = Config.OUTPUT_FOLDER / f"analyzed_{session_id}.mp4"
         results_path = Config.OUTPUT_FOLDER / f"results_{session_id}.json"
 
-        # Create processor
         processor = VideoProcessor()
 
-        # Progress callback
-        async def progress_callback(progress: float, message: str):
-            session_manager.update_session(session_id, {
-                "progress": progress,
-                "message": message
-            })
+        # ✅ Track last sent progress to throttle updates
+        last_sent_progress = -1
+        
+        def progress_callback(progress: float, message: str):
+            """Throttled progress callback - only send every 10%"""
+            nonlocal last_sent_progress
             
-            # Send WebSocket update if connected
-            await manager.send_message(session_id, {
-                "type": "progress",
-                "progress": progress,
-                "message": message
-            })
+            # Round to nearest 10%
+            progress_percent = int(progress * 100)
+            progress_milestone = (progress_percent // 10) * 10
             
-            logger.info(f"Progress {session_id}: {progress*100:.1f}% - {message}")
+            # Only send if we've crossed a 10% milestone
+            if progress_milestone > last_sent_progress or progress >= 1.0:
+                last_sent_progress = progress_milestone
+                
+                # Update session
+                session_manager.update_session(session_id, {
+                    "progress": progress,
+                    "message": message
+                })
+                
+                logger.info(f"📊 Progress {session_id}: {progress*100:.0f}% - {message}")
+                
+                # Send WebSocket update
+                try:
+                    import asyncio
+                    loop = asyncio.get_event_loop()
+                    if loop.is_running():
+                        # Create task to send WebSocket message
+                        asyncio.create_task(
+                            send_progress_update(session_id, progress, message)
+                        )
+                except Exception as e:
+                    logger.debug(f"WebSocket send failed: {e}")
 
-        # Process video (blocking call in background task)
         logger.info(f"Processing video: {input_path}")
         
-        # Run blocking code in executor to not block event loop
         import asyncio
         loop = asyncio.get_event_loop()
         
@@ -160,12 +178,15 @@ async def process_video_direct(session_id: str):
             processor.process_video,
             input_path,
             output_path,
-            lambda p, m: asyncio.create_task(progress_callback(p, m))
+            progress_callback
         )
 
+        # Sanitize results
+        safe_results = convert_numpy_types(results)
+
         # Save JSON
         with open(results_path, 'w') as f:
-            json.dump(results, f, indent=2, default=str)
+            json.dump(safe_results, f, indent=2, default=str)
 
         # Update session
         session_manager.update_session(session_id, {
@@ -173,14 +194,14 @@ async def process_video_direct(session_id: str):
             "output_path": str(output_path),
             "results_path": str(results_path),
             "end_time": datetime.now().isoformat(),
-            "results": results
+            "results": safe_results
         })
 
         # Send completion notification
         await manager.send_message(session_id, {
             "type": "complete",
             "session_id": session_id,
-            "results": results
+            "results": safe_results
         })
 
         logger.info(f"✅ Processing completed: {session_id}")
@@ -192,10 +213,25 @@ async def process_video_direct(session_id: str):
             "error": str(e)
         })
         
+        try:
+            await manager.send_message(session_id, {
+                "type": "error",
+                "error": str(e)
+            })
+        except:
+            pass
+
+
+async def send_progress_update(session_id: str, progress: float, message: str):
+    """Helper to send progress via WebSocket"""
+    try:
         await manager.send_message(session_id, {
-            "type": "error",
-            "error": str(e)
+            "type": "progress",
+            "progress": progress,
+            "message": message
         })
+    except Exception as e:
+        logger.debug(f"Failed to send progress update: {e}")
 
 
 @router.get("/api/results/{session_id}", response_model=ResultsResponse)

backend/app/api/websocket.py

@@ -5,6 +5,7 @@ WebSocket connection management
 from typing import Dict
 from fastapi import WebSocket
 import logging
+import json
 
 logger = logging.getLogger(__name__)
 
@@ -18,19 +19,23 @@ class ConnectionManager:
     async def connect(self, session_id: str, websocket: WebSocket):
         await websocket.accept()
         self.active_connections[session_id] = websocket
-        logger.info(f"WebSocket connected: {session_id}")
+        logger.info(f"✅ WebSocket connected: {session_id}")
     
     def disconnect(self, session_id: str):
         if session_id in self.active_connections:
             del self.active_connections[session_id]
-            logger.info(f"WebSocket disconnected: {session_id}")
+            logger.info(f"🔌 WebSocket disconnected: {session_id}")
     
     async def send_message(self, session_id: str, message: dict):
+        """Send JSON message to client"""
         if session_id in self.active_connections:
             try:
-                await self.active_connections[session_id].send_json(message)
+                # ✅ Ensure clean JSON serialization
+                json_str = json.dumps(message, default=str)
+                await self.active_connections[session_id].send_text(json_str)
+                logger.debug(f"📤 Sent to {session_id}: {message.get('type')}")
             except Exception as e:
-                logger.error(f"Error sending message to {session_id}: {e}")
+                logger.error(f"❌ Error sending to {session_id}: {e}")
                 self.disconnect(session_id)
     
     async def broadcast(self, message: dict):
@@ -38,7 +43,8 @@ class ConnectionManager:
         disconnected = []
         for session_id, connection in self.active_connections.items():
             try:
-                await connection.send_json(message)
+                json_str = json.dumps(message, default=str)
+                await connection.send_text(json_str)
             except Exception:
                 disconnected.append(session_id)
         

backend/app/utils/helpers.py

@@ -6,6 +6,7 @@ import time
 import logging
 from functools import wraps
 from typing import Any, Dict, Optional
+import numpy as np
 
 logger = logging.getLogger(__name__)
 
@@ -46,4 +47,23 @@ def create_error_response(error: str, details: Optional[str] = None) -> Dict[str
     }
     if details:
         response["details"] = details
-    return response
+    return response
+
+def convert_numpy_types(obj):
+    """
+    Recursively convert numpy types to native Python types for JSON serialization
+    """
+    if isinstance(obj, np.bool_):
+        return bool(obj)
+    elif isinstance(obj, (np.int_, np.intc, np.intp, np.int8, np.int16, np.int32, np.int64)):
+        return int(obj)
+    elif isinstance(obj, (np.float_, np.float16, np.float32, np.float64)):
+        return float(obj)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    elif isinstance(obj, dict):
+        return {key: convert_numpy_types(value) for key, value in obj.items()}
+    elif isinstance(obj, (list, tuple)):
+        return [convert_numpy_types(item) for item in obj]
+    else:
+        return obj

frontend/js/main.js

@@ -5,7 +5,7 @@
 import { APP_CONFIG } from './core/config.js';
 import { appState } from './core/state.js';
 import { apiService } from './services/api-service.js';
-import { pollingService } from './services/polling-service.js';
+// import { pollingService } from './services/polling-service.js';
 import { toast } from './ui/toast.js';
 import { progressManager } from './ui/progress.js';
 import { videoHandler } from './handlers/video-handler.js';
@@ -142,23 +142,11 @@ async function startAnalysis() {
         // Start analysis
         const data = await apiService.startAnalysis(appState.sessionId);
         
-        appState.setTask(data.task_id);
         progressManager.start();
-        
         toast.info('Analysis started!');
         
-        // Start polling
-        pollingService.startPolling(data.task_id, {
-            onProgress: (progress, message) => {
-                progressManager.update(progress, message);
-            },
-            onComplete: async (result) => {
-                await handleAnalysisComplete(result);
-            },
-            onError: (error) => {
-                handleAnalysisError(error);
-            }
-        });
+        // Connect WebSocket for real-time updates
+        connectWebSocket(appState.sessionId);
         
     } catch (error) {
         console.error('Analysis error:', error);
@@ -168,6 +156,86 @@ async function startAnalysis() {
     }
 }
 
+function connectWebSocket(sessionId) {
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const wsUrl = `${protocol}//${window.location.host}/ws/${sessionId}`;
+    
+    console.log('🔌 Connecting WebSocket:', wsUrl);
+    
+    const ws = new WebSocket(wsUrl);
+    let heartbeatInterval;
+    
+    ws.onopen = () => {
+        console.log('✅ WebSocket connected');
+        toast.info('Connected - receiving updates');
+        
+        // Send heartbeat every 20 seconds
+        heartbeatInterval = setInterval(() => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send('ping');
+            }
+        }, 20000);
+    };
+    
+    ws.onmessage = (event) => {
+        try {
+            const data = JSON.parse(event.data);
+            console.log('📨 WebSocket message:', data);
+            
+            switch (data.type) {
+                case 'connected':
+                    console.log('✅ Connected to session:', data.session_id);
+                    break;
+                    
+                case 'progress':
+                    // ✅ Update progress bar and ETA
+                    const progress = data.progress || 0;
+                    const message = data.message || 'Processing...';
+                    
+                    console.log(`📊 Progress: ${(progress * 100).toFixed(0)}%`);
+                    progressManager.update(progress, message);
+                    break;
+                    
+                case 'complete':
+                    console.log('🎉 Analysis complete!');
+                    clearInterval(heartbeatInterval);
+                    handleAnalysisComplete(data);
+                    ws.close();
+                    break;
+                    
+                case 'error':
+                    console.error('❌ Error:', data.error);
+                    clearInterval(heartbeatInterval);
+                    handleAnalysisError(new Error(data.error));
+                    ws.close();
+                    break;
+                    
+                case 'pong':
+                    // Heartbeat response
+                    break;
+                    
+                default:
+                    console.log('Unknown message type:', data.type);
+            }
+        } catch (error) {
+            console.error('Failed to parse WebSocket message:', error, event.data);
+        }
+    };
+    
+    ws.onerror = (error) => {
+        console.error('❌ WebSocket error:', error);
+        toast.error('Connection error - progress may not update');
+    };
+    
+    ws.onclose = (event) => {
+        console.log('🔌 WebSocket closed:', event.code, event.reason);
+        clearInterval(heartbeatInterval);
+    };
+    
+    // Store reference for cleanup
+    appState.ws = ws;
+}
+
 async function handleAnalysisComplete(result) {
     progressManager.complete();
     
@@ -266,7 +334,7 @@ function displayBodyParts(bodyParts) {
 function resetApp() {
     appState.reset();
     progressManager.reset();
-    pollingService.stopPolling();
+    // pollingService.stopPolling();
     
     elements.fileInfo.style.display = 'none';
     elements.uploadSection.style.display = 'block';

frontend/js/services/api-service.js

@@ -39,15 +39,15 @@ export class APIService {
         return await response.json();
     }
     
-    async getTaskStatus(taskId) {
-        const response = await fetch(`${this.baseURL}/api/task/${taskId}`);
+    // async getTaskStatus(taskId) {
+    //     const response = await fetch(`${this.baseURL}/api/task/${taskId}`);
         
-        if (!response.ok) {
-            throw new Error('Failed to get task status');
-        }
+    //     if (!response.ok) {
+    //         throw new Error('Failed to get task status');
+    //     }
         
-        return await response.json();
-    }
+    //     return await response.json();
+    // }
     
     async getResults(sessionId) {
         const response = await fetch(`${this.baseURL}/api/results/${sessionId}`);

frontend/js/ui/progress.js

@@ -9,25 +9,32 @@ export class ProgressManager {
             text: document.getElementById('progressText'),
             message: document.getElementById('processingMessage'),
             elapsed: document.getElementById('elapsedTime'),
-            eta: document.getElementById('etaTime')  // New element for ETA
+            eta: document.getElementById('etaTime'),
+            status: document.getElementById('statusValue')
         };
         this.startTime = null;
         this.interval = null;
+        this.lastProgress = 0;
     }
     
     start() {
         this.startTime = Date.now();
+        this.lastProgress = 0;
         this.updateElapsedTime();
         
         // Update elapsed time every second
         this.interval = setInterval(() => {
             this.updateElapsedTime();
         }, 1000);
+        
+        console.log('⏱️ Progress tracking started');
     }
     
     update(progress, message = '') {
         const percentage = Math.round(progress * 100);
         
+        console.log(`📊 Updating progress: ${percentage}% - ${message}`);
+        
         if (this.elements.fill) {
             this.elements.fill.style.width = `${percentage}%`;
         }
@@ -40,7 +47,12 @@ export class ProgressManager {
             this.elements.message.textContent = message;
         }
         
+        if (this.elements.status) {
+            this.elements.status.textContent = 'Processing';
+        }
+        
         // Update ETA
+        this.lastProgress = progress;
         this.updateETA(progress);
     }
     
@@ -52,14 +64,27 @@ export class ProgressManager {
     }
     
     updateETA(progress) {
-        if (!this.startTime || !this.elements.eta || progress <= 0) return;
+        if (!this.startTime || !this.elements.eta || progress <= 0) {
+            if (this.elements.eta) {
+                this.elements.eta.textContent = 'Calculating...';
+            }
+            return;
+        }
         
-        const elapsed = Date.now() - this.startTime;
+        // Calculate ETA based on current progress
+        const elapsed = (Date.now() - this.startTime) / 1000; // seconds
         const estimatedTotal = elapsed / progress;
         const remaining = Math.max(0, estimatedTotal - elapsed);
-        const etaSeconds = Math.ceil(remaining / 1000);
         
-        this.elements.eta.textContent = this.formatTime(etaSeconds);
+        console.log(`⏱️ ETA: ${remaining.toFixed(0)}s remaining (${(progress * 100).toFixed(0)}% complete)`);
+        
+        if (this.elements.eta) {
+            if (remaining > 0 && progress < 1.0) {
+                this.elements.eta.textContent = this.formatTime(Math.ceil(remaining));
+            } else {
+                this.elements.eta.textContent = 'Almost done!';
+            }
+        }
     }
     
     formatTime(seconds) {
@@ -77,7 +102,17 @@ export class ProgressManager {
     }
     
     complete() {
+        console.log('✅ Progress complete!');
         this.update(1.0, 'Analysis complete!');
+        
+        if (this.elements.status) {
+            this.elements.status.textContent = 'Complete';
+        }
+        
+        if (this.elements.eta) {
+            this.elements.eta.textContent = 'Done!';
+        }
+        
         this.stop();
     }
     
@@ -91,12 +126,16 @@ export class ProgressManager {
     reset() {
         this.stop();
         this.startTime = null;
+        this.lastProgress = 0;
         
         if (this.elements.fill) this.elements.fill.style.width = '0%';
         if (this.elements.text) this.elements.text.textContent = '0%';
         if (this.elements.message) this.elements.message.textContent = '';
         if (this.elements.elapsed) this.elements.elapsed.textContent = '0s';
         if (this.elements.eta) this.elements.eta.textContent = '--';
+        if (this.elements.status) this.elements.status.textContent = 'Ready';
+        
+        console.log('🔄 Progress reset');
     }
 }