removed redis feature

backend/app/api/routes.py

@@ -1,5 +1,5 @@
 """
-API Routes - With Optional Redis/Celery Support
+API Routes - Direct Processing (No Redis/Celery)
 """
 
 from fastapi import APIRouter, File, UploadFile, HTTPException, WebSocket, WebSocketDisconnect
@@ -23,7 +23,6 @@ from app.services.cleanup_service import cleanup_service
 
 logger = logging.getLogger(__name__)
 
-# Create router
 router = APIRouter()
 
 @router.get("/health", response_model=HealthResponse)
@@ -78,7 +77,7 @@ async def upload_video(file: UploadFile = File(...)):
 
 @router.post("/api/analyze/{session_id}")
 async def analyze_video(session_id: str):
-    """Start video analysis (uses Celery if enabled, otherwise direct processing)"""
+    """Start video analysis with direct processing"""
     try:
         session = session_manager.get_session(session_id)
         if not session:
@@ -90,43 +89,23 @@ async def analyze_video(session_id: str):
                 detail=f"Invalid session status: {session['status']}"
             )
 
-        # Check if Redis/Celery is enabled
-        if Config.USE_REDIS:
-            # Use Celery for async processing
-            from app.services.processing_service import processing_service
-            
-            task_info = processing_service.start_processing(session_id)
-
-            return {
-                "success": True,
-                "message": "Analysis queued",
-                "session_id": session_id,
-                "task_id": task_info["task_id"],
-                "poll_url": f"/api/task/{task_info['task_id']}",
-                "mode": "celery"
-            }
-        else:
-            # Direct processing without Celery
-            logger.info(f"⚡ Direct processing mode (Redis disabled)")
-            
-            # Update status
-            session_manager.update_session(session_id, {
-                "status": "processing",
-                "start_time": datetime.now().isoformat()
-            })
+        logger.info(f"⚡ Starting direct processing for {session_id}")
+        
+        # Update status
+        session_manager.update_session(session_id, {
+            "status": "processing",
+            "start_time": datetime.now().isoformat()
+        })
 
-            # Start async processing without Celery
-            asyncio.create_task(
-                process_video_direct(session_id)
-            )
+        # Start async processing
+        asyncio.create_task(process_video_direct(session_id))
 
-            return {
-                "success": True,
-                "message": "Analysis started",
-                "session_id": session_id,
-                "websocket_url": f"/ws/{session_id}",
-                "mode": "direct"
-            }
+        return {
+            "success": True,
+            "message": "Analysis started",
+            "session_id": session_id,
+            "websocket_url": f"/ws/{session_id}"
+        }
 
     except HTTPException:
         raise
@@ -136,7 +115,7 @@ async def analyze_video(session_id: str):
 
 
 async def process_video_direct(session_id: str):
-    """Direct video processing without Celery (for Windows)"""
+    """Direct video processing (async background task)"""
     from app.core.video_processor import VideoProcessor
     import json
 
@@ -169,12 +148,19 @@ async def process_video_direct(session_id: str):
             
             logger.info(f"Progress {session_id}: {progress*100:.1f}% - {message}")
 
-        # Process video
+        # Process video (blocking call in background task)
         logger.info(f"Processing video: {input_path}")
-        results = processor.process_video(
-            video_path=input_path,
-            output_path=output_path,
-            progress_callback=progress_callback
+        
+        # Run blocking code in executor to not block event loop
+        import asyncio
+        loop = asyncio.get_event_loop()
+        
+        results = await loop.run_in_executor(
+            None,
+            processor.process_video,
+            input_path,
+            output_path,
+            lambda p, m: asyncio.create_task(progress_callback(p, m))
         )
 
         # Save JSON
@@ -212,27 +198,6 @@ async def process_video_direct(session_id: str):
         })
 
 
-@router.get("/api/task/{task_id}")
-async def get_task_status(task_id: str):
-    """Get Celery task status (only works if Redis is enabled)"""
-    if not Config.USE_REDIS:
-        raise HTTPException(
-            status_code=501,
-            detail="Task polling not available in direct processing mode"
-        )
-    
-    try:
-        from app.services.processing_service import processing_service
-        status = processing_service.get_task_status(task_id)
-        return {
-            "success": True,
-            "task_id": task_id,
-            **status
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
 @router.get("/api/results/{session_id}", response_model=ResultsResponse)
 async def get_results(session_id: str):
     """Get analysis results for a session"""
@@ -249,19 +214,11 @@ async def get_results(session_id: str):
             download_url=None
         )
 
-    # Convert results to ensure JSON serialization
-    safe_results = session.get("results", {})
-    
-    # Only convert if Redis is enabled and results might have numpy types
-    if Config.USE_REDIS:
-        from app.services.processing_service import convert_to_native_bool
-        safe_results = convert_to_native_bool(safe_results)
-
     return ResultsResponse(
         success=True,
         session_id=session_id,
         status=session["status"],
-        results=safe_results,
+        results=session.get("results", {}),
         download_url=f"/api/download/{session_id}"
     )
 
@@ -378,16 +335,4 @@ async def trigger_cleanup():
         "success": True,
         "message": "Cleanup completed",
         **result
-    }
-
-
-@router.get("/api/config")
-async def get_config_info():
-    """Get current configuration info"""
-    return {
-        "platform": "Windows" if Config.IS_WINDOWS else "Linux/Mac",
-        "redis_enabled": Config.USE_REDIS,
-        "docker": Config.IS_DOCKER,
-        "hf_space": Config.IS_HF_SPACE,
-        "processing_mode": "celery" if Config.USE_REDIS else "direct"
     }

backend/app/celery_app.py

@@ -1,34 +0,0 @@
-"""
-Celery application for background task processing
-"""
-
-from celery import Celery
-import os
-
-# Redis URL from environment or default
-REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379/0")
-
-# Create Celery app
-celery_app = Celery(
-    "dance_analyzer",
-    broker=REDIS_URL,
-    backend=REDIS_URL
-)
-
-# Celery configuration
-celery_app.conf.update(
-    task_serializer='json',
-    accept_content=['json'],
-    result_serializer='json',
-    timezone='UTC',
-    enable_utc=True,
-    task_track_started=True,
-    task_time_limit=600,  # 10 minutes max per task
-    task_soft_time_limit=540,  # 9 minutes soft limit
-    worker_prefetch_multiplier=1,  # Take one task at a time
-    worker_max_tasks_per_child=10,  # Restart worker after 10 tasks
-    imports=['app.tasks']  # ✅ IMPORTANT: Tell Celery where to find tasks
-)
-
-# Auto-discover tasks
-celery_app.autodiscover_tasks(['app'])

backend/app/config.py

@@ -22,17 +22,6 @@ class Config:
     IS_DOCKER: bool = os.path.exists("/.dockerenv")
     IS_HF_SPACE: bool = os.getenv("SPACE_ID") is not None
 
-    # ==================== Redis/Celery Configuration ====================
-    # Auto-disable Redis on Windows unless explicitly enabled
-    USE_REDIS: bool = field(default_factory=lambda: (
-        os.getenv("USE_REDIS", "auto").lower() == "true" if os.getenv("USE_REDIS", "auto").lower() != "auto"
-        else not (sys.platform == "win32")  # Disable on Windows by default
-    ))
-    
-    REDIS_URL: str = os.getenv("REDIS_URL", "redis://localhost:6379/0")
-    CELERY_BROKER_URL: str = os.getenv("CELERY_BROKER_URL", "redis://localhost:6379/0")
-    CELERY_RESULT_BACKEND: str = os.getenv("CELERY_RESULT_BACKEND", "redis://localhost:6379/0")
-
     # ==================== API Configuration ====================
     API_HOST: str = os.getenv("API_HOST", "0.0.0.0")
     API_PORT: int = int(os.getenv("API_PORT", "7860"))
@@ -222,13 +211,15 @@ class Config:
         print(f"Output Folder: {cls.OUTPUT_FOLDER}")
         print("=" * 70)
 
+# ==================== Instantiate Global Config ====================
+config = Config()
 
 # Validate configuration on import
-if not Config.validate_config():
+if not config.validate_config():
     raise RuntimeError("Invalid configuration. Please check environment variables.")
 
 # Initialize folders on import
-Config.initialize_folders()
+config.initialize_folders()
 
 if __name__ == "__main__":
-    Config.print_config()
+    config.print_config()

backend/app/core/video_processor.py

@@ -17,6 +17,9 @@ from app.utils.file_utils import format_file_size
 
 logger = logging.getLogger(__name__)
 
+import inspect
+import asyncio
+
 
 class VideoProcessor:
     """
@@ -31,6 +34,13 @@ class VideoProcessor:
         self.current_video_path: Optional[Path] = None
         self.video_info: Dict[str, Any] = {}
         logger.info("VideoProcessor initialized")
+
+    def _safe_callback(self, callback, *args, **kwargs):
+        """Safely handle async or sync progress callbacks."""
+        if inspect.iscoroutinefunction(callback):
+            asyncio.create_task(callback(*args, **kwargs))
+        else:
+            callback(*args, **kwargs)
     
     def load_video(self, video_path: Path) -> Dict[str, Any]:
         """
@@ -193,7 +203,8 @@ class VideoProcessor:
                 if progress_callback:
                     progress = (frame_number + 1) / video_info['frame_count']
                     message = f"Processing frame {frame_number + 1}/{video_info['frame_count']}"
-                    progress_callback(progress, message)
+                    # progress_callback(progress, message)
+                    self._safe_callback(progress_callback, progress, message)                    
                 
                 frame_number += 1
             

backend/app/services/__init__.py

@@ -4,7 +4,6 @@ Business services
 
 from .session_manager import session_manager, SessionManager
 from .video_service import video_service, VideoService
-from .processing_service import processing_service, ProcessingService
 from .cleanup_service import cleanup_service, CleanupService
 
 __all__ = [

backend/app/services/processing_service.py

@@ -1,86 +0,0 @@
-"""
-Video processing service - Updated for Celery
-"""
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class ProcessingService:
-    """Handles video processing tasks"""
-    
-    def start_processing(self, session_id: str) -> dict:
-        """
-        Start video processing with Celery
-        
-        Args:
-            session_id: Session ID to process
-            
-        Returns:
-            Dict with task info
-        """
-        # ✅ LAZY IMPORT - Import only when function is called
-        from app.tasks import process_video_task
-        from app.services.session_manager import session_manager
-        
-        try:
-            # Submit task to Celery
-            task = process_video_task.delay(session_id)
-            
-            # Update session with task ID
-            session_manager.update_session(session_id, {
-                "status": "queued",
-                "celery_task_id": task.id
-            })
-            
-            logger.info(f"✅ Task queued: {session_id} (task_id: {task.id})")
-            
-            return {
-                "task_id": task.id,
-                "status": "queued"
-            }
-            
-        except Exception as e:
-            logger.error(f"Failed to queue task: {e}")
-            raise
-    
-    def get_task_status(self, task_id: str) -> dict:
-        """Get Celery task status"""
-        # ✅ LAZY IMPORT
-        from celery.result import AsyncResult
-        from app.celery_app import celery_app
-        
-        task = AsyncResult(task_id, app=celery_app)
-        
-        if task.state == 'PENDING':
-            response = {
-                'state': task.state,
-                'progress': 0,
-                'message': 'Task pending...'
-            }
-        elif task.state == 'PROGRESS':
-            response = {
-                'state': task.state,
-                'progress': task.info.get('progress', 0),
-                'message': task.info.get('message', ''),
-                'session_id': task.info.get('session_id', '')
-            }
-        elif task.state == 'SUCCESS':
-            response = {
-                'state': task.state,
-                'progress': 1.0,
-                'result': task.info
-            }
-        else:  # FAILURE, RETRY, etc.
-            response = {
-                'state': task.state,
-                'progress': 0,
-                'error': str(task.info)
-            }
-        
-        return response
-
-
-# Global processing service instance
-processing_service = ProcessingService()

backend/app/tasks.py

@@ -1,120 +0,0 @@
-"""
-Celery background tasks
-"""
-
-from pathlib import Path
-from datetime import datetime
-import json
-import logging
-import numpy as np
-
-from app.celery_app import celery_app
-from app.config import Config
-
-logger = logging.getLogger(__name__)
-
-
-def convert_to_native_bool(obj):
-    """Convert numpy types to native Python types"""
-    if isinstance(obj, np.bool_):
-        return bool(obj)
-    elif isinstance(obj, (np.integer, np.floating)):
-        return obj.item()
-    elif isinstance(obj, dict):
-        return {k: convert_to_native_bool(v) for k, v in obj.items()}
-    elif isinstance(obj, (list, tuple)):
-        return [convert_to_native_bool(v) for v in obj]
-    else:
-        return obj
-
-
-@celery_app.task(bind=True, name='process_video_task')
-def process_video_task(self, session_id: str):
-    """
-    Celery task for video processing
-    
-    Args:
-        self: Celery task instance
-        session_id: Session ID to process
-    """
-    # ✅ LAZY IMPORT - Import only when task runs, not at module load
-    from app.services.session_manager import session_manager
-    from app.core.video_processor import VideoProcessor
-    
-    try:
-        logger.info(f"🎬 Starting processing for session: {session_id}")
-        
-        # Get session
-        session = session_manager.get_session(session_id)
-        if not session:
-            raise ValueError(f"Session not found: {session_id}")
-        
-        input_path = Path(session["upload_path"])
-        output_path = Config.OUTPUT_FOLDER / f"analyzed_{session_id}.mp4"
-        results_path = Config.OUTPUT_FOLDER / f"results_{session_id}.json"
-        
-        # Update session status
-        session_manager.update_session(session_id, {
-            "status": "processing",
-            "celery_task_id": self.request.id
-        })
-        
-        # Create processor (inside task, not at module level)
-        processor = VideoProcessor()
-        
-        # Progress callback
-        def progress_callback(progress: float, message: str):
-            self.update_state(
-                state='PROGRESS',
-                meta={
-                    'progress': progress,
-                    'message': message,
-                    'session_id': session_id
-                }
-            )
-            logger.info(f"Progress {session_id}: {progress*100:.1f}% - {message}")
-        
-        # Process video
-        logger.info(f"Processing video: {input_path}")
-        raw_results = processor.process_video(
-            video_path=input_path,
-            output_path=output_path,
-            progress_callback=progress_callback
-        )
-        
-        # Convert results
-        results = convert_to_native_bool(raw_results)
-        
-        # Save JSON
-        with open(results_path, 'w') as f:
-            json.dump(results, f, indent=2, default=str)
-        
-        # Update session
-        session_manager.update_session(session_id, {
-            "status": "completed",
-            "output_path": str(output_path),
-            "results_path": str(results_path),
-            "end_time": datetime.now().isoformat(),
-            "results": results
-        })
-        
-        logger.info(f"✅ Processing completed: {session_id}")
-        
-        return {
-            "status": "completed",
-            "session_id": session_id,
-            "results": results,
-            "output_path": str(output_path)
-        }
-        
-    except Exception as e:
-        logger.error(f"❌ Processing failed for {session_id}: {str(e)}")
-        
-        # Lazy import here too
-        from app.services.session_manager import session_manager
-        session_manager.update_session(session_id, {
-            "status": "failed",
-            "error": str(e)
-        })
-        
-        raise  # Re-raise for Celery to mark as failed

backend/requirements.txt

@@ -29,9 +29,3 @@ python-jose==3.3.0
 
 # Templating Support
 jinja2==3.1.2
-
-# Celery and Redis
-celery==5.5.3
-redis==7.0.1
-
-flower==2.0.1  # Optional: Celery monitoring UI

docker_compose.yml

@@ -1,89 +0,0 @@
-version: '3.8'
-
-services:
-  # Redis for Celery broker
-  redis:
-    image: redis:7-alpine
-    container_name: dance-analyzer-redis
-    ports:
-      - "6379:6379"
-    volumes:
-      - redis_data:/data
-    restart: unless-stopped
-    networks:
-      - dance-analyzer-network
-
-  # Main web application
-  dance-analyzer:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: dance-movement-analyzer
-    ports:
-      - "7860:7860"
-    volumes:
-      - ./uploads:/app/uploads
-      - ./outputs:/app/outputs
-      - ./logs:/app/logs
-    environment:
-      - API_HOST=0.0.0.0
-      - API_PORT=7860
-      - DEBUG=false
-      - REDIS_URL=redis://redis:6379/0
-      - MAX_FILE_SIZE=104857600
-      - MAX_VIDEO_DURATION=60
-      - MEDIAPIPE_MODEL_COMPLEXITY=1
-      - MAX_WORKERS=2
-    depends_on:
-      - redis
-    restart: unless-stopped
-    networks:
-      - dance-analyzer-network
-
-  # Celery worker
-  celery-worker:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: dance-analyzer-worker
-    command: celery -A app.celery_app worker --loglevel=info --concurrency=2
-    volumes:
-      - ./uploads:/app/uploads
-      - ./outputs:/app/outputs
-      - ./logs:/app/logs
-    environment:
-      - REDIS_URL=redis://redis:6379/0
-      - MEDIAPIPE_MODEL_COMPLEXITY=1
-    depends_on:
-      - redis
-    restart: unless-stopped
-    networks:
-      - dance-analyzer-network
-
-  # Flower (Celery monitoring UI) - Optional
-  flower:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: dance-analyzer-flower
-    command: celery -A app.celery_app flower --port=5555
-    ports:
-      - "5555:5555"
-    environment:
-      - REDIS_URL=redis://redis:6379/0
-    depends_on:
-      - redis
-      - celery-worker
-    restart: unless-stopped
-    networks:
-      - dance-analyzer-network
-
-networks:
-  dance-analyzer-network:
-    driver: bridge
-
-volumes:
-  redis_data:
-  uploads:
-  outputs:
-  logs:

startup.sh

@@ -1,58 +1,4 @@
 #!/bin/bash
-set -e
-
 echo "🚀 Starting Dance Movement Analyzer..."
-echo "📦 MediaPipe models pre-downloaded during build"
-
-# ===============================
-# Start Redis in background
-# ===============================
-echo "🧠 Starting Redis server..."
-redis-server --bind 127.0.0.1 --port 6379 --requirepass "" &
-REDIS_PID=$!
-sleep 3
-
-if redis-cli ping > /dev/null 2>&1; then
-    echo "✅ Redis started on localhost:6379 (PID: $REDIS_PID)"
-else
-    echo "❌ Redis failed to start"
-    exit 1
-fi
-
-# ===============================
-# Start Celery Worker in Background
-# ===============================
-echo "⚙️ Starting Celery worker..."
-celery -A app.celery_app worker \
-    --loglevel=info \
-    --concurrency=2 \
-    --max-tasks-per-child=10 \
-    --time-limit=600 \
-    --soft-time-limit=540 \
-    > /tmp/celery.log 2>&1 &
-
-CELERY_PID=$!
-sleep 3
-
-if kill -0 $CELERY_PID 2>/dev/null; then
-    echo "✅ Celery worker started (PID: $CELERY_PID)"
-else
-    echo "❌ Celery worker failed to start"
-    cat /tmp/celery.log
-    exit 1
-fi
-
-# ===============================
-# Start Uvicorn (FastAPI)
-# ===============================
 PORT=${PORT:-7860}
-
-echo "🎬 Starting Uvicorn server on port $PORT..."
-echo "📍 Application will be available at http://0.0.0.0:$PORT"
-echo ""
-
-exec uvicorn app.main:app \
-    --host 0.0.0.0 \
-    --port $PORT \
-    --workers 1 \
-    --log-level info
+exec uvicorn app.main:app --host 0.0.0.0 --port $PORT --workers 1