Initial deployment: SWARA API with eye tracking, facial expression, and gesture detection

.env

@@ -0,0 +1,27 @@
+# Environment Configuration
+ENV=production
+
+# Redis Configuration (Upstash)
+REDIS_URL=rediss://default:ASjMAAIncDJkMmEyMzAxMDdhOWI0YzQyOThmNDg3ZjkxMDZkYmQ3ZXAyMTA0NDQ@profound-catfish-10444.upstash.io:6379
+
+# API Configuration
+API_HOST=0.0.0.0
+API_PORT=7860
+API_WORKERS=1
+
+# Processing Configuration
+MAX_VIDEO_SIZE_MB=50
+MAX_VIDEO_DURATION_SECONDS=60
+TEMP_DIR=./temp
+MODELS_DIR=./models
+
+# Task Configuration
+TASK_TIMEOUT_SECONDS=300
+TASK_RESULT_TTL_SECONDS=3600
+
+# Rate Limiting
+RATE_LIMIT_REQUESTS=10
+RATE_LIMIT_PERIOD_SECONDS=3600
+
+# Logging
+LOG_LEVEL=INFO

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies for OpenCV and MediaPipe
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender1 \
+    libgomp1 \
+    libgstreamer1.0-0 \
+    libgstreamer-plugins-base1.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first (for better caching)
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p temp models logs
+
+# Expose port
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:7860/health')"
+
+# Run application
+CMD ["python", "-m", "app.main"]

README.md

@@ -1,11 +1,451 @@
 ---
-title: Swara Api
-emoji: 👀
-colorFrom: purple
-colorTo: gray
+title: SWARA - AI Public Speaking Evaluation
+emoji: 🎤
+colorFrom: blue
+colorTo: purple
 sdk: docker
-pinned: false
-license: mit
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎤 SWARA API - AI-Powered Public Speaking Evaluation
+
+API backend untuk sistem evaluasi public speaking berbasis AI.
+
+## 📋 Fitur
+
+- ✅ **Async Video Processing** - Non-blocking video analysis dengan RQ (Redis Queue)
+- ✅ **Multi-Model AI** - Eye tracking, facial expression, gesture detection
+- ✅ **Level-based Evaluation** - 5 level kesulitan dengan indikator berbeda
+- ✅ **RESTful API** - FastAPI dengan OpenAPI documentation
+- ✅ **Cloud Redis** - Upstash Redis untuk production
+- ✅ **Progress Tracking** - Real-time progress updates untuk analysis
+
+## 🏗️ Arsitektur
+
+```
+┌─────────────────────────────────────────┐
+│         Docker Container                │
+│                                         │
+│  ┌──────────────┐    ┌──────────────┐  │
+│  │   FastAPI    │───▶│    Redis     │  │
+│  │ (Port 7860)  │    │ (Queue & KV) │  │
+│  └──────────────┘    └──────────────┘  │
+│         │                    │          │
+│         │ POST /analyze      │          │
+│         │ return task_id     │          │
+│         │                    ▼          │
+│         │           ┌──────────────┐   │
+│         │           │  RQ Worker   │   │
+│         │           │ (Background) │   │
+│         │           └──────────────┘   │
+│         │                    │          │
+│         │ GET /task/{id}     │          │
+│         │◀───────────────────┘          │
+└─────────────────────────────────────────┘
+```
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Docker & Docker Compose
+- Python 3.10+ (untuk development tanpa Docker)
+
+### 1. Clone & Setup
+
+```powershell
+# Clone repository (if applicable)
+cd API-MODEL
+
+# Copy environment file
+cp .env.example .env
+
+# Edit .env jika perlu (optional untuk local development)
+```
+
+### 2. Run dengan Docker Compose
+
+```powershell
+# Build dan start semua services
+docker-compose up --build
+
+# Atau run di background
+docker-compose up -d --build
+
+# Lihat logs
+docker-compose logs -f
+
+# Stop services
+docker-compose down
+```
+
+API akan tersedia di: `http://localhost:7860`
+
+### 3. Akses Documentation
+
+- **Swagger UI**: http://localhost:7860/docs
+- **ReDoc**: http://localhost:7860/redoc
+- **OpenAPI JSON**: http://localhost:7860/openapi.json
+
+## 📖 API Endpoints
+
+### 1. Health Check
+
+```bash
+GET /health
+```
+
+**Response:**
+
+```json
+{
+  "status": "healthy",
+  "version": "1.0.0",
+  "redis_connected": true,
+  "timestamp": "2025-11-10T10:00:00"
+}
+```
+
+### 2. Upload Video untuk Analysis
+
+```bash
+POST /api/v1/analyze
+Content-Type: multipart/form-data
+```
+
+**Parameters:**
+
+- `video` (file): Video file (max 50MB, max 1 minute)
+- `level` (int): Level 1-5
+- `user_id` (string, optional): User identifier
+
+**Response:**
+
+```json
+{
+  "task_id": "abc123def456",
+  "status": "pending",
+  "message": "Video uploaded successfully. Processing has been queued.",
+  "created_at": "2025-11-10T10:00:00"
+}
+```
+
+### 3. Get Task Status
+
+```bash
+GET /api/v1/task/{task_id}
+```
+
+**Response (Processing):**
+
+```json
+{
+  "task_id": "abc123def456",
+  "status": "processing",
+  "progress": {
+    "current_step": "processing",
+    "percentage": 45.5,
+    "message": "Analyzing facial expressions..."
+  },
+  "created_at": "2025-11-10T10:00:00"
+}
+```
+
+**Response (Completed):**
+
+```json
+{
+  "task_id": "abc123def456",
+  "status": "completed",
+  "result": {
+    "level": 2,
+    "video_metadata": {
+      "duration": 58.5,
+      "fps": 30,
+      "resolution": "1920x1080",
+      "file_size": 15728640
+    },
+    "main_indicators": {
+      "kontak_mata": {
+        "score": 4,
+        "raw_data": {...}
+      }
+    },
+    "bonus_indicators": {
+      "first_impression": {
+        "detected": true,
+        "raw_data": {...}
+      },
+      "face_expression": {...},
+      "gesture": {...}
+    },
+    "processing_time": 42.3
+  },
+  "created_at": "2025-11-10T10:00:00",
+  "completed_at": "2025-11-10T10:01:00"
+}
+```
+
+### 4. Delete Task
+
+```bash
+DELETE /api/v1/task/{task_id}
+```
+
+## 🧪 Testing dengan cURL
+
+### Upload Video
+
+```powershell
+curl -X POST "http://localhost:7860/api/v1/analyze" `
+  -F "video=@test_video.mp4" `
+  -F "level=2" `
+  -F "user_id=user123"
+```
+
+### Check Status
+
+```powershell
+curl "http://localhost:7860/api/v1/task/abc123def456"
+```
+
+## 🛠️ Development Setup (Tanpa Docker)
+
+### 1. Install Dependencies
+
+```powershell
+# Create virtual environment
+python -m venv venv
+.\venv\Scripts\activate
+
+# Install dependencies
+pip install -r requirements.txt
+```
+
+### 2. Setup Redis (Local atau Upstash)
+
+**Option A: Local Redis (dengan Docker)**
+
+```powershell
+docker run -d -p 6379:6379 redis:7-alpine
+```
+
+**Option B: Upstash Redis (Gratis)**
+
+1. Daftar di https://upstash.com
+2. Create Redis database
+3. Copy connection string ke `.env`:
+
+```
+REDIS_URL=redis://default:YOUR_PASSWORD@YOUR_ENDPOINT:6379
+```
+
+### 3. Run API Server
+
+```powershell
+python -m app.main
+```
+
+### 4. Run Worker (Terminal terpisah)
+
+```powershell
+python -m app.worker
+```
+
+## 📁 Project Structure
+
+```
+API-MODEL/
+├── app/
+│   ├── __init__.py
+│   ├── main.py              # FastAPI app
+│   ├── config.py            # Configuration
+│   ├── models.py            # Pydantic models
+│   ├── tasks.py             # Background tasks
+│   ├── worker.py            # RQ worker
+│   ├── api/
+│   │   ├── routes.py        # API endpoints
+│   ├── core/
+│   │   ├── redis_client.py  # Redis connection
+│   │   └── storage.py       # File storage
+│   └── services/
+│       ├── video_processor.py    # Main orchestrator
+│       ├── eye_tracking.py       # Eye tracking service
+│       ├── facial_expression.py  # Facial expression service
+│       └── gesture_detection.py  # Gesture detection service
+├── models/                  # AI model files
+├── temp/                    # Temporary video storage
+├── logs/                    # Application logs
+├── docker-compose.yml
+├── Dockerfile
+├── requirements.txt
+└── README.md
+```
+
+## ⚙️ Configuration
+
+Edit `.env` file untuk konfigurasi:
+
+```env
+# Environment
+ENV=development
+
+# Redis (Upstash atau local)
+REDIS_URL=redis://localhost:6379
+
+# API
+API_HOST=0.0.0.0
+API_PORT=7860
+
+# Processing
+MAX_VIDEO_SIZE_MB=50
+MAX_VIDEO_DURATION_SECONDS=60
+TASK_TIMEOUT_SECONDS=300
+
+# Logging
+LOG_LEVEL=INFO
+```
+
+## 📊 Monitoring
+
+### View Logs
+
+```powershell
+# API logs
+docker-compose logs -f api
+
+# Worker logs
+docker-compose logs -f worker
+
+# Redis logs
+docker-compose logs -f redis
+
+# All logs
+docker-compose logs -f
+```
+
+### Check Redis Queue
+
+```powershell
+# Connect to Redis container
+docker exec -it swara-redis redis-cli
+
+# Check queue length
+LLEN swara:tasks
+
+# View all keys
+KEYS *
+
+# Get task data
+GET task:abc123def456
+```
+
+## 🔧 Troubleshooting
+
+### Problem: Redis connection failed
+
+**Solution:**
+
+```powershell
+# Check Redis is running
+docker-compose ps
+
+# Restart Redis
+docker-compose restart redis
+
+# Check Redis logs
+docker-compose logs redis
+```
+
+### Problem: Worker not processing tasks
+
+**Solution:**
+
+```powershell
+# Check worker logs
+docker-compose logs worker
+
+# Restart worker
+docker-compose restart worker
+
+# Check if worker is running
+docker-compose ps worker
+```
+
+### Problem: Video file too large
+
+**Solution:**
+
+- Compress video atau gunakan format yang lebih efisien
+- Increase `MAX_VIDEO_SIZE_MB` di `.env`
+
+## 📝 Next Steps (TODO)
+
+Untuk complete implementation, Anda perlu:
+
+1. **Refactor existing code** ke services:
+
+   - [ ] `app/services/eye_tracking.py` - dari `eye_tracking_production.py`
+   - [ ] `app/services/facial_expression.py` - dari `facial_expression.py`
+   - [ ] `app/services/gesture_detection.py` - dari `gesture_detection.py`
+
+2. **Add audio processing**:
+
+   - [ ] `app/services/audio_processor.py` - untuk tempo, artikulasi, jeda
+   - [ ] Speech-to-text integration
+   - [ ] Kata pengisi & kata tidak senonoh detection
+
+3. **Add NLP processing**:
+
+   - [ ] `app/services/nlp_processor.py` - untuk kesesuaian topik, struktur kalimat
+   - [ ] Topic matching
+   - [ ] Sentence structure analysis
+
+4. **Optimization**:
+
+   - [ ] Implement frame sampling (5 fps instead of 30 fps)
+   - [ ] Model loading optimization
+   - [ ] Memory management
+
+5. **Testing**:
+   - [ ] Unit tests
+   - [ ] Integration tests
+   - [ ] Load testing
+
+## 🚢 Deployment ke HuggingFace Spaces
+
+### 1. Create Space
+
+1. Go to https://huggingface.co/spaces
+2. Create new Space (Docker type)
+3. Clone repository
+
+### 2. Prepare Files
+
+```bash
+# Add Dockerfile for HF Spaces
+# (sudah ada di repository)
+```
+
+### 3. Setup Secrets
+
+Di HuggingFace Space settings, add secrets:
+
+- `REDIS_URL` - Upstash Redis URL
+- `ENV` - production
+
+### 4. Push & Deploy
+
+```bash
+git push origin main
+```
+
+HuggingFace akan auto-deploy!
+
+## 📞 Support
+
+Untuk pertanyaan atau issues, contact SWARA team.
+
+---
+
+**Built with ❤️ by SWARA Team for LIDM Competition 2025**

app.py

@@ -0,0 +1,18 @@
+"""
+SWARA API - Entry Point untuk HuggingFace Spaces (Non-Docker)
+"""
+import os
+import uvicorn
+from app.main import app
+
+if __name__ == "__main__":
+    # Get port from environment (HuggingFace uses 7860)
+    port = int(os.environ.get("PORT", 7860))
+    
+    # Run server
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=port,
+        log_level="info"
+    )

app/__init__.py

@@ -0,0 +1,7 @@
+"""
+SWARA - AI-Powered Public Speaking Evaluation System
+API Application Package
+"""
+
+__version__ = "1.0.0"
+__author__ = "SWARA Team"

app/api/__init__.py

@@ -0,0 +1,3 @@
+"""
+API module initialization
+"""

app/api/routes.py

@@ -0,0 +1,288 @@
+"""
+API Route Handlers
+"""
+import json
+import uuid
+from datetime import datetime
+from typing import Optional
+from fastapi import APIRouter, UploadFile, File, Form, HTTPException, status
+from loguru import logger
+from rq import Queue
+from rq.job import Job
+
+from app.models import (
+    TaskCreateResponse,
+    TaskStatusResponse,
+    TaskStatus,
+    HealthResponse,
+    ErrorResponse,
+    Level
+)
+from app.core.redis_client import get_redis_client
+from app.core.storage import get_storage_manager
+from app.config import settings
+
+# Create router
+router = APIRouter()
+
+
+@router.get("/", tags=["Root"])
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "SWARA API - AI-Powered Public Speaking Evaluation",
+        "version": "1.0.0",
+        "docs": "/docs"
+    }
+
+
+@router.get("/health", response_model=HealthResponse, tags=["Health"])
+async def health_check():
+    """
+    Health check endpoint
+    
+    Checks:
+    - API status
+    - Redis connection
+    """
+    redis_client = get_redis_client()
+    redis_connected = redis_client.is_connected()
+    
+    return HealthResponse(
+        status="healthy" if redis_connected else "degraded",
+        version=settings.API_VERSION,
+        redis_connected=redis_connected
+    )
+
+
+@router.post(
+    "/api/v1/analyze",
+    response_model=TaskCreateResponse,
+    status_code=status.HTTP_202_ACCEPTED,
+    tags=["Analysis"]
+)
+async def analyze_video(
+    video: UploadFile = File(..., description="Video file to analyze"),
+    level: int = Form(..., ge=1, le=5, description="Public speaking level (1-5)"),
+    user_id: Optional[str] = Form(None, description="Optional user ID")
+):
+    """
+    Upload video for analysis
+    
+    This endpoint accepts a video file and queues it for processing.
+    Returns a task_id that can be used to check the analysis status.
+    
+    **Parameters:**
+    - **video**: Video file (MP4 format recommended, max 50MB, max 1 minute)
+    - **level**: Public speaking level (1-5)
+    - **user_id**: Optional user identifier for tracking
+    
+    **Returns:**
+    - task_id: Unique identifier to check task status
+    - status: Task status (pending)
+    - created_at: Task creation timestamp
+    """
+    try:
+        # Validate file type
+        if not video.content_type or not video.content_type.startswith("video/"):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Invalid file type. Please upload a video file."
+            )
+        
+        # Read video content
+        video_content = await video.read()
+        video_size = len(video_content)
+        
+        # Validate file size
+        if video_size > settings.max_video_size_bytes:
+            raise HTTPException(
+                status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+                detail=f"Video size exceeds maximum allowed size of {settings.MAX_VIDEO_SIZE_MB}MB"
+            )
+        
+        # Save video to temporary storage
+        storage = get_storage_manager()
+        video_path = await storage.save_video(video_content)
+        
+        # Generate task ID
+        task_id = uuid.uuid4().hex
+        
+        # Create task metadata
+        task_data = {
+            "task_id": task_id,
+            "status": TaskStatus.PENDING.value,
+            "video_path": video_path,
+            "level": level,
+            "user_id": user_id,
+            "video_size": video_size,
+            "original_filename": video.filename,
+            "created_at": datetime.utcnow().isoformat()
+        }
+        
+        # Store task in Redis
+        redis_client = get_redis_client().get_client()
+        task_key = f"task:{task_id}"
+        redis_client.setex(
+            task_key,
+            settings.TASK_RESULT_TTL_SECONDS,
+            json.dumps(task_data)
+        )
+        
+        # Queue the task for processing
+        queue = Queue(settings.TASK_QUEUE_NAME, connection=redis_client)
+        job = queue.enqueue(
+            'app.tasks.process_video_task',
+            task_id,
+            video_path,
+            level,
+            job_timeout=settings.TASK_TIMEOUT_SECONDS,
+            result_ttl=settings.TASK_RESULT_TTL_SECONDS,
+            job_id=task_id
+        )
+        
+        logger.info(f"✓ Task created: {task_id} (Level {level}, Size: {video_size} bytes)")
+        
+        return TaskCreateResponse(
+            task_id=task_id,
+            status=TaskStatus.PENDING,
+            message="Video uploaded successfully. Processing has been queued.",
+            created_at=datetime.utcnow()
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"✗ Error creating task: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to create analysis task: {str(e)}"
+        )
+
+
+@router.get(
+    "/api/v1/task/{task_id}",
+    response_model=TaskStatusResponse,
+    tags=["Analysis"]
+)
+async def get_task_status(task_id: str):
+    """
+    Get task status and results
+    
+    Check the status of a video analysis task. If the task is completed,
+    this endpoint returns the full analysis results.
+    
+    **Parameters:**
+    - **task_id**: Task identifier returned from the analyze endpoint
+    
+    **Returns:**
+    - Task status (pending, processing, completed, failed)
+    - Progress information (if processing)
+    - Analysis results (if completed)
+    """
+    try:
+        redis_client = get_redis_client().get_client()
+        
+        # Get task data from Redis
+        task_key = f"task:{task_id}"
+        task_data_str = redis_client.get(task_key)
+        
+        if not task_data_str:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Task {task_id} not found or has expired"
+            )
+        
+        task_data = json.loads(task_data_str)
+        
+        # Get RQ job status
+        try:
+            job = Job.fetch(task_id, connection=redis_client)
+            
+            # Update status based on job state
+            if job.is_finished:
+                task_data["status"] = TaskStatus.COMPLETED.value
+                task_data["completed_at"] = datetime.utcnow().isoformat()
+                if job.result:
+                    task_data["result"] = job.result
+            elif job.is_failed:
+                task_data["status"] = TaskStatus.FAILED.value
+                task_data["error"] = str(job.exc_info) if job.exc_info else "Unknown error"
+                task_data["completed_at"] = datetime.utcnow().isoformat()
+            elif job.is_started:
+                task_data["status"] = TaskStatus.PROCESSING.value
+        except:
+            # Job not found in queue, use stored status
+            pass
+        
+        # Parse response
+        response = TaskStatusResponse(
+            task_id=task_data["task_id"],
+            status=TaskStatus(task_data["status"]),
+            progress=task_data.get("progress"),
+            result=task_data.get("result"),
+            error=task_data.get("error"),
+            created_at=datetime.fromisoformat(task_data["created_at"]),
+            completed_at=datetime.fromisoformat(task_data["completed_at"]) if task_data.get("completed_at") else None
+        )
+        
+        return response
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"✗ Error getting task status: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get task status: {str(e)}"
+        )
+
+
+@router.delete(
+    "/api/v1/task/{task_id}",
+    tags=["Analysis"]
+)
+async def delete_task(task_id: str):
+    """
+    Delete task and cleanup associated files
+    
+    **Parameters:**
+    - **task_id**: Task identifier to delete
+    
+    **Returns:**
+    - Success message
+    """
+    try:
+        redis_client = get_redis_client().get_client()
+        storage = get_storage_manager()
+        
+        # Get task data
+        task_key = f"task:{task_id}"
+        task_data_str = redis_client.get(task_key)
+        
+        if task_data_str:
+            task_data = json.loads(task_data_str)
+            
+            # Delete video file
+            if "video_path" in task_data:
+                storage.delete_video(task_data["video_path"])
+            
+            # Delete task from Redis
+            redis_client.delete(task_key)
+            
+            logger.info(f"✓ Task deleted: {task_id}")
+            return {"message": f"Task {task_id} deleted successfully"}
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Task {task_id} not found"
+            )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"✗ Error deleting task: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to delete task: {str(e)}"
+        )

app/config.py

@@ -0,0 +1,78 @@
+"""
+Configuration Management
+"""
+import os
+from pathlib import Path
+from typing import Optional
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+
+class Settings(BaseSettings):
+    """Application Settings"""
+    
+    # Environment
+    ENV: str = "development"
+    
+    # API Configuration
+    API_HOST: str = "0.0.0.0"
+    API_PORT: int = 7860
+    API_WORKERS: int = 1
+    API_TITLE: str = "SWARA API"
+    API_VERSION: str = "1.0.0"
+    API_DESCRIPTION: str = "AI-Powered Public Speaking Evaluation API"
+    
+    # Redis Configuration
+    REDIS_URL: str = "redis://localhost:6379"
+    
+    # Processing Configuration
+    MAX_VIDEO_SIZE_MB: int = 50
+    MAX_VIDEO_DURATION_SECONDS: int = 60
+    TEMP_DIR: str = "./temp"
+    MODELS_DIR: str = "./models"
+    
+    # Task Configuration
+    TASK_TIMEOUT_SECONDS: int = 300
+    TASK_RESULT_TTL_SECONDS: int = 3600  # 1 hour
+    TASK_QUEUE_NAME: str = "swara:tasks"
+    
+    # Rate Limiting
+    RATE_LIMIT_REQUESTS: int = 10
+    RATE_LIMIT_PERIOD_SECONDS: int = 3600
+    
+    # Logging
+    LOG_LEVEL: str = "INFO"
+    
+    # Model Paths
+    FACIAL_EXPRESSION_MODEL: str = "models/best.onnx"
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+    
+    def get_temp_dir(self) -> Path:
+        """Get temporary directory path"""
+        path = Path(self.TEMP_DIR)
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+    
+    def get_models_dir(self) -> Path:
+        """Get models directory path"""
+        path = Path(self.MODELS_DIR)
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+    
+    @property
+    def max_video_size_bytes(self) -> int:
+        """Get max video size in bytes"""
+        return self.MAX_VIDEO_SIZE_MB * 1024 * 1024
+
+
+@lru_cache()
+def get_settings() -> Settings:
+    """Get cached settings instance"""
+    return Settings()
+
+
+# Global settings instance
+settings = get_settings()

app/core/__init__.py

@@ -0,0 +1,3 @@
+"""
+Core module initialization
+"""

app/core/redis_client.py

@@ -0,0 +1,107 @@
+"""
+Redis Client Manager
+"""
+import redis
+from typing import Optional
+from loguru import logger
+from app.config import settings
+
+
+class RedisClient:
+    """Redis client wrapper with connection pooling"""
+    
+    def __init__(self):
+        self._client: Optional[redis.Redis] = None
+        self._connection_pool: Optional[redis.ConnectionPool] = None
+    
+    def connect(self) -> redis.Redis:
+        """Establish Redis connection"""
+        if self._client is None:
+            try:
+                logger.info(f"Connecting to Redis at {settings.REDIS_URL}")
+                
+                self._connection_pool = redis.ConnectionPool.from_url(
+                    settings.REDIS_URL,
+                    decode_responses=True,
+                    max_connections=10
+                )
+                
+                self._client = redis.Redis(connection_pool=self._connection_pool)
+                
+                # Test connection
+                self._client.ping()
+                logger.info("✓ Redis connected successfully")
+                
+            except Exception as e:
+                logger.error(f"✗ Failed to connect to Redis: {e}")
+                raise
+        
+        return self._client
+    
+    def disconnect(self):
+        """Close Redis connection"""
+        if self._client:
+            self._client.close()
+            self._client = None
+            logger.info("Redis connection closed")
+    
+    def get_client(self) -> redis.Redis:
+        """Get Redis client instance"""
+        if self._client is None:
+            self.connect()
+        return self._client
+    
+    def is_connected(self) -> bool:
+        """Check if Redis is connected"""
+        try:
+            if self._client:
+                self._client.ping()
+                return True
+        except:
+            pass
+        return False
+    
+    def set_with_ttl(self, key: str, value: str, ttl: int) -> bool:
+        """Set key with TTL (Time To Live)"""
+        try:
+            client = self.get_client()
+            return client.setex(key, ttl, value)
+        except Exception as e:
+            logger.error(f"Error setting key {key}: {e}")
+            return False
+    
+    def get(self, key: str) -> Optional[str]:
+        """Get value by key"""
+        try:
+            client = self.get_client()
+            return client.get(key)
+        except Exception as e:
+            logger.error(f"Error getting key {key}: {e}")
+            return None
+    
+    def delete(self, key: str) -> bool:
+        """Delete key"""
+        try:
+            client = self.get_client()
+            return bool(client.delete(key))
+        except Exception as e:
+            logger.error(f"Error deleting key {key}: {e}")
+            return False
+    
+    def exists(self, key: str) -> bool:
+        """Check if key exists"""
+        try:
+            client = self.get_client()
+            return bool(client.exists(key))
+        except Exception as e:
+            logger.error(f"Error checking key {key}: {e}")
+            return False
+
+
+# Global Redis client instance
+redis_client = RedisClient()
+
+
+def get_redis_client() -> RedisClient:
+    """Get global Redis client instance"""
+    return redis_client

app/core/storage.py

@@ -0,0 +1,113 @@
+"""
+Storage Manager for Video Files
+"""
+import os
+import uuid
+import aiofiles
+from pathlib import Path
+from typing import Optional
+from datetime import datetime, timedelta
+from loguru import logger
+from app.config import settings
+
+
+class StorageManager:
+    """Manage video file storage and cleanup"""
+    
+    def __init__(self):
+        self.temp_dir = settings.get_temp_dir()
+    
+    async def save_video(self, file_content: bytes, extension: str = "mp4") -> str:
+        """
+        Save uploaded video to temporary storage
+        
+        Args:
+            file_content: Video file bytes
+            extension: File extension (default: mp4)
+        
+        Returns:
+            str: Saved file path
+        """
+        # Generate unique filename
+        file_id = uuid.uuid4().hex
+        filename = f"{file_id}.{extension}"
+        file_path = self.temp_dir / filename
+        
+        try:
+            # Save file asynchronously
+            async with aiofiles.open(file_path, 'wb') as f:
+                await f.write(file_content)
+            
+            logger.info(f"✓ Video saved: {file_path} ({len(file_content)} bytes)")
+            return str(file_path)
+            
+        except Exception as e:
+            logger.error(f"✗ Failed to save video: {e}")
+            raise
+    
+    def delete_video(self, file_path: str) -> bool:
+        """
+        Delete video file
+        
+        Args:
+            file_path: Path to video file
+        
+        Returns:
+            bool: True if deleted successfully
+        """
+        try:
+            path = Path(file_path)
+            if path.exists():
+                path.unlink()
+                logger.info(f"✓ Video deleted: {file_path}")
+                return True
+            else:
+                logger.warning(f"⚠ Video not found: {file_path}")
+                return False
+        except Exception as e:
+            logger.error(f"✗ Failed to delete video: {e}")
+            return False
+    
+    def cleanup_old_files(self, hours: int = 2):
+        """
+        Delete files older than specified hours
+        
+        Args:
+            hours: Age threshold in hours
+        """
+        try:
+            threshold = datetime.now() - timedelta(hours=hours)
+            deleted_count = 0
+            
+            for file_path in self.temp_dir.glob("*.*"):
+                if file_path.is_file():
+                    file_time = datetime.fromtimestamp(file_path.stat().st_mtime)
+                    if file_time < threshold:
+                        file_path.unlink()
+                        deleted_count += 1
+            
+            if deleted_count > 0:
+                logger.info(f"✓ Cleaned up {deleted_count} old files")
+        
+        except Exception as e:
+            logger.error(f"✗ Failed to cleanup old files: {e}")
+    
+    def get_file_size(self, file_path: str) -> Optional[int]:
+        """Get file size in bytes"""
+        try:
+            return Path(file_path).stat().st_size
+        except:
+            return None
+    
+    def file_exists(self, file_path: str) -> bool:
+        """Check if file exists"""
+        return Path(file_path).exists()
+
+
+# Global storage manager instance
+storage_manager = StorageManager()
+
+
+def get_storage_manager() -> StorageManager:
+    """Get global storage manager instance"""
+    return storage_manager

app/main.py

@@ -0,0 +1,131 @@
+"""
+FastAPI Main Application
+"""
+import sys
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from loguru import logger
+
+from app.config import settings
+from app.core.redis_client import get_redis_client
+from app.api.routes import router
+
+
+# Configure logging
+logger.remove()
+logger.add(
+    sys.stdout,
+    format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan> - <level>{message}</level>",
+    level=settings.LOG_LEVEL
+)
+logger.add(
+    "logs/swara_api_{time:YYYY-MM-DD}.log",
+    rotation="1 day",
+    retention="7 days",
+    format="{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function} - {message}",
+    level=settings.LOG_LEVEL
+)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    Application lifespan events
+    """
+    # Startup
+    logger.info("=" * 70)
+    logger.info("🚀 SWARA API Starting...")
+    logger.info("=" * 70)
+    logger.info(f"Environment: {settings.ENV}")
+    logger.info(f"API Version: {settings.API_VERSION}")
+    logger.info(f"Redis URL: {settings.REDIS_URL}")
+    
+    # Connect to Redis
+    try:
+        redis_client = get_redis_client()
+        redis_client.connect()
+        logger.info("✓ Redis connection established")
+    except Exception as e:
+        logger.error(f"✗ Failed to connect to Redis: {e}")
+        logger.warning("⚠ API will start but background tasks will not work")
+    
+    # Create necessary directories
+    settings.get_temp_dir()
+    settings.get_models_dir()
+    logger.info("✓ Directories created")
+    
+    logger.info("=" * 70)
+    logger.info(f"✓ SWARA API Ready at http://{settings.API_HOST}:{settings.API_PORT}")
+    logger.info("=" * 70)
+    
+    yield
+    
+    # Shutdown
+    logger.info("=" * 70)
+    logger.info("🛑 SWARA API Shutting down...")
+    logger.info("=" * 70)
+    
+    # Disconnect from Redis
+    try:
+        redis_client = get_redis_client()
+        redis_client.disconnect()
+        logger.info("✓ Redis disconnected")
+    except:
+        pass
+    
+    logger.info("✓ Shutdown complete")
+    logger.info("=" * 70)
+
+
+# Create FastAPI application
+app = FastAPI(
+    title=settings.API_TITLE,
+    version=settings.API_VERSION,
+    description=settings.API_DESCRIPTION,
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json"
+)
+
+
+# CORS Middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify allowed origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Include routers
+app.include_router(router)
+
+
+# Global exception handler
+@app.exception_handler(Exception)
+async def global_exception_handler(request, exc):
+    """Global exception handler"""
+    logger.error(f"Unhandled exception: {exc}")
+    return JSONResponse(
+        status_code=500,
+        content={
+            "error": "Internal server error",
+            "detail": str(exc) if settings.ENV == "development" else "An unexpected error occurred"
+        }
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    uvicorn.run(
+        "app.main:app",
+        host=settings.API_HOST,
+        port=settings.API_PORT,
+        reload=settings.ENV == "development",
+        workers=settings.API_WORKERS
+    )

app/models.py

@@ -0,0 +1,115 @@
+"""
+Pydantic Models for Request/Response
+"""
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+from enum import Enum
+from pydantic import BaseModel, Field, validator
+
+
+class TaskStatus(str, Enum):
+    """Task status enum"""
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class Level(int, Enum):
+    """Public speaking level enum"""
+    LEVEL_1 = 1
+    LEVEL_2 = 2
+    LEVEL_3 = 3
+    LEVEL_4 = 4
+    LEVEL_5 = 5
+
+
+class VideoUploadRequest(BaseModel):
+    """Video upload request model"""
+    level: Level = Field(..., description="Public speaking level (1-5)")
+    user_id: Optional[str] = Field(None, description="Optional user ID for tracking")
+
+
+class TaskCreateResponse(BaseModel):
+    """Task creation response"""
+    task_id: str = Field(..., description="Unique task identifier")
+    status: TaskStatus = Field(default=TaskStatus.PENDING)
+    message: str = Field(default="Task created successfully")
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+
+
+class TaskProgress(BaseModel):
+    """Task progress information"""
+    current_step: str = Field(..., description="Current processing step")
+    percentage: float = Field(..., ge=0, le=100, description="Progress percentage")
+    message: str = Field(..., description="Progress message")
+
+
+class IndicatorResult(BaseModel):
+    """Individual indicator result"""
+    score: Optional[float] = Field(None, description="Indicator score")
+    raw_data: Dict[str, Any] = Field(default_factory=dict, description="Raw analysis data")
+    detected: Optional[bool] = Field(None, description="Detection status (for boolean indicators)")
+
+
+class MainIndicators(BaseModel):
+    """Main indicators for scoring"""
+    tempo: Optional[IndicatorResult] = None
+    artikulasi: Optional[IndicatorResult] = None
+    kontak_mata: Optional[IndicatorResult] = None
+    kesesuaian_topik: Optional[IndicatorResult] = None
+    struktur_kalimat: Optional[IndicatorResult] = None
+
+
+class BonusIndicators(BaseModel):
+    """Bonus indicators for additional points"""
+    jeda: Optional[IndicatorResult] = None
+    first_impression: Optional[IndicatorResult] = None
+    face_expression: Optional[IndicatorResult] = None
+    gesture: Optional[IndicatorResult] = None
+    kata_pengisi: Optional[IndicatorResult] = None
+    kata_tidak_senonoh: Optional[IndicatorResult] = None
+
+
+class VideoMetadata(BaseModel):
+    """Video metadata information"""
+    duration: float = Field(..., description="Video duration in seconds")
+    fps: int = Field(..., description="Frames per second")
+    resolution: str = Field(..., description="Video resolution (e.g., '1920x1080')")
+    file_size: int = Field(..., description="File size in bytes")
+
+
+class AnalysisResult(BaseModel):
+    """Complete analysis result"""
+    level: Level = Field(..., description="Evaluated level")
+    video_metadata: VideoMetadata
+    main_indicators: MainIndicators
+    bonus_indicators: BonusIndicators
+    processing_time: float = Field(..., description="Total processing time in seconds")
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+
+
+class TaskStatusResponse(BaseModel):
+    """Task status response"""
+    task_id: str
+    status: TaskStatus
+    progress: Optional[TaskProgress] = None
+    result: Optional[AnalysisResult] = None
+    error: Optional[str] = None
+    created_at: datetime
+    completed_at: Optional[datetime] = None
+
+
+class HealthResponse(BaseModel):
+    """Health check response"""
+    status: str = Field(default="healthy")
+    version: str = Field(default="1.0.0")
+    redis_connected: bool
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+
+
+class ErrorResponse(BaseModel):
+    """Error response model"""
+    error: str = Field(..., description="Error message")
+    detail: Optional[str] = Field(None, description="Detailed error information")
+    timestamp: datetime = Field(default_factory=datetime.utcnow)

app/services/__init__.py

@@ -0,0 +1,3 @@
+"""
+Services module initialization
+"""

app/services/eye_tracking.py

@@ -0,0 +1,894 @@
+"""
+Eye Tracking Service
+
+Refactored from eye_tracking_production.py for production use.
+Production-ready eye tracking untuk website SWARA
+"""
+import cv2 as cv
+import math
+import numpy as np
+import mediapipe as mp
+from datetime import datetime
+from typing import Dict, List, Tuple, Optional, Any
+from loguru import logger
+
+from app.config import settings
+
+
+class EyeTrackingConfig:
+    """Configuration class untuk eye tracking parameters"""
+
+    # MediaPipe landmarks indices
+    LEFT_EYE = [362, 382, 381, 380, 374, 373, 390, 249, 263, 466, 388, 387, 386, 385, 384, 398]
+    RIGHT_EYE = [33, 7, 163, 144, 145, 153, 154, 155, 133, 173, 157, 158, 159, 160, 161, 246]
+
+    # Eye size classification thresholds
+    SMALL_EYE_THRESHOLD = 600
+    MEDIUM_EYE_THRESHOLD = 1500
+
+    # Position boundaries (optimized)
+    LEFT_BOUNDARY = 0.35
+    RIGHT_BOUNDARY = 0.65
+
+    # Temporal smoothing zone
+    SMOOTHING_LEFT_MIN = 0.33
+    SMOOTHING_LEFT_MAX = 0.37
+    SMOOTHING_RIGHT_MIN = 0.63
+    SMOOTHING_RIGHT_MAX = 0.67
+
+    # Blink ratio threshold
+    BLINK_THRESHOLD = 5.5
+
+    # Score thresholds (dalam detik)
+    SCORE_THRESHOLDS = {
+        5: (5, "Sangat Baik"),
+        4: (8, "Baik"),
+        3: (10, "Cukup Baik"),
+        2: (12, "Buruk"),
+        1: (float('inf'), "Perlu Ditingkatkan")
+    }
+
+    # Adaptive parameters by eye size
+    ADAPTIVE_PARAMS = {
+        'SMALL': {
+            'scale_factor': 3.0,
+            'interpolation': cv.INTER_LANCZOS4,
+            'clahe_clip': 4.0,
+            'clahe_grid': (4, 4),
+            'bilateral_d': 7,
+            'bilateral_sigma': 75,
+            'thresholds': [20, 25, 30, 35, 40, 45, 50, 55],
+            'min_area_ratio': 0.001,
+            'max_area_ratio': 0.50,
+            'min_circularity': 0.3,
+            'min_solidity': 0.5,
+            'morph_kernel': 5,
+            'morph_close_iter': 3,
+            'morph_open_iter': 2
+        },
+        'MEDIUM': {
+            'scale_factor': 2.0,
+            'interpolation': cv.INTER_CUBIC,
+            'clahe_clip': 3.0,
+            'clahe_grid': (8, 8),
+            'bilateral_d': 5,
+            'bilateral_sigma': 50,
+            'thresholds': [30, 35, 40, 45, 50, 55, 60],
+            'min_area_ratio': 0.005,
+            'max_area_ratio': 0.45,
+            'min_circularity': 0.4,
+            'min_solidity': 0.6,
+            'morph_kernel': 3,
+            'morph_close_iter': 2,
+            'morph_open_iter': 1
+        },
+        'LARGE': {
+            'scale_factor': 1.5,
+            'interpolation': cv.INTER_CUBIC,
+            'clahe_clip': 2.0,
+            'clahe_grid': (8, 8),
+            'bilateral_d': 3,
+            'bilateral_sigma': 30,
+            'thresholds': [35, 40, 45, 50, 55, 60, 65],
+            'min_area_ratio': 0.01,
+            'max_area_ratio': 0.40,
+            'min_circularity': 0.5,
+            'min_solidity': 0.7,
+            'morph_kernel': 3,
+            'morph_close_iter': 2,
+            'morph_open_iter': 1
+        }
+    }
+
+
+class EyeTracker:
+    """Main class untuk eye tracking"""
+
+    def __init__(self, config: EyeTrackingConfig = None):
+        self.config = config or EyeTrackingConfig()
+        self.face_mesh = mp.solutions.face_mesh.FaceMesh(
+            min_detection_confidence=0.5,
+            min_tracking_confidence=0.5
+        )
+        self.prev_position_right = None
+        self.prev_position_left = None
+
+    def __del__(self):
+        """Cleanup resources"""
+        if hasattr(self, 'face_mesh') and self.face_mesh:
+            self.face_mesh.close()
+
+    @staticmethod
+    def euclidean_distance(point1: Tuple[int, int], point2: Tuple[int, int]) -> float:
+        """Calculate Euclidean distance between two points"""
+        return math.sqrt((point2[0] - point1[0])**2 + (point2[1] - point1[1])**2)
+
+    def detect_landmarks(self, frame: np.ndarray) -> Optional[List[Tuple[int, int]]]:
+        """Detect facial landmarks"""
+        try:
+            rgb_frame = cv.cvtColor(frame, cv.COLOR_BGR2RGB)
+            results = self.face_mesh.process(rgb_frame)
+
+            if not results.multi_face_landmarks:
+                return None
+
+            img_height, img_width = frame.shape[:2]
+            mesh_coords = [
+                (int(point.x * img_width), int(point.y * img_height))
+                for point in results.multi_face_landmarks[0].landmark
+            ]
+            return mesh_coords
+        except Exception as e:
+            logger.error(f"Error detecting landmarks: {e}")
+            return None
+
+    def calculate_blink_ratio(self, landmarks: List[Tuple[int, int]]) -> float:
+        """Calculate blink ratio from eye landmarks"""
+        try:
+            # Right eye
+            rh_distance = self.euclidean_distance(
+                landmarks[self.config.RIGHT_EYE[0]],
+                landmarks[self.config.RIGHT_EYE[8]]
+            )
+            rv_distance = self.euclidean_distance(
+                landmarks[self.config.RIGHT_EYE[12]],
+                landmarks[self.config.RIGHT_EYE[4]]
+            )
+
+            # Left eye
+            lh_distance = self.euclidean_distance(
+                landmarks[self.config.LEFT_EYE[0]],
+                landmarks[self.config.LEFT_EYE[8]]
+            )
+            lv_distance = self.euclidean_distance(
+                landmarks[self.config.LEFT_EYE[12]],
+                landmarks[self.config.LEFT_EYE[4]]
+            )
+
+            if rv_distance == 0 or lv_distance == 0:
+                return 0
+
+            re_ratio = rh_distance / rv_distance
+            le_ratio = lh_distance / lv_distance
+            ratio = (re_ratio + le_ratio) / 2
+
+            return ratio
+        except Exception as e:
+            logger.error(f"Error calculating blink ratio: {e}")
+            return 0
+
+    def extract_eye_region(self, frame: np.ndarray, eye_coords: List[Tuple[int, int]]) -> Optional[np.ndarray]:
+        """Extract and crop eye region from frame"""
+        try:
+            gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+            mask = np.zeros(gray.shape, dtype=np.uint8)
+
+            cv.fillPoly(mask, [np.array(eye_coords, dtype=np.int32)], 255)
+            eye = cv.bitwise_and(gray, gray, mask=mask)
+            eye[mask == 0] = 155
+
+            # Get bounding box
+            x_coords = [coord[0] for coord in eye_coords]
+            y_coords = [coord[1] for coord in eye_coords]
+
+            min_x, max_x = min(x_coords), max(x_coords)
+            min_y, max_y = min(y_coords), max(y_coords)
+
+            cropped = eye[min_y:max_y, min_x:max_x]
+            return cropped if cropped.size > 0 else None
+        except Exception as e:
+            logger.error(f"Error extracting eye region: {e}")
+            return None
+
+    def classify_eye_size(self, eye_region: np.ndarray) -> str:
+        """Classify eye size (SMALL/MEDIUM/LARGE)"""
+        if eye_region is None or eye_region.size == 0:
+            return 'UNKNOWN'
+
+        h, w = eye_region.shape
+        area = h * w
+
+        if area < self.config.SMALL_EYE_THRESHOLD:
+            return 'SMALL'
+        elif area < self.config.MEDIUM_EYE_THRESHOLD:
+            return 'MEDIUM'
+        else:
+            return 'LARGE'
+
+    def adaptive_preprocessing(self, eye_region: np.ndarray, eye_size: str) -> Optional[np.ndarray]:
+        """
+        Adaptive preprocessing: upscale + enhancement berdasarkan ukuran mata
+        """
+        if eye_region is None or eye_region.size == 0:
+            return None
+        
+        try:
+            params = self.config.ADAPTIVE_PARAMS[eye_size]
+            scale_factor = params['scale_factor']
+            
+            # Adaptive upscaling based on eye size
+            if eye_size == 'SMALL':
+                interpolation = cv.INTER_LANCZOS4
+            else:
+                interpolation = cv.INTER_CUBIC
+            
+            upscaled = cv.resize(
+                eye_region, None,
+                fx=scale_factor, fy=scale_factor,
+                interpolation=interpolation
+            )
+            
+            # Adaptive enhancement based on eye size
+            if eye_size == 'SMALL':
+                # Aggressive enhancement for small eyes
+                clahe = cv.createCLAHE(clipLimit=4.0, tileGridSize=(4,4))
+                enhanced = clahe.apply(upscaled)
+                enhanced = cv.bilateralFilter(enhanced, 7, 75, 75)
+                
+                # Unsharp mask untuk detail
+                gaussian = cv.GaussianBlur(enhanced, (3, 3), 2.0)
+                enhanced = cv.addWeighted(enhanced, 1.5, gaussian, -0.5, 0)
+                enhanced = np.clip(enhanced, 0, 255).astype(np.uint8)
+                
+            elif eye_size == 'MEDIUM':
+                clahe = cv.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
+                enhanced = clahe.apply(upscaled)
+                enhanced = cv.bilateralFilter(enhanced, 5, 50, 50)
+                
+            else:  # LARGE
+                clahe = cv.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+                enhanced = clahe.apply(upscaled)
+                enhanced = cv.bilateralFilter(enhanced, 3, 30, 30)
+            
+            return enhanced
+            
+        except Exception as e:
+            logger.error(f"Error in adaptive preprocessing: {e}")
+            return None
+
+    def aggressive_morphology(self, mask: np.ndarray, eye_size: str) -> np.ndarray:
+        """
+        STAGE 1: Aggressive morphology untuk solid contour
+        Mengatasi masalah kontour terpecah-pecah
+        """
+        params = self.config.ADAPTIVE_PARAMS[eye_size]
+        kernel = cv.getStructuringElement(
+            cv.MORPH_ELLIPSE,
+            (params['morph_kernel'], params['morph_kernel'])
+        )
+
+        # Close gaps - menggabungkan fragmen yang terpisah
+        mask = cv.morphologyEx(
+            mask, cv.MORPH_CLOSE, kernel,
+            iterations=params['morph_close_iter']
+        )
+
+        # Remove noise
+        mask = cv.morphologyEx(
+            mask, cv.MORPH_OPEN, kernel,
+            iterations=params['morph_open_iter']
+        )
+
+        # Fill holes untuk SMALL eyes
+        if eye_size == 'SMALL':
+            kernel_dilate = cv.getStructuringElement(cv.MORPH_ELLIPSE, (3, 3))
+            mask = cv.dilate(mask, kernel_dilate, iterations=1)
+
+        return mask
+
+    def connected_components_analysis(self, mask: np.ndarray, params: Dict) -> Optional[Dict]:
+        """
+        STAGE 2: Connected Components Analysis untuk filtering blob yang lebih akurat
+        Mengatasi false positives dari noise
+        """
+        h, w = mask.shape
+        min_area = (h * w) * params['min_area_ratio']
+        max_area = (h * w) * params['max_area_ratio']
+
+        # Connected components with stats
+        num_labels, labels, stats, centroids = cv.connectedComponentsWithStats(
+            mask, connectivity=8
+        )
+
+        candidates = []
+
+        for i in range(1, num_labels):  # Skip background (label 0)
+            area = stats[i, cv.CC_STAT_AREA]
+
+            # Filter by area
+            if area < min_area or area > max_area:
+                continue
+
+            # Create component mask
+            component_mask = np.zeros_like(mask)
+            component_mask[labels == i] = 255
+
+            # Calculate properties
+            contours, _ = cv.findContours(
+                component_mask, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE
+            )
+
+            if not contours:
+                continue
+
+            contour = contours[0]
+
+            # Circularity
+            perimeter = cv.arcLength(contour, True)
+            if perimeter == 0:
+                continue
+            circularity = 4 * np.pi * area / (perimeter ** 2)
+
+            if circularity < params['min_circularity']:
+                continue
+
+            # Solidity (area / convex hull area) - filter irregular shapes
+            hull = cv.convexHull(contour)
+            hull_area = cv.contourArea(hull)
+            if hull_area == 0:
+                continue
+            solidity = area / hull_area
+
+            if solidity < params['min_solidity']:
+                continue
+
+            # Distance from center (prefer pupil near center)
+            center_x = w / 2
+            cx = centroids[i][0]
+            distance_from_center = abs(cx - center_x) / w
+            center_score = 1.0 - distance_from_center
+
+            # Aspect ratio (prefer circular)
+            x, y, w_bbox, h_bbox = (stats[i, cv.CC_STAT_LEFT], 
+                                     stats[i, cv.CC_STAT_TOP],
+                                     stats[i, cv.CC_STAT_WIDTH], 
+                                     stats[i, cv.CC_STAT_HEIGHT])
+            if h_bbox == 0:
+                continue
+            aspect_ratio = w_bbox / h_bbox
+            aspect_score = 1.0 - abs(aspect_ratio - 1.0)
+
+            # Combined score (COLAB METHOD: multiplicative)
+            # Mengutamakan kandidat dengan SEMUA metrik bagus
+            score = area * circularity * solidity * center_score * aspect_score
+
+            candidates.append({
+                'mask': component_mask,
+                'contour': contour,
+                'centroid': centroids[i],
+                'area': area,
+                'circularity': circularity,
+                'solidity': solidity,
+                'center_score': center_score,
+                'aspect_ratio': aspect_ratio,
+                'score': score
+            })
+
+        if not candidates:
+            return None
+
+        return max(candidates, key=lambda x: x['score'])
+
+    def distance_transform_refinement(self, mask: np.ndarray) -> Tuple[int, int]:
+        """
+        STAGE 3: Distance Transform untuk memperbaiki centroid
+        Memberikan posisi yang lebih akurat dibanding moment
+        """
+        dist_transform = cv.distanceTransform(mask, cv.DIST_L2, 5)
+        _, _, _, max_loc = cv.minMaxLoc(dist_transform)
+        return max_loc
+
+    def detect_pupil(self, enhanced: np.ndarray, eye_size: str) -> Optional[Dict]:
+        """
+        Detect pupil using multi-stage OPTIMIZED pipeline
+        
+        OPTIMIZATIONS dari Colab:
+        1. Aggressive Morphology - solid contour, no fragments
+        2. Connected Components Analysis - better blob detection  
+        3. Distance Transform - accurate centroid
+        4. Solidity Filter - reject irregular shapes
+        """
+        params = self.config.ADAPTIVE_PARAMS[eye_size]
+        h, w = enhanced.shape
+
+        best_candidate = None
+        best_score = 0
+        best_threshold = 0
+
+        for thresh_val in params['thresholds']:
+            _, binary = cv.threshold(enhanced, thresh_val, 255, cv.THRESH_BINARY_INV)
+            
+            # STAGE 1: Aggressive Morphology
+            binary = self.aggressive_morphology(binary, eye_size)
+            
+            # STAGE 2: Connected Components Analysis
+            candidate = self.connected_components_analysis(binary, params)
+
+            if candidate and candidate['score'] > best_score:
+                best_candidate = candidate
+                best_score = candidate['score']
+                best_threshold = thresh_val
+
+        if not best_candidate:
+            return None
+
+        # STAGE 3: Distance transform refinement
+        dt_center = self.distance_transform_refinement(best_candidate['mask'])
+        best_candidate['dt_center'] = dt_center
+        best_candidate['threshold'] = best_threshold
+
+        return best_candidate
+
+    def determine_gaze_position(self, centroid_x: int, width: int, prev_position: Optional[str]) -> str:
+        """Determine gaze position (LEFT/CENTER/RIGHT)"""
+        ratio = centroid_x / width
+
+        # Base position
+        if ratio < self.config.LEFT_BOUNDARY:
+            position = "LEFT"
+        elif ratio > self.config.RIGHT_BOUNDARY:
+            position = "RIGHT"
+        else:
+            position = "CENTER"
+
+        # Temporal smoothing
+        if prev_position and prev_position != "UNKNOWN":
+            if position == "LEFT" and self.config.SMOOTHING_LEFT_MIN < ratio < self.config.SMOOTHING_LEFT_MAX:
+                position = prev_position
+            elif position == "RIGHT" and self.config.SMOOTHING_RIGHT_MIN < ratio < self.config.SMOOTHING_RIGHT_MAX:
+                position = prev_position
+            elif position == "CENTER" and prev_position != "CENTER":
+                if ratio < self.config.SMOOTHING_LEFT_MAX or ratio > self.config.SMOOTHING_RIGHT_MIN:
+                    position = prev_position
+
+        return position
+
+    def estimate_eye_position(self, eye_region: np.ndarray, prev_position: Optional[str] = None) -> Tuple[str, Dict]:
+        """
+        Estimate eye gaze position using OPTIMIZED METHOD
+        
+        Priority untuk centroid: Distance Transform > Ellipse > Connected Components
+        """
+        if eye_region is None or eye_region.size == 0:
+            return "UNKNOWN", {}
+
+        h, w = eye_region.shape
+        if h < 5 or w < 10:
+            return "UNKNOWN", {}
+
+        try:
+            eye_size = self.classify_eye_size(eye_region)
+            enhanced = self.adaptive_preprocessing(eye_region, eye_size)
+
+            if enhanced is None:
+                return "UNKNOWN", {}
+
+            pupil_data = self.detect_pupil(enhanced, eye_size)
+
+            if not pupil_data:
+                return "UNKNOWN", {}
+
+            # OPTIMIZED: Use Distance Transform center (most accurate)
+            scale_factor = self.config.ADAPTIVE_PARAMS[eye_size]['scale_factor']
+            cx_dt, cy_dt = pupil_data['dt_center']
+            
+            # Scale back to original size
+            centroid_x = int(cx_dt / scale_factor)
+            
+            # Determine position
+            position = self.determine_gaze_position(centroid_x, w, prev_position)
+
+            return position, {
+                'eye_size': eye_size,
+                'centroid': (centroid_x, int(cy_dt / scale_factor)),
+                'circularity': pupil_data['circularity'],
+                'solidity': pupil_data['solidity'],
+                'dt_center': pupil_data['dt_center'],
+                'threshold': pupil_data['threshold']
+            }
+
+        except Exception as e:
+            logger.error(f"Error estimating eye position: {e}")
+            return "UNKNOWN", {}
+
+    def process_frame(self, frame: np.ndarray) -> Dict:
+        """Process single frame and return analysis"""
+        result = {
+            'face_detected': False,
+            'blink_detected': False,
+            'blink_ratio': 0.0,
+            'right_eye': {'position': 'UNKNOWN', 'data': {}},
+            'left_eye': {'position': 'UNKNOWN', 'data': {}},
+            'gaze_position': 'UNKNOWN'
+        }
+
+        try:
+            landmarks = self.detect_landmarks(frame)
+
+            if landmarks is None:
+                return result
+
+            result['face_detected'] = True
+
+            # Blink detection
+            blink_ratio = self.calculate_blink_ratio(landmarks)
+            result['blink_ratio'] = round(blink_ratio, 2)
+            result['blink_detected'] = blink_ratio > self.config.BLINK_THRESHOLD
+
+            if not result['blink_detected']:
+                # Right eye
+                right_eye_coords = [landmarks[i] for i in self.config.RIGHT_EYE]
+                right_eye_region = self.extract_eye_region(frame, right_eye_coords)
+
+                if right_eye_region is not None:
+                    right_position, right_data = self.estimate_eye_position(
+                        right_eye_region, self.prev_position_right
+                    )
+                    result['right_eye'] = {'position': right_position, 'data': right_data}
+                    self.prev_position_right = right_position
+
+                # Left eye
+                left_eye_coords = [landmarks[i] for i in self.config.LEFT_EYE]
+                left_eye_region = self.extract_eye_region(frame, left_eye_coords)
+
+                if left_eye_region is not None:
+                    left_position, left_data = self.estimate_eye_position(
+                        left_eye_region, self.prev_position_left
+                    )
+                    result['left_eye'] = {'position': left_position, 'data': left_data}
+                    self.prev_position_left = left_position
+
+                # Determine overall gaze
+                if result['right_eye']['position'] == result['left_eye']['position']:
+                    result['gaze_position'] = result['right_eye']['position']
+                elif result['right_eye']['position'] == 'UNKNOWN':
+                    result['gaze_position'] = result['left_eye']['position']
+                elif result['left_eye']['position'] == 'UNKNOWN':
+                    result['gaze_position'] = result['right_eye']['position']
+                else:
+                    result['gaze_position'] = result['right_eye']['position']
+
+        except Exception as e:
+            logger.error(f"Error processing frame: {e}")
+
+        return result
+
+
+class EyeTrackingService:
+    """
+    Eye Tracking Service for SWARA API
+    
+    Analyzes eye contact and gaze patterns in videos
+    """
+    
+    # Class variable for singleton pattern
+    _tracker = None
+    
+    def __init__(self):
+        """Initialize service"""
+        if EyeTrackingService._tracker is None:
+            logger.info("Initializing Eye Tracking Service...")
+            EyeTrackingService._tracker = EyeTracker()
+            logger.info("✓ Eye Tracking Service initialized")
+    
+    def calculate_score(self, gaze_away_time: float) -> Tuple[int, str]:
+        """Calculate score based on gaze away time"""
+        config = EyeTrackingConfig()
+        for score, (threshold, rating) in sorted(
+            config.SCORE_THRESHOLDS.items(), reverse=True
+        ):
+            if gaze_away_time <= threshold:
+                return score, rating
+        return 1, "Perlu Ditingkatkan"
+    
+    def _annotate_frame(
+        self, 
+        frame: np.ndarray, 
+        result: Dict, 
+        frame_number: int,
+        total_blinks: int,
+        gaze_position: str
+    ) -> np.ndarray:
+        """
+        Annotate frame with eye tracking information
+        
+        Args:
+            frame: Original frame
+            result: Analysis result from process_frame
+            frame_number: Current frame number
+            total_blinks: Total blinks detected so far
+            gaze_position: Current gaze position
+        
+        Returns:
+            Annotated frame
+        """
+        annotated = frame.copy()
+        
+        # Define colors
+        COLOR_GREEN = (0, 255, 0)
+        COLOR_RED = (0, 0, 255)
+        COLOR_YELLOW = (0, 255, 255)
+        COLOR_BLUE = (255, 0, 0)
+        COLOR_WHITE = (255, 255, 255)
+        
+        # Semi-transparent overlay for info box
+        overlay = annotated.copy()
+        cv.rectangle(overlay, (10, 10), (400, 180), (0, 0, 0), -1)
+        cv.addWeighted(overlay, 0.6, annotated, 0.4, 0, annotated)
+        
+        # Frame info
+        cv.putText(annotated, f"Frame: {frame_number}", (20, 35),
+                  cv.FONT_HERSHEY_SIMPLEX, 0.6, COLOR_WHITE, 2)
+        
+        # Face detection status
+        face_status = "DETECTED" if result['face_detected'] else "NOT DETECTED"
+        face_color = COLOR_GREEN if result['face_detected'] else COLOR_RED
+        cv.putText(annotated, f"Face: {face_status}", (20, 60),
+                  cv.FONT_HERSHEY_SIMPLEX, 0.6, face_color, 2)
+        
+        # Blink info
+        blink_status = "BLINKING" if result['blink_detected'] else "OPEN"
+        blink_color = COLOR_YELLOW if result['blink_detected'] else COLOR_GREEN
+        cv.putText(annotated, f"Eyes: {blink_status} | Ratio: {result['blink_ratio']:.2f}", 
+                  (20, 85), cv.FONT_HERSHEY_SIMPLEX, 0.6, blink_color, 2)
+        cv.putText(annotated, f"Total Blinks: {total_blinks}", (20, 110),
+                  cv.FONT_HERSHEY_SIMPLEX, 0.6, COLOR_WHITE, 2)
+        
+        # Gaze position
+        if gaze_position == 'CENTER':
+            gaze_color = COLOR_GREEN
+        elif gaze_position in ['LEFT', 'RIGHT']:
+            gaze_color = COLOR_YELLOW
+        else:
+            gaze_color = COLOR_RED
+        
+        cv.putText(annotated, f"Gaze: {gaze_position}", (20, 135),
+                  cv.FONT_HERSHEY_SIMPLEX, 0.7, gaze_color, 2)
+        
+        # Eye positions
+        if result['face_detected'] and not result['blink_detected']:
+            left_pos = result['left_eye']['position']
+            right_pos = result['right_eye']['position']
+            cv.putText(annotated, f"L:{left_pos} | R:{right_pos}", (20, 160),
+                      cv.FONT_HERSHEY_SIMPLEX, 0.5, COLOR_BLUE, 2)
+        
+        # Gaze indicator (big display)
+        h, w = annotated.shape[:2]
+        indicator_y = h - 60
+        
+        # Draw gaze direction indicator
+        if gaze_position == 'CENTER':
+            cv.circle(annotated, (w // 2, indicator_y), 30, COLOR_GREEN, -1)
+            cv.putText(annotated, "CENTER", (w // 2 - 50, indicator_y + 10),
+                      cv.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 0), 2)
+        elif gaze_position == 'LEFT':
+            cv.arrowedLine(annotated, (w // 2, indicator_y), (w // 2 - 80, indicator_y),
+                          COLOR_YELLOW, 5, tipLength=0.3)
+            cv.putText(annotated, "LEFT", (w // 2 - 150, indicator_y + 10),
+                      cv.FONT_HERSHEY_SIMPLEX, 0.8, COLOR_YELLOW, 2)
+        elif gaze_position == 'RIGHT':
+            cv.arrowedLine(annotated, (w // 2, indicator_y), (w // 2 + 80, indicator_y),
+                          COLOR_YELLOW, 5, tipLength=0.3)
+            cv.putText(annotated, "RIGHT", (w // 2 + 50, indicator_y + 10),
+                      cv.FONT_HERSHEY_SIMPLEX, 0.8, COLOR_YELLOW, 2)
+        else:
+            cv.putText(annotated, "UNKNOWN", (w // 2 - 60, indicator_y + 10),
+                      cv.FONT_HERSHEY_SIMPLEX, 0.8, COLOR_RED, 2)
+        
+        return annotated
+    
+    def analyze_video(
+        self, 
+        video_path: str,
+        progress_callback: Optional[callable] = None,
+        save_annotated_video: bool = False,
+        output_path: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Analyze video for eye contact
+        
+        Args:
+            video_path: Path to video file
+            progress_callback: Optional callback for progress updates
+            save_annotated_video: Whether to save annotated video
+            output_path: Path for output video (default: 'output/eye_tracking_annotated.mp4')
+        
+        Returns:
+            Dict containing eye tracking analysis results
+        """
+        try:
+            logger.info(f"Analyzing video with Eye Tracking Service: {video_path}")
+            logger.info(f"Save annotated video: {save_annotated_video}")
+            
+            cap = cv.VideoCapture(video_path)
+            if not cap.isOpened():
+                raise ValueError(f"Cannot open video: {video_path}")
+            
+            # Video properties
+            fps = int(cap.get(cv.CAP_PROP_FPS)) or 30
+            width = int(cap.get(cv.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
+            total_frames = int(cap.get(cv.CAP_PROP_FRAME_COUNT))
+            
+            logger.info(f"Video properties: {width}x{height} @ {fps}FPS, {total_frames} frames")
+            logger.info(f"Video properties: {width}x{height} @ {fps}FPS, {total_frames} frames")
+            
+            # Setup video writer if needed
+            out = None
+            if save_annotated_video:
+                if output_path is None:
+                    import os
+                    os.makedirs('output', exist_ok=True)
+                    output_path = 'output/eye_tracking_annotated.mp4'
+                
+                fourcc = cv.VideoWriter_fourcc(*'mp4v')
+                out = cv.VideoWriter(output_path, fourcc, fps, (width, height))
+                logger.info(f"Output video will be saved to: {output_path}")
+            
+            # Initialize counters
+            frame_count = 0
+            gaze_away_frames = 0
+            blink_count = 0
+            position_counts = {'CENTER': 0, 'LEFT': 0, 'RIGHT': 0, 'UNKNOWN': 0}
+            
+            prev_blink = False
+            
+            # Debug counters
+            debug_stats = {
+                'face_detected_frames': 0,
+                'pupil_detected_frames': 0,
+                'center_gaze_frames': 0,
+                'left_gaze_frames': 0,
+                'right_gaze_frames': 0,
+                'unknown_frames': 0
+            }
+            
+            logger.info("Starting frame processing...")
+            
+            # Process frames
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                frame_count += 1
+                
+                # Progress callback
+                if progress_callback and frame_count % 30 == 0:
+                    progress = int((frame_count / total_frames) * 100)
+                    progress_callback(frame_count, total_frames, f"Eye tracking: {progress}%")
+                
+                # Process frame
+                result = self._tracker.process_frame(frame)
+                
+                # Debug stats
+                if result['face_detected']:
+                    debug_stats['face_detected_frames'] += 1
+                
+                # Count blinks
+                if result['blink_detected'] and not prev_blink:
+                    blink_count += 1
+                    logger.debug(f"Frame {frame_count}: Blink detected (total: {blink_count})")
+                prev_blink = result['blink_detected']
+                
+                # Track gaze position
+                gaze_pos = result['gaze_position']
+                position_counts[gaze_pos] = position_counts.get(gaze_pos, 0) + 1
+                
+                # Update debug stats
+                if gaze_pos == 'CENTER':
+                    debug_stats['center_gaze_frames'] += 1
+                elif gaze_pos == 'LEFT':
+                    debug_stats['left_gaze_frames'] += 1
+                elif gaze_pos == 'RIGHT':
+                    debug_stats['right_gaze_frames'] += 1
+                else:
+                    debug_stats['unknown_frames'] += 1
+                
+                # Count gaze away frames (not CENTER)
+                if gaze_pos != 'CENTER' and gaze_pos != 'UNKNOWN':
+                    gaze_away_frames += 1
+                
+                # Annotate frame if video output enabled
+                if save_annotated_video and out is not None:
+                    annotated_frame = self._annotate_frame(frame, result, frame_count, blink_count, gaze_pos)
+                    out.write(annotated_frame)
+                
+                # Log every 100 frames
+                if frame_count % 100 == 0:
+                    logger.info(f"Processed {frame_count}/{total_frames} frames | "
+                               f"Gaze: C:{debug_stats['center_gaze_frames']} "
+                               f"L:{debug_stats['left_gaze_frames']} "
+                               f"R:{debug_stats['right_gaze_frames']} | "
+                               f"Blinks: {blink_count}")
+            
+            cap.release()
+            if out is not None:
+                out.release()
+                logger.info(f"✓ Annotated video saved: {output_path}")
+            
+            # Calculate metrics
+            duration = frame_count / fps
+            gaze_away_time = gaze_away_frames / fps
+            score, rating = self.calculate_score(gaze_away_time)
+            
+            # Log summary statistics
+            logger.info("="*60)
+            logger.info("EYE TRACKING ANALYSIS SUMMARY")
+            logger.info("="*60)
+            logger.info(f"Total Frames Processed: {frame_count}")
+            logger.info(f"Face Detection Rate: {debug_stats['face_detected_frames']}/{frame_count} "
+                       f"({debug_stats['face_detected_frames']/frame_count*100:.1f}%)")
+            logger.info(f"\nGaze Distribution:")
+            logger.info(f"  CENTER: {debug_stats['center_gaze_frames']} frames "
+                       f"({debug_stats['center_gaze_frames']/frame_count*100:.1f}%)")
+            logger.info(f"  LEFT:   {debug_stats['left_gaze_frames']} frames "
+                       f"({debug_stats['left_gaze_frames']/frame_count*100:.1f}%)")
+            logger.info(f"  RIGHT:  {debug_stats['right_gaze_frames']} frames "
+                       f"({debug_stats['right_gaze_frames']/frame_count*100:.1f}%)")
+            logger.info(f"  UNKNOWN: {debug_stats['unknown_frames']} frames "
+                       f"({debug_stats['unknown_frames']/frame_count*100:.1f}%)")
+            logger.info(f"\nGaze Away Time: {gaze_away_time:.2f}s / {duration:.2f}s "
+                       f"({gaze_away_time/duration*100:.1f}%)")
+            logger.info(f"Total Blinks: {blink_count} ({blink_count/duration*60:.1f} blinks/minute)")
+            logger.info(f"\nFinal Score: {score}/5 - {rating}")
+            logger.info("="*60)
+            
+            # Build result
+            result = {
+                'success': True,
+                'video_info': {
+                    'duration': round(duration, 2),
+                    'fps': fps,
+                    'total_frames': frame_count,
+                    'resolution': f"{width}x{height}"
+                },
+                'eye_contact_analysis': {
+                    'total_gaze_away_time': round(gaze_away_time, 2),
+                    'gaze_away_percentage': round((gaze_away_time / duration) * 100, 2) if duration > 0 else 0,
+                    'score': score,
+                    'rating': rating,
+                    'position_distribution': {
+                        k: {
+                            'frames': v,
+                            'percentage': round((v / frame_count) * 100, 2) if frame_count > 0 else 0
+                        }
+                        for k, v in position_counts.items()
+                    }
+                },
+                'blink_analysis': {
+                    'total_blinks': blink_count,
+                    'blinks_per_minute': round((blink_count / duration) * 60, 2) if duration > 0 else 0
+                },
+                'debug_stats': debug_stats
+            }
+            
+            if save_annotated_video and output_path:
+                result['annotated_video_path'] = output_path
+            
+            logger.info(f"✓ Eye Tracking analysis completed: Score {score}/5 - {rating}")
+            return result
+        
+        except Exception as e:
+            logger.error(f"✗ Eye Tracking analysis failed: {e}")
+            raise

app/services/eye_tracking_production.py

@@ -0,0 +1,873 @@
+# -*- coding: utf-8 -*-
+"""eye-tracking-production.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/13Z0FJCvPUstAc77sypU_QJFfuDOycDDe
+"""
+
+!pip install mediapipe
+
+# ===== SWARA EYE TRACKING MODULE (PRODUCTION) =====
+# Production-ready eye tracking untuk website SWARA
+# Optimized untuk performa, error handling, dan integrasi
+# ====================================================
+
+import cv2 as cv
+import mediapipe as mp
+import numpy as np
+import math
+import json
+from datetime import datetime
+from typing import Dict, List, Tuple, Optional
+import logging
+
+# ===== SETUP LOGGING =====
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('SWARA_EyeTracking')
+
+
+class EyeTrackingConfig:
+    """Configuration class untuk eye tracking parameters"""
+
+    # MediaPipe landmarks indices
+    LEFT_EYE = [362, 382, 381, 380, 374, 373, 390, 249, 263, 466, 388, 387, 386, 385, 384, 398]
+    RIGHT_EYE = [33, 7, 163, 144, 145, 153, 154, 155, 133, 173, 157, 158, 159, 160, 161, 246]
+
+    # Eye size classification thresholds
+    SMALL_EYE_THRESHOLD = 600
+    MEDIUM_EYE_THRESHOLD = 1500
+
+    # Position boundaries (optimized)
+    LEFT_BOUNDARY = 0.35
+    RIGHT_BOUNDARY = 0.65
+
+    # Temporal smoothing zone
+    SMOOTHING_LEFT_MIN = 0.33
+    SMOOTHING_LEFT_MAX = 0.37
+    SMOOTHING_RIGHT_MIN = 0.63
+    SMOOTHING_RIGHT_MAX = 0.67
+
+    # Blink ratio threshold
+    BLINK_THRESHOLD = 5.5
+
+    # Score thresholds (dalam detik)
+    SCORE_THRESHOLDS = {
+        5: (5, "Sangat Baik"),
+        4: (8, "Baik"),
+        3: (10, "Cukup Baik"),
+        2: (12, "Buruk"),
+        1: (float('inf'), "Perlu Ditingkatkan")
+    }
+
+    # Adaptive parameters by eye size
+    ADAPTIVE_PARAMS = {
+        'SMALL': {
+            'scale_factor': 3.0,
+            'interpolation': cv.INTER_LANCZOS4,
+            'clahe_clip': 4.0,
+            'clahe_grid': (4, 4),
+            'bilateral_d': 7,
+            'bilateral_sigma': 75,
+            'thresholds': [20, 25, 30, 35, 40, 45, 50, 55],
+            'min_area_ratio': 0.001,
+            'max_area_ratio': 0.50,
+            'min_circularity': 0.3,
+            'min_solidity': 0.5,
+            'morph_kernel': 5,
+            'morph_close_iter': 3,
+            'morph_open_iter': 2
+        },
+        'MEDIUM': {
+            'scale_factor': 2.0,
+            'interpolation': cv.INTER_CUBIC,
+            'clahe_clip': 3.0,
+            'clahe_grid': (8, 8),
+            'bilateral_d': 5,
+            'bilateral_sigma': 50,
+            'thresholds': [30, 35, 40, 45, 50, 55, 60],
+            'min_area_ratio': 0.005,
+            'max_area_ratio': 0.45,
+            'min_circularity': 0.4,
+            'min_solidity': 0.6,
+            'morph_kernel': 3,
+            'morph_close_iter': 2,
+            'morph_open_iter': 1
+        },
+        'LARGE': {
+            'scale_factor': 1.5,
+            'interpolation': cv.INTER_CUBIC,
+            'clahe_clip': 2.0,
+            'clahe_grid': (8, 8),
+            'bilateral_d': 3,
+            'bilateral_sigma': 30,
+            'thresholds': [35, 40, 45, 50, 55, 60, 65],
+            'min_area_ratio': 0.01,
+            'max_area_ratio': 0.40,
+            'min_circularity': 0.5,
+            'min_solidity': 0.7,
+            'morph_kernel': 3,
+            'morph_close_iter': 2,
+            'morph_open_iter': 1
+        }
+    }
+
+
+class EyeTracker:
+    """Main class untuk eye tracking"""
+
+    def __init__(self, config: EyeTrackingConfig = None):
+        self.config = config or EyeTrackingConfig()
+        self.face_mesh = mp.solutions.face_mesh.FaceMesh(
+            min_detection_confidence=0.5,
+            min_tracking_confidence=0.5
+        )
+        self.prev_position_right = None
+        self.prev_position_left = None
+        logger.info("EyeTracker initialized successfully")
+
+    def __del__(self):
+        """Cleanup resources"""
+        if hasattr(self, 'face_mesh') and self.face_mesh:
+            self.face_mesh.close()
+
+    @staticmethod
+    def euclidean_distance(point1: Tuple[int, int], point2: Tuple[int, int]) -> float:
+        """Calculate Euclidean distance between two points"""
+        return math.sqrt((point2[0] - point1[0])**2 + (point2[1] - point1[1])**2)
+
+    def detect_landmarks(self, frame: np.ndarray) -> Optional[List[Tuple[int, int]]]:
+        """Detect facial landmarks"""
+        try:
+            rgb_frame = cv.cvtColor(frame, cv.COLOR_BGR2RGB)
+            results = self.face_mesh.process(rgb_frame)
+
+            if not results.multi_face_landmarks:
+                return None
+
+            img_height, img_width = frame.shape[:2]
+            mesh_coords = [
+                (int(point.x * img_width), int(point.y * img_height))
+                for point in results.multi_face_landmarks[0].landmark
+            ]
+            return mesh_coords
+        except Exception as e:
+            logger.error(f"Error detecting landmarks: {e}")
+            return None
+
+    def calculate_blink_ratio(self, landmarks: List[Tuple[int, int]]) -> float:
+        """Calculate blink ratio from eye landmarks"""
+        try:
+            # Right eye
+            rh_distance = self.euclidean_distance(
+                landmarks[self.config.RIGHT_EYE[0]],
+                landmarks[self.config.RIGHT_EYE[8]]
+            )
+            rv_distance = self.euclidean_distance(
+                landmarks[self.config.RIGHT_EYE[12]],
+                landmarks[self.config.RIGHT_EYE[4]]
+            )
+
+            # Left eye
+            lh_distance = self.euclidean_distance(
+                landmarks[self.config.LEFT_EYE[0]],
+                landmarks[self.config.LEFT_EYE[8]]
+            )
+            lv_distance = self.euclidean_distance(
+                landmarks[self.config.LEFT_EYE[12]],
+                landmarks[self.config.LEFT_EYE[4]]
+            )
+
+            if rv_distance == 0 or lv_distance == 0:
+                return 0
+
+            re_ratio = rh_distance / rv_distance
+            le_ratio = lh_distance / lv_distance
+            ratio = (re_ratio + le_ratio) / 2
+
+            return ratio
+        except Exception as e:
+            logger.error(f"Error calculating blink ratio: {e}")
+            return 0
+
+    def extract_eye_region(self, frame: np.ndarray, eye_coords: List[Tuple[int, int]]) -> Optional[np.ndarray]:
+        """Extract and crop eye region from frame"""
+        try:
+            gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
+            mask = np.zeros(gray.shape, dtype=np.uint8)
+
+            cv.fillPoly(mask, [np.array(eye_coords, dtype=np.int32)], 255)
+            eye = cv.bitwise_and(gray, gray, mask=mask)
+            eye[mask == 0] = 155
+
+            # Get bounding box
+            x_coords = [coord[0] for coord in eye_coords]
+            y_coords = [coord[1] for coord in eye_coords]
+
+            min_x, max_x = min(x_coords), max(x_coords)
+            min_y, max_y = min(y_coords), max(y_coords)
+
+            cropped = eye[min_y:max_y, min_x:max_x]
+            return cropped if cropped.size > 0 else None
+        except Exception as e:
+            logger.error(f"Error extracting eye region: {e}")
+            return None
+
+    def classify_eye_size(self, eye_region: np.ndarray) -> str:
+        """Classify eye size (SMALL/MEDIUM/LARGE)"""
+        if eye_region is None or eye_region.size == 0:
+            return 'UNKNOWN'
+
+        h, w = eye_region.shape
+        area = h * w
+
+        if area < self.config.SMALL_EYE_THRESHOLD:
+            return 'SMALL'
+        elif area < self.config.MEDIUM_EYE_THRESHOLD:
+            return 'MEDIUM'
+        else:
+            return 'LARGE'
+
+    def adaptive_preprocessing(self, eye_region: np.ndarray, eye_size: str) -> Optional[np.ndarray]:
+        """Apply adaptive preprocessing based on eye size"""
+        try:
+            params = self.config.ADAPTIVE_PARAMS[eye_size]
+
+            # Upscaling
+            upscaled = cv.resize(
+                eye_region, None,
+                fx=params['scale_factor'],
+                fy=params['scale_factor'],
+                interpolation=params['interpolation']
+            )
+
+            # CLAHE enhancement
+            clahe = cv.createCLAHE(
+                clipLimit=params['clahe_clip'],
+                tileGridSize=params['clahe_grid']
+            )
+            enhanced = clahe.apply(upscaled)
+
+            # Bilateral filter
+            enhanced = cv.bilateralFilter(
+                enhanced,
+                params['bilateral_d'],
+                params['bilateral_sigma'],
+                params['bilateral_sigma']
+            )
+
+            # Unsharp masking for SMALL eyes
+            if eye_size == 'SMALL':
+                gaussian = cv.GaussianBlur(enhanced, (3, 3), 2.0)
+                enhanced = cv.addWeighted(enhanced, 1.5, gaussian, -0.5, 0)
+                enhanced = np.clip(enhanced, 0, 255).astype(np.uint8)
+
+            return enhanced
+        except Exception as e:
+            logger.error(f"Error in adaptive preprocessing: {e}")
+            return None
+
+    def aggressive_morphology(self, mask: np.ndarray, eye_size: str) -> np.ndarray:
+        """Apply aggressive morphology operations"""
+        params = self.config.ADAPTIVE_PARAMS[eye_size]
+        kernel = cv.getStructuringElement(
+            cv.MORPH_ELLIPSE,
+            (params['morph_kernel'], params['morph_kernel'])
+        )
+
+        # Close gaps
+        mask = cv.morphologyEx(
+            mask, cv.MORPH_CLOSE, kernel,
+            iterations=params['morph_close_iter']
+        )
+
+        # Remove noise
+        mask = cv.morphologyEx(
+            mask, cv.MORPH_OPEN, kernel,
+            iterations=params['morph_open_iter']
+        )
+
+        # Fill holes
+        if eye_size == 'SMALL':
+            kernel_dilate = cv.getStructuringElement(cv.MORPH_ELLIPSE, (3, 3))
+            mask = cv.dilate(mask, kernel_dilate, iterations=1)
+
+        return mask
+
+    def connected_components_analysis(self, mask: np.ndarray, params: Dict) -> Optional[Dict]:
+        """Analyze connected components and find best pupil candidate"""
+        h, w = mask.shape
+        min_area = (h * w) * params['min_area_ratio']
+        max_area = (h * w) * params['max_area_ratio']
+
+        # Connected components
+        num_labels, labels, stats, centroids = cv.connectedComponentsWithStats(
+            mask, connectivity=8
+        )
+
+        candidates = []
+
+        for i in range(1, num_labels):
+            area = stats[i, cv.CC_STAT_AREA]
+
+            if area < min_area or area > max_area:
+                continue
+
+            # Create component mask
+            component_mask = np.zeros_like(mask)
+            component_mask[labels == i] = 255
+
+            # Get contour
+            contours, _ = cv.findContours(
+                component_mask, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE
+            )
+            if not contours:
+                continue
+
+            contour = contours[0]
+
+            # Circularity
+            perimeter = cv.arcLength(contour, True)
+            if perimeter == 0:
+                continue
+            circularity = 4 * math.pi * area / (perimeter * perimeter)
+
+            if circularity < params['min_circularity']:
+                continue
+
+            # Solidity
+            hull = cv.convexHull(contour)
+            hull_area = cv.contourArea(hull)
+            if hull_area == 0:
+                continue
+            solidity = area / hull_area
+
+            if solidity < params['min_solidity']:
+                continue
+
+            # Center score
+            center_x = w / 2
+            cx = centroids[i][0]
+            distance_from_center = abs(cx - center_x) / w
+            center_score = 1.0 - distance_from_center
+
+            # Aspect ratio
+            x, y, w_bbox, h_bbox = (
+                stats[i, cv.CC_STAT_LEFT],
+                stats[i, cv.CC_STAT_TOP],
+                stats[i, cv.CC_STAT_WIDTH],
+                stats[i, cv.CC_STAT_HEIGHT]
+            )
+            if h_bbox == 0:
+                continue
+            aspect_ratio = w_bbox / h_bbox
+            aspect_score = 1.0 - abs(aspect_ratio - 1.0)
+
+            # Combined score
+            score = area * circularity * solidity * center_score * aspect_score
+
+            candidates.append({
+                'mask': component_mask,
+                'contour': contour,
+                'area': area,
+                'circularity': circularity,
+                'solidity': solidity,
+                'center_score': center_score,
+                'aspect_ratio': aspect_ratio,
+                'score': score,
+                'centroid': centroids[i]
+            })
+
+        if not candidates:
+            return None
+
+        return max(candidates, key=lambda x: x['score'])
+
+    def distance_transform_refinement(self, mask: np.ndarray) -> Tuple[int, int]:
+        """Refine centroid using distance transform"""
+        dist_transform = cv.distanceTransform(mask, cv.DIST_L2, 5)
+        _, _, _, max_loc = cv.minMaxLoc(dist_transform)
+        return max_loc
+
+    def detect_pupil(self, enhanced: np.ndarray, eye_size: str) -> Optional[Dict]:
+        """Detect pupil using multi-stage pipeline"""
+        params = self.config.ADAPTIVE_PARAMS[eye_size]
+
+        best_candidate = None
+        best_score = 0
+        best_threshold = 0
+
+        for thresh_val in params['thresholds']:
+            # Threshold
+            _, mask = cv.threshold(enhanced, thresh_val, 255, cv.THRESH_BINARY_INV)
+
+            # Morphology
+            mask = self.aggressive_morphology(mask, eye_size)
+
+            # Connected components
+            candidate = self.connected_components_analysis(mask, params)
+
+            if candidate and candidate['score'] > best_score:
+                best_score = candidate['score']
+                best_candidate = candidate
+                best_threshold = thresh_val
+                best_candidate['refined_mask'] = mask
+
+        if not best_candidate:
+            return None
+
+        # Distance transform refinement
+        dt_center = self.distance_transform_refinement(best_candidate['mask'])
+        best_candidate['dt_center'] = dt_center
+        best_candidate['threshold'] = best_threshold
+
+        return best_candidate
+
+    def determine_gaze_position(self, centroid_x: int, width: int, prev_position: Optional[str]) -> str:
+        """Determine gaze position (LEFT/CENTER/RIGHT)"""
+        ratio = centroid_x / width
+
+        # Base position
+        if ratio < self.config.LEFT_BOUNDARY:
+            position = "LEFT"
+        elif ratio > self.config.RIGHT_BOUNDARY:
+            position = "RIGHT"
+        else:
+            position = "CENTER"
+
+        # Temporal smoothing
+        if prev_position and prev_position != "UNKNOWN":
+            in_left_boundary = (
+                self.config.SMOOTHING_LEFT_MIN <= ratio <= self.config.SMOOTHING_LEFT_MAX
+            )
+            in_right_boundary = (
+                self.config.SMOOTHING_RIGHT_MIN <= ratio <= self.config.SMOOTHING_RIGHT_MAX
+            )
+
+            if in_left_boundary or in_right_boundary:
+                position = prev_position
+
+        return position
+
+    def estimate_eye_position(self, eye_region: np.ndarray, prev_position: Optional[str] = None) -> Tuple[str, Dict]:
+        """Estimate eye gaze position"""
+        if eye_region is None or eye_region.size == 0:
+            return "UNKNOWN", {}
+
+        h, w = eye_region.shape
+        if h < 5 or w < 10:
+            return "UNKNOWN", {}
+
+        try:
+            # Classify eye size
+            eye_size = self.classify_eye_size(eye_region)
+            if eye_size == 'UNKNOWN':
+                return "UNKNOWN", {}
+
+            # Preprocessing
+            enhanced = self.adaptive_preprocessing(eye_region, eye_size)
+            if enhanced is None:
+                return "UNKNOWN", {}
+
+            # Detect pupil
+            pupil_data = self.detect_pupil(enhanced, eye_size)
+            if not pupil_data:
+                return "UNKNOWN", {}
+
+            # Get centroid
+            cx, cy = pupil_data['dt_center']
+            upscaled_h, upscaled_w = enhanced.shape
+
+            # Determine position
+            position = self.determine_gaze_position(cx, upscaled_w, prev_position)
+
+            # Return result
+            result = {
+                'position': position,
+                'centroid': (cx, cy),
+                'centroid_ratio': cx / upscaled_w,
+                'eye_size': eye_size,
+                'metrics': {
+                    'circularity': pupil_data['circularity'],
+                    'solidity': pupil_data['solidity'],
+                    'area': pupil_data['area'],
+                    'threshold': pupil_data['threshold']
+                }
+            }
+
+            return position, result
+
+        except Exception as e:
+            logger.error(f"Error estimating eye position: {e}")
+            return "UNKNOWN", {}
+
+    def process_frame(self, frame: np.ndarray) -> Dict:
+        """Process single frame and return analysis"""
+        result = {
+            'timestamp': datetime.now().isoformat(),
+            'face_detected': False,
+            'blink_detected': False,
+            'blink_ratio': 0.0,
+            'right_eye': {'position': 'UNKNOWN', 'data': {}},
+            'left_eye': {'position': 'UNKNOWN', 'data': {}},
+            'gaze_position': 'UNKNOWN'
+        }
+
+        try:
+            # Detect landmarks
+            landmarks = self.detect_landmarks(frame)
+            if not landmarks:
+                return result
+
+            result['face_detected'] = True
+
+            # Calculate blink ratio
+            blink_ratio = self.calculate_blink_ratio(landmarks)
+            result['blink_ratio'] = round(blink_ratio, 2)
+            result['blink_detected'] = blink_ratio > self.config.BLINK_THRESHOLD
+
+            # Extract eye regions
+            right_coords = [landmarks[i] for i in self.config.RIGHT_EYE]
+            left_coords = [landmarks[i] for i in self.config.LEFT_EYE]
+
+            right_eye_region = self.extract_eye_region(frame, right_coords)
+            left_eye_region = self.extract_eye_region(frame, left_coords)
+
+            # Estimate positions
+            right_pos, right_data = self.estimate_eye_position(
+                right_eye_region, self.prev_position_right
+            )
+            left_pos, left_data = self.estimate_eye_position(
+                left_eye_region, self.prev_position_left
+            )
+
+            result['right_eye'] = {'position': right_pos, 'data': right_data}
+            result['left_eye'] = {'position': left_pos, 'data': left_data}
+
+            # Use right eye as primary (typically more stable)
+            result['gaze_position'] = right_pos
+
+            # Update previous positions
+            self.prev_position_right = right_pos
+            self.prev_position_left = left_pos
+
+        except Exception as e:
+            logger.error(f"Error processing frame: {e}")
+
+        return result
+
+
+class VideoAnalyzer:
+    """Analyze video and generate comprehensive report"""
+
+    def __init__(self, config: EyeTrackingConfig = None):
+        self.config = config or EyeTrackingConfig()
+        self.tracker = EyeTracker(config)
+
+    def calculate_score(self, gaze_away_time: float) -> Tuple[int, str]:
+        """Calculate score based on gaze away time"""
+        for score, (threshold, rating) in sorted(
+            self.config.SCORE_THRESHOLDS.items(), reverse=True
+        ):
+            if gaze_away_time <= threshold:
+                return score, rating
+        return 1, "Perlu Ditingkatkan"
+
+    def analyze_video(
+        self,
+        video_path: str,
+        output_path: Optional[str] = None,
+        progress_callback: Optional[callable] = None
+    ) -> Dict:
+        """
+        Analyze video and return comprehensive report
+
+        Args:
+            video_path: Path to input video
+            output_path: Optional path for output video with annotations
+            progress_callback: Optional callback function(current, total, status)
+
+        Returns:
+            Dictionary containing analysis results
+        """
+        logger.info(f"Starting video analysis: {video_path}")
+
+        cap = cv.VideoCapture(video_path)
+        if not cap.isOpened():
+            logger.error(f"Failed to open video: {video_path}")
+            return {'error': 'Failed to open video file'}
+
+        # Video properties
+        fps = int(cap.get(cv.CAP_PROP_FPS)) or 30
+        width = int(cap.get(cv.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
+        total_frames = int(cap.get(cv.CAP_PROP_FRAME_COUNT))
+
+        # Initialize video writer if output requested
+        writer = None
+        if output_path:
+            fourcc = cv.VideoWriter_fourcc(*'mp4v')
+            writer = cv.VideoWriter(output_path, fourcc, fps, (width, height))
+
+        # Initialize counters
+        frame_count = 0
+        gaze_away_frames = 0
+        blink_count = 0
+        position_counts = {'CENTER': 0, 'LEFT': 0, 'RIGHT': 0, 'UNKNOWN': 0}
+        eye_size_counts = {'SMALL': 0, 'MEDIUM': 0, 'LARGE': 0}
+
+        prev_blink = False
+
+        # Process frames
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            frame_count += 1
+
+            # Process frame
+            result = self.tracker.process_frame(frame)
+
+            # Update counters
+            position = result['gaze_position']
+            position_counts[position] += 1
+
+            if position not in ['CENTER', 'UNKNOWN']:
+                gaze_away_frames += 1
+
+            # Count blinks (transition from non-blink to blink)
+            if result['blink_detected'] and not prev_blink:
+                blink_count += 1
+            prev_blink = result['blink_detected']
+
+            # Track eye size
+            if result['right_eye']['data']:
+                eye_size = result['right_eye']['data'].get('eye_size', 'UNKNOWN')
+                if eye_size in eye_size_counts:
+                    eye_size_counts[eye_size] += 1
+
+            # Annotate frame if output requested
+            if writer:
+                # Add annotations here if needed
+                writer.write(frame)
+
+            # Progress callback
+            if progress_callback and frame_count % 10 == 0:
+                progress_callback(frame_count, total_frames, position)
+
+        # Cleanup
+        cap.release()
+        if writer:
+            writer.release()
+
+        # Calculate metrics
+        duration = frame_count / fps
+        gaze_away_time = gaze_away_frames / fps
+        score, rating = self.calculate_score(gaze_away_time)
+
+        # Generate report
+        report = {
+            'success': True,
+            'video_info': {
+                'path': video_path,
+                'duration': round(duration, 2),
+                'fps': fps,
+                'resolution': f"{width}x{height}",
+                'total_frames': frame_count
+            },
+            'eye_contact_analysis': {
+                'total_gaze_away_time': round(gaze_away_time, 2),
+                'gaze_away_percentage': round((gaze_away_time / duration) * 100, 2),
+                'score': score,
+                'rating': rating,
+                'position_distribution': {
+                    k: {
+                        'frames': v,
+                        'percentage': round((v / frame_count) * 100, 2)
+                    }
+                    for k, v in position_counts.items()
+                }
+            },
+            'blink_analysis': {
+                'total_blinks': blink_count,
+                'blinks_per_minute': round((blink_count / duration) * 60, 2)
+            },
+            'eye_size_distribution': {
+                k: {
+                    'frames': v,
+                    'percentage': round((v / sum(eye_size_counts.values())) * 100, 2) if sum(eye_size_counts.values()) > 0 else 0
+                }
+                for k, v in eye_size_counts.items()
+            },
+            'timestamp': datetime.now().isoformat()
+        }
+
+        logger.info(f"Video analysis completed: {score}/5 - {rating}")
+        return report
+
+    def save_report(self, report: Dict, output_path: str):
+        """Save report to JSON file"""
+        try:
+            with open(output_path, 'w', encoding='utf-8') as f:
+                json.dump(report, f, indent=2, ensure_ascii=False)
+            logger.info(f"Report saved to: {output_path}")
+        except Exception as e:
+            logger.error(f"Error saving report: {e}")
+
+
+# ===== API FUNCTIONS FOR INTEGRATION =====
+
+def analyze_video_file(
+    video_path: str,
+    output_video_path: Optional[str] = None,
+    output_report_path: Optional[str] = None,
+    progress_callback: Optional[callable] = None
+) -> Dict:
+    """
+    Main API function untuk analisis video
+
+    Args:
+        video_path: Path ke video input
+        output_video_path: Optional path untuk video output dengan anotasi
+        output_report_path: Optional path untuk JSON report
+        progress_callback: Optional callback untuk progress update
+
+    Returns:
+        Dictionary berisi hasil analisis
+
+    Example:
+        >>> result = analyze_video_file('video.mp4', 'output.mp4', 'report.json')
+        >>> print(f"Score: {result['eye_contact_analysis']['score']}/5")
+    """
+    try:
+        analyzer = VideoAnalyzer()
+        report = analyzer.analyze_video(
+            video_path,
+            output_video_path,
+            progress_callback
+        )
+
+        if output_report_path and report.get('success'):
+            analyzer.save_report(report, output_report_path)
+
+        return report
+
+    except Exception as e:
+        logger.error(f"Error in analyze_video_file: {e}")
+        return {
+            'success': False,
+            'error': str(e)
+        }
+
+
+def analyze_frame(frame: np.ndarray, tracker: Optional[EyeTracker] = None) -> Dict:
+    """
+    Analyze single frame (untuk real-time processing)
+
+    Args:
+        frame: Frame image (numpy array)
+        tracker: Optional EyeTracker instance (untuk reuse)
+
+    Returns:
+        Dictionary berisi hasil analisis frame
+
+    Example:
+        >>> tracker = EyeTracker()
+        >>> cap = cv.VideoCapture(0)
+        >>> ret, frame = cap.read()
+        >>> result = analyze_frame(frame, tracker)
+        >>> print(result['gaze_position'])
+    """
+    try:
+        if tracker is None:
+            tracker = EyeTracker()
+
+        return tracker.process_frame(frame)
+
+    except Exception as e:
+        logger.error(f"Error in analyze_frame: {e}")
+        return {
+            'error': str(e),
+            'gaze_position': 'UNKNOWN'
+        }
+
+
+# ===== EXAMPLE USAGE =====
+if __name__ == "__main__":
+    import sys
+
+    print("=" * 70)
+    print("SWARA - Eye Tracking Module (Production)")
+    print("=" * 70)
+
+    if len(sys.argv) < 2:
+        print("\nUsage:")
+        print("  python swara_eye_tracking.py <video_path> [output_video] [output_report]")
+        print("\nExample:")
+        print("  python swara_eye_tracking.py input.mp4")
+        print("  python swara_eye_tracking.py input.mp4 output.mp4 report.json")
+        sys.exit(1)
+
+    video_path = sys.argv[1]
+    output_video = sys.argv[2] if len(sys.argv) > 2 else None
+    output_report = sys.argv[3] if len(sys.argv) > 3 else None
+
+    # Progress callback
+    def progress(current, total, status):
+        percent = (current / total) * 100
+        print(f"\rProgress: {current}/{total} ({percent:.1f}%) - Status: {status}", end='')
+
+    print(f"\n📹 Processing video: {video_path}")
+    print("-" * 70)
+
+    # Analyze
+    result = analyze_video_file(
+        video_path,
+        output_video,
+        output_report,
+        progress
+    )
+
+    print("\n")
+
+    if result.get('success'):
+        print("\n" + "=" * 70)
+        print("📊 HASIL ANALISIS")
+        print("=" * 70)
+
+        # Video info
+        print(f"\n📹 Video Info:")
+        print(f"   Duration: {result['video_info']['duration']} seconds")
+        print(f"   FPS: {result['video_info']['fps']}")
+        print(f"   Resolution: {result['video_info']['resolution']}")
+
+        # Eye contact
+        ec = result['eye_contact_analysis']
+        print(f"\n👁️  Eye Contact:")
+        print(f"   Score: {ec['score']}/5 - {ec['rating']}")
+        print(f"   Gaze Away Time: {ec['total_gaze_away_time']}s ({ec['gaze_away_percentage']}%)")
+        print(f"\n   Position Distribution:")
+        for pos, data in ec['position_distribution'].items():
+            print(f"      {pos}: {data['frames']} frames ({data['percentage']}%)")
+
+        # Blink
+        blink = result['blink_analysis']
+        print(f"\n👁️  Blink Analysis:")
+        print(f"   Total Blinks: {blink['total_blinks']}")
+        print(f"   Blinks/Minute: {blink['blinks_per_minute']}")
+
+        print("\n" + "=" * 70)
+
+        if output_report:
+            print(f"\n✅ Report saved to: {output_report}")
+        if output_video:
+            print(f"✅ Video saved to: {output_video}")
+
+    else:
+        print(f"\n❌ Error: {result.get('error', 'Unknown error')}")
+        sys.exit(1)

app/services/facial_expression.py

@@ -0,0 +1,206 @@
+"""
+Facial Expression Service
+
+Refactored from facial_expression.py for production use.
+Detects facial expressions using YOLO model
+"""
+import cv2
+import numpy as np
+from typing import Dict, Any
+from loguru import logger
+from ultralytics import YOLO
+
+from app.config import settings
+
+
+class FacialExpressionService:
+    """
+    Facial Expression Service for SWARA API
+    
+    Analyzes facial expressions in videos using YOLO model
+    """
+    
+    # Class variable for singleton pattern
+    _model = None
+    
+    def __init__(self):
+        """Initialize service and load model"""
+        if FacialExpressionService._model is None:
+            self._load_model()
+    
+    def _load_model(self):
+        """Load YOLO model (called once)"""
+        try:
+            logger.info("Loading Facial Expression YOLO model...")
+            model_path = settings.FACIAL_EXPRESSION_MODEL
+            FacialExpressionService._model = YOLO(model_path)
+            logger.info(f"✓ Facial Expression model loaded from {model_path}")
+        except Exception as e:
+            logger.error(f"✗ Failed to load Facial Expression model: {e}")
+            raise
+    
+    def analyze_video(self, video_path: str) -> Dict[str, Any]:
+        """
+        Analyze video for facial expressions
+        
+        Args:
+            video_path: Path to video file
+        
+        Returns:
+            Dict containing facial expression analysis results
+        """
+        try:
+            logger.info(f"Analyzing video with Facial Expression Service: {video_path}")
+            
+            # Open video
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                raise ValueError(f"Cannot open video: {video_path}")
+            
+            # Get video properties
+            fps = int(cap.get(cv2.CAP_PROP_FPS))
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            
+            # Data storage
+            frame_data = []
+            frame_number = 0
+            
+            # Process each frame
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                frame_number += 1
+                timestamp_start = (frame_number - 1) / fps
+                timestamp_end = frame_number / fps
+                
+                # Convert to grayscale and back to 3 channels
+                gray_image = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                gray_image_3d = cv2.merge([gray_image, gray_image, gray_image])
+                
+                # Run YOLO inference
+                results = self._model(gray_image_3d, verbose=False)
+                result = results[0]
+                
+                # Get detections
+                if len(result.boxes) > 0:
+                    # Get all detections
+                    boxes = result.boxes.xyxy.cpu().numpy()
+                    confidences = result.boxes.conf.cpu().numpy()
+                    classes = result.boxes.cls.cpu().numpy()
+                    
+                    # Find detection with highest confidence
+                    max_conf_idx = np.argmax(confidences)
+                    
+                    # Get data for highest confidence detection
+                    box = boxes[max_conf_idx]
+                    confidence = confidences[max_conf_idx]
+                    class_id = int(classes[max_conf_idx])
+                    
+                    # Get class name
+                    expression = self._model.names[class_id]
+                    
+                    # Store frame data
+                    frame_data.append({
+                        'frame_number': frame_number,
+                        'timestamp_start': round(timestamp_start, 3),
+                        'timestamp_end': round(timestamp_end, 3),
+                        'expression': expression,
+                        'confidence': round(float(confidence), 4),
+                        'bbox_x': int(box[0]),
+                        'bbox_y': int(box[1]),
+                        'bbox_width': int(box[2] - box[0]),
+                        'bbox_height': int(box[3] - box[1])
+                    })
+                else:
+                    # No face detected
+                    frame_data.append({
+                        'frame_number': frame_number,
+                        'timestamp_start': round(timestamp_start, 3),
+                        'timestamp_end': round(timestamp_end, 3),
+                        'expression': 'no_face',
+                        'confidence': 0.0,
+                        'bbox_x': 0,
+                        'bbox_y': 0,
+                        'bbox_width': 0,
+                        'bbox_height': 0
+                    })
+            
+            cap.release()
+            
+            logger.info(f"✓ Processed {frame_number} frames")
+            
+            # Analyze expressions
+            df_faces = [f for f in frame_data if f['expression'] not in ['no_face', 'background']]
+            
+            # Calculate expression distribution
+            if len(df_faces) > 0:
+                expression_counts = {}
+                for f in df_faces:
+                    expr = f['expression']
+                    expression_counts[expr] = expression_counts.get(expr, 0) + 1
+                
+                total_face_frames = len(df_faces)
+                expression_distribution = {}
+                for expr, count in expression_counts.items():
+                    percentage = (count / total_face_frames) * 100
+                    expression_distribution[expr] = round(percentage, 2)
+                
+                # Find dominant expression
+                dominant_expression = max(expression_counts.items(), key=lambda x: x[1])[0]
+            else:
+                expression_distribution = {}
+                dominant_expression = 'no_face'
+            
+            # Opening smile analysis (first 10 seconds)
+            opening_frames = [f for f in frame_data if f['timestamp_start'] < 10.0]
+            opening_faces = [f for f in opening_frames if f['expression'] not in ['no_face', 'background']]
+            
+            if len(opening_faces) > 0:
+                # Count happy expressions in opening
+                opening_happy_count = len([f for f in opening_faces if f['expression'].lower() == 'happy'])
+                opening_smile_percentage = (opening_happy_count / len(opening_faces)) * 100
+                opening_smile_detected = opening_smile_percentage > 50.0
+                
+                # Get all expressions in opening period
+                opening_expressions = [f['expression'] for f in opening_faces]
+                
+                # Count each expression in opening
+                opening_expr_counts = {}
+                for f in opening_faces:
+                    expr = f['expression']
+                    opening_expr_counts[expr] = opening_expr_counts.get(expr, 0) + 1
+            else:
+                opening_smile_percentage = 0.0
+                opening_smile_detected = False
+                opening_expressions = []
+                opening_expr_counts = {}
+            
+            # Build result
+            result = {
+                'success': True,
+                'statistics_df': frame_data,  # Raw frame data
+                'summary': {
+                    'total_frames': total_frames,
+                    'frames_with_face': len(df_faces),
+                    'dominant_expression': dominant_expression,
+                    'expression_distribution': expression_distribution,
+                    'opening_smile_detected': opening_smile_detected,
+                    'opening_period_expressions': opening_expressions,
+                    'opening_smile_percentage': round(opening_smile_percentage, 2),
+                    'opening_expression_counts': opening_expr_counts,
+                    'video_duration_seconds': round(total_frames / fps, 2),
+                    'fps': fps
+                }
+            }
+            
+            logger.info(f"✓ Facial Expression analysis completed")
+            logger.info(f"  Dominant expression: {dominant_expression}")
+            logger.info(f"  Opening smile: {'YES' if opening_smile_detected else 'NO'} ({opening_smile_percentage:.1f}%)")
+            
+            return result
+        
+        except Exception as e:
+            logger.error(f"✗ Facial Expression analysis failed: {e}")
+            raise

app/services/gesture_detection.py

@@ -0,0 +1,569 @@
+"""
+Gesture Detection Service
+
+Refactored from Colab notebook for production use.
+Detects body gestures and movements using MediaPipe Pose.
+"""
+
+import cv2
+import numpy as np
+import mediapipe as mp
+from typing import Dict, Any, List, Optional, Tuple
+from loguru import logger
+from scipy.signal import savgol_filter
+from collections import Counter
+
+
+class GestureConfig:
+    """Configuration untuk gesture detection thresholds"""
+    
+    # Movement thresholds (dalam pixel)
+    EXCESSIVE_MOVEMENT_THRESHOLD = 50  # pixel/frame
+    MINIMAL_MOVEMENT_THRESHOLD = 5     # pixel/frame
+    
+    # Frequency thresholds (gestures per second)
+    HIGH_FREQUENCY = 3.0
+    LOW_FREQUENCY = 0.5
+    
+    # Stability thresholds
+    JITTER_THRESHOLD = 15  # pixel variance
+    
+    # Hand position zones (relative to body)
+    FRONT_ZONE_THRESHOLD = 0.15  # 15cm di depan bahu
+    
+    # Landmark indices
+    SHOULDER_LEFT = 11
+    SHOULDER_RIGHT = 12
+    ELBOW_LEFT = 13
+    ELBOW_RIGHT = 14
+    WRIST_LEFT = 15
+    WRIST_RIGHT = 16
+    HIP_LEFT = 23
+    HIP_RIGHT = 24
+    NOSE = 0
+
+
+class GestureDetectionService:
+    """
+    Gesture Detection Service for SWARA API
+    
+    Analyzes hand movements, body stability, and gesture patterns
+    using MediaPipe Pose landmarks.
+    """
+    
+    _instance = None
+    _pose = None
+    
+    def __new__(cls):
+        """Singleton pattern to avoid reloading MediaPipe multiple times"""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._pose = mp.solutions.pose.Pose(
+                static_image_mode=False,
+                model_complexity=1,
+                smooth_landmarks=True,
+                min_detection_confidence=0.5,
+                min_tracking_confidence=0.5
+            )
+            logger.info("GestureDetectionService initialized with MediaPipe Pose")
+        return cls._instance
+    
+    def __init__(self):
+        """Initialize service (called after __new__)"""
+        self.config = GestureConfig()
+    
+    def analyze_video(
+        self, 
+        video_path: str,
+        progress_callback: Optional[callable] = None
+    ) -> Dict[str, Any]:
+        """
+        Analyze gestures in a video file
+        
+        Args:
+            video_path: Path to video file
+            progress_callback: Optional callback function(current, total, message)
+            
+        Returns:
+            Dictionary containing gesture analysis results
+        """
+        try:
+            logger.info(f"Starting gesture analysis for: {video_path}")
+            
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                raise ValueError(f"Cannot open video file: {video_path}")
+            
+            fps = cap.get(cv2.CAP_PROP_FPS)
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            
+            logger.info(f"Video Info: {width}x{height} @ {fps}FPS, Total frames: {total_frames}")
+            
+            # Data storage
+            frame_data = []
+            frame_count = 0
+            prev_landmarks = None
+            
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                frame_count += 1
+                
+                # Progress callback
+                if progress_callback and frame_count % 30 == 0:
+                    progress = int((frame_count / total_frames) * 100)
+                    progress_callback(frame_count, total_frames, f"Processing gestures: {progress}%")
+                
+                # Convert to RGB for MediaPipe
+                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                results = self._pose.process(rgb_frame)
+                
+                # Initialize frame metrics
+                frame_metrics = {
+                    'frame_number': frame_count,
+                    'timestamp_start': (frame_count - 1) / fps,
+                    'timestamp_end': frame_count / fps,
+                    'pose_detected': False,
+                    'left_hand_movement': 0.0,
+                    'right_hand_movement': 0.0,
+                    'body_movement': 0.0,
+                    'left_hand_position': 'unknown',
+                    'right_hand_position': 'unknown'
+                }
+                
+                if results.pose_landmarks:
+                    frame_metrics['pose_detected'] = True
+                    landmarks = results.pose_landmarks.landmark
+                    
+                    # Get key landmarks
+                    l_wrist = self._get_landmark_coords(landmarks, self.config.WRIST_LEFT, width, height)
+                    r_wrist = self._get_landmark_coords(landmarks, self.config.WRIST_RIGHT, width, height)
+                    l_shoulder = self._get_landmark_coords(landmarks, self.config.SHOULDER_LEFT, width, height)
+                    r_shoulder = self._get_landmark_coords(landmarks, self.config.SHOULDER_RIGHT, width, height)
+                    
+                    # Calculate movements if previous frame exists
+                    if prev_landmarks is not None:
+                        if l_wrist and prev_landmarks.get('l_wrist'):
+                            frame_metrics['left_hand_movement'] = self._calculate_movement_speed(
+                                prev_landmarks['l_wrist'], l_wrist
+                            )
+                        
+                        if r_wrist and prev_landmarks.get('r_wrist'):
+                            frame_metrics['right_hand_movement'] = self._calculate_movement_speed(
+                                prev_landmarks['r_wrist'], r_wrist
+                            )
+                        
+                        # Body movement (center of shoulders)
+                        if l_shoulder and r_shoulder and prev_landmarks.get('shoulder_center'):
+                            shoulder_center = (
+                                (l_shoulder[0] + r_shoulder[0]) / 2,
+                                (l_shoulder[1] + r_shoulder[1]) / 2
+                            )
+                            frame_metrics['body_movement'] = self._calculate_movement_speed(
+                                prev_landmarks['shoulder_center'], shoulder_center
+                            )
+                    
+                    # Determine hand positions (front/side/back)
+                    if l_wrist and l_shoulder:
+                        if l_wrist[0] < l_shoulder[0] - width * 0.05:
+                            frame_metrics['left_hand_position'] = 'front'
+                        elif l_wrist[0] > l_shoulder[0] + width * 0.05:
+                            frame_metrics['left_hand_position'] = 'back'
+                        else:
+                            frame_metrics['left_hand_position'] = 'side'
+                    
+                    if r_wrist and r_shoulder:
+                        if r_wrist[0] > r_shoulder[0] + width * 0.05:
+                            frame_metrics['right_hand_position'] = 'front'
+                        elif r_wrist[0] < r_shoulder[0] - width * 0.05:
+                            frame_metrics['right_hand_position'] = 'back'
+                        else:
+                            frame_metrics['right_hand_position'] = 'side'
+                    
+                    # Store current landmarks for next frame
+                    prev_landmarks = {
+                        'l_wrist': l_wrist,
+                        'r_wrist': r_wrist,
+                        'l_shoulder': l_shoulder,
+                        'r_shoulder': r_shoulder,
+                        'shoulder_center': (
+                            (l_shoulder[0] + r_shoulder[0]) / 2,
+                            (l_shoulder[1] + r_shoulder[1]) / 2
+                        ) if l_shoulder and r_shoulder else None
+                    }
+                else:
+                    prev_landmarks = None
+                
+                frame_data.append(frame_metrics)
+            
+            cap.release()
+            
+            if not frame_data:
+                logger.warning("No frames processed")
+                return self._create_empty_result("No frames processed")
+            
+            # Filter frames with detected pose
+            pose_frames = [f for f in frame_data if f['pose_detected']]
+            
+            if len(pose_frames) < 10:
+                logger.warning(f"Insufficient pose landmarks detected: {len(pose_frames)} frames")
+                return self._create_empty_result("Insufficient pose data")
+            
+            logger.info(f"Frames with pose detected: {len(pose_frames)} / {len(frame_data)} ({len(pose_frames)/len(frame_data)*100:.1f}%)")
+            
+            # Analyze gestures
+            analysis_result = self._analyze_gestures(pose_frames, fps, total_frames)
+            
+            logger.info(f"Gesture analysis complete: Score {analysis_result['gesture_analysis']['movement_score']:.1f}/10")
+            return analysis_result
+            
+        except Exception as e:
+            logger.error(f"Error in gesture analysis: {str(e)}")
+            raise
+    
+    def _get_landmark_coords(
+        self, 
+        landmarks: Any, 
+        idx: int, 
+        width: int, 
+        height: int
+    ) -> Optional[Tuple[int, int, float]]:
+        """Get landmark coordinates in pixel space with visibility"""
+        if landmarks:
+            lm = landmarks[idx]
+            return (int(lm.x * width), int(lm.y * height), lm.visibility)
+        return None
+    
+    def _calculate_movement_speed(
+        self, 
+        prev_point: Tuple, 
+        curr_point: Tuple
+    ) -> float:
+        """Calculate movement speed between frames"""
+        if prev_point is None or curr_point is None:
+            return 0.0
+        return np.sqrt(
+            (curr_point[0] - prev_point[0])**2 + 
+            (curr_point[1] - prev_point[1])**2
+        )
+    
+    def _smooth_data(self, data: List[float], window_size: int = 5) -> np.ndarray:
+        """Smooth data using Savitzky-Golay filter"""
+        if len(data) < window_size:
+            return np.array(data)
+        try:
+            return savgol_filter(data, window_size, 2)
+        except:
+            return np.array(data)
+    
+    def _analyze_gestures(
+        self, 
+        pose_frames: List[Dict], 
+        fps: float,
+        total_frames: int
+    ) -> Dict[str, Any]:
+        """Analyze gesture patterns and calculate scores"""
+        
+        # Extract movement data
+        left_hand_movements = [f['left_hand_movement'] for f in pose_frames]
+        right_hand_movements = [f['right_hand_movement'] for f in pose_frames]
+        body_movements = [f['body_movement'] for f in pose_frames]
+        
+        # Calculate statistics
+        avg_left_hand_speed = np.mean(left_hand_movements)
+        avg_right_hand_speed = np.mean(right_hand_movements)
+        avg_hand_speed = (avg_left_hand_speed + avg_right_hand_speed) / 2
+        
+        max_left_hand_speed = np.max(left_hand_movements)
+        max_right_hand_speed = np.max(right_hand_movements)
+        max_hand_speed = max(max_left_hand_speed, max_right_hand_speed)
+        
+        avg_body_movement = np.mean(body_movements)
+        max_body_movement = np.max(body_movements)
+        
+        # Hand activity percentage
+        active_frames = [
+            f for f in pose_frames 
+            if f['left_hand_movement'] > self.config.MINIMAL_MOVEMENT_THRESHOLD or 
+               f['right_hand_movement'] > self.config.MINIMAL_MOVEMENT_THRESHOLD
+        ]
+        hand_activity_percentage = (len(active_frames) / len(pose_frames)) * 100
+        
+        # Gesture frequency (peak detection)
+        combined_movement = [
+            left_hand_movements[i] + right_hand_movements[i] 
+            for i in range(len(left_hand_movements))
+        ]
+        smooth_movement = self._smooth_data(combined_movement)
+        
+        peaks = 0
+        threshold = self.config.MINIMAL_MOVEMENT_THRESHOLD * 2
+        for i in range(1, len(smooth_movement) - 1):
+            if (smooth_movement[i] > threshold and 
+                smooth_movement[i] > smooth_movement[i-1] and 
+                smooth_movement[i] > smooth_movement[i+1]):
+                peaks += 1
+        
+        video_duration = total_frames / fps
+        gesture_frequency = peaks / video_duration if video_duration > 0 else 0
+        
+        # Body stability
+        body_movement_variance = np.var(body_movements)
+        if body_movement_variance < self.config.JITTER_THRESHOLD:
+            jitter_level = 'low'
+        elif body_movement_variance < self.config.JITTER_THRESHOLD * 2:
+            jitter_level = 'medium'
+        else:
+            jitter_level = 'high'
+        
+        # Hand position distribution
+        hand_positions = []
+        for f in pose_frames:
+            if f['left_hand_position'] != 'unknown':
+                hand_positions.append(f['left_hand_position'])
+            if f['right_hand_position'] != 'unknown':
+                hand_positions.append(f['right_hand_position'])
+        
+        if hand_positions:
+            pos_counts = Counter(hand_positions)
+            total_pos = len(hand_positions)
+            hand_position_dist = {
+                'front': (pos_counts.get('front', 0) / total_pos) * 100,
+                'side': (pos_counts.get('side', 0) / total_pos) * 100,
+                'back': (pos_counts.get('back', 0) / total_pos) * 100
+            }
+        else:
+            hand_position_dist = {'front': 0.0, 'side': 0.0, 'back': 0.0}
+        
+        # Calculate movement score
+        movement_score = self._calculate_movement_score(
+            avg_hand_speed, max_hand_speed, gesture_frequency,
+            body_movement_variance, jitter_level, hand_activity_percentage,
+            hand_position_dist
+        )
+        
+        # Movement category
+        if (avg_hand_speed > self.config.EXCESSIVE_MOVEMENT_THRESHOLD or 
+            gesture_frequency > self.config.HIGH_FREQUENCY or 
+            hand_activity_percentage > 80):
+            movement_category = 'excessive'
+        elif (avg_hand_speed < self.config.MINIMAL_MOVEMENT_THRESHOLD or 
+              gesture_frequency < self.config.LOW_FREQUENCY or 
+              hand_activity_percentage < 35):
+            movement_category = 'minimal'
+        else:
+            movement_category = 'balanced'
+        
+        # Body stability score
+        if jitter_level == 'low':
+            body_stability_score = 9.0
+        elif jitter_level == 'medium':
+            body_stability_score = 6.0
+        else:
+            body_stability_score = 3.0
+        
+        if avg_body_movement > 20:
+            body_stability_score -= 2.0
+        body_stability_score = max(0, min(10, body_stability_score))
+        
+        # Detect nervous gestures
+        nervous_gestures_detected = (
+            gesture_frequency > self.config.HIGH_FREQUENCY or
+            jitter_level == 'high' or
+            hand_activity_percentage > 85 or
+            max_hand_speed > 300
+        )
+        
+        # Generate recommendations
+        recommendations = self._generate_recommendations(
+            gesture_frequency, hand_position_dist, max_hand_speed,
+            hand_activity_percentage, jitter_level, avg_hand_speed,
+            movement_score
+        )
+        
+        # Log analysis
+        logger.info(f"Movement Metrics - Avg Speed: {avg_hand_speed:.2f}px, "
+                   f"Frequency: {gesture_frequency:.2f}/s, "
+                   f"Activity: {hand_activity_percentage:.1f}%, "
+                   f"Stability: {jitter_level}")
+        
+        return {
+            'gesture_analysis': {
+                'movement_score': round(movement_score, 1),
+                'movement_category': movement_category,
+                'gesture_frequency': round(gesture_frequency, 2),
+                'hand_activity_percentage': round(hand_activity_percentage, 1),
+                'body_stability_score': round(body_stability_score, 1),
+                'nervous_gestures_detected': nervous_gestures_detected,
+                'recommendations': recommendations,
+                'detailed_metrics': {
+                    'avg_hand_movement_speed': round(avg_hand_speed, 2),
+                    'max_hand_movement_speed': round(max_hand_speed, 2),
+                    'avg_body_movement': round(avg_body_movement, 2),
+                    'max_body_movement': round(max_body_movement, 2),
+                    'body_sway_intensity': jitter_level,
+                    'hand_position_distribution': {
+                        'front': round(hand_position_dist['front'], 1),
+                        'side': round(hand_position_dist['side'], 1),
+                        'back': round(hand_position_dist['back'], 1)
+                    },
+                    'gesture_peaks_detected': peaks
+                },
+                'total_frames_analyzed': len(pose_frames),
+                'video_duration': round(video_duration, 2)
+            }
+        }
+    
+    def _calculate_movement_score(
+        self,
+        avg_hand_speed: float,
+        max_hand_speed: float,
+        gesture_frequency: float,
+        body_variance: float,
+        jitter_level: str,
+        hand_activity: float,
+        hand_position_dist: Dict[str, float]
+    ) -> float:
+        """Calculate movement score (0-10) based on multiple factors"""
+        
+        score = 10.0
+        
+        # Penalty #1: Average Movement Speed
+        if avg_hand_speed > self.config.EXCESSIVE_MOVEMENT_THRESHOLD:
+            score -= 3.0
+        elif avg_hand_speed < self.config.MINIMAL_MOVEMENT_THRESHOLD:
+            score -= 2.5
+        
+        # Penalty #2: Max Speed Spikes
+        if max_hand_speed > 300:
+            score -= 2.0
+        elif max_hand_speed > 200:
+            score -= 1.0
+        
+        # Penalty #3: Gesture Frequency
+        if gesture_frequency > 4.0:
+            score -= 3.5
+        elif gesture_frequency > self.config.HIGH_FREQUENCY:
+            score -= 2.5
+        elif gesture_frequency < self.config.LOW_FREQUENCY:
+            score -= 2.0
+        
+        # Penalty #4: Body Instability
+        if jitter_level == 'high':
+            score -= 2.0
+        elif jitter_level == 'medium':
+            score -= 1.0
+        else:
+            score += 0.5  # Bonus for stability
+        
+        # Penalty #5: Hand Position - Back
+        if hand_position_dist['back'] > 35:
+            score -= 2.5
+        elif hand_position_dist['back'] > 25:
+            score -= 1.5
+        elif hand_position_dist['back'] > 15:
+            score -= 0.5
+        
+        # Penalty #6: Hand Position - Front
+        if hand_position_dist['front'] < 40:
+            score -= 2.0
+        elif hand_position_dist['front'] < 50:
+            score -= 1.0
+        elif hand_position_dist['front'] > 60:
+            score += 1.0  # Bonus
+        
+        # Penalty #7: Hand Activity
+        if hand_activity > 85:
+            score -= 1.5
+        elif hand_activity > 75:
+            score -= 0.5
+        elif hand_activity < 30:
+            score -= 1.5
+        
+        return max(0, min(10, score))
+    
+    def _generate_recommendations(
+        self,
+        gesture_frequency: float,
+        hand_position_dist: Dict[str, float],
+        max_hand_speed: float,
+        hand_activity: float,
+        jitter_level: str,
+        avg_hand_speed: float,
+        movement_score: float
+    ) -> List[str]:
+        """Generate actionable recommendations"""
+        
+        recommendations = []
+        
+        if gesture_frequency > 4.0:
+            recommendations.append("Reduce gesture frequency significantly (currently very high)")
+        elif gesture_frequency > 3.0:
+            recommendations.append("Reduce gesture frequency slightly")
+        elif gesture_frequency < 0.5:
+            recommendations.append("Increase gesture frequency for more expressiveness")
+        
+        if hand_position_dist['back'] > 30:
+            recommendations.append("Keep hands visible in front - avoid hiding behind body")
+        elif hand_position_dist['back'] > 20:
+            recommendations.append("Try to position hands more in front for better engagement")
+        
+        if hand_position_dist['front'] < 45:
+            recommendations.append("Bring hands forward more often - increases audience connection")
+        
+        if max_hand_speed > 300:
+            recommendations.append("Avoid sudden explosive movements - use smooth gestures")
+        
+        if hand_activity > 80:
+            recommendations.append("Add strategic pauses - let hands rest between key points")
+        elif hand_activity < 35:
+            recommendations.append("Increase hand activity - use more gestures to emphasize points")
+        
+        if jitter_level == 'high':
+            recommendations.append("Work on body stability - reduce nervous movements and sway")
+        
+        if avg_hand_speed > 50:
+            recommendations.append("Slow down hand movements - make gestures more deliberate")
+        elif avg_hand_speed < 5:
+            recommendations.append("Make gestures more dynamic - increase movement speed slightly")
+        
+        if movement_score >= 8.0:
+            recommendations.append("Excellent gesture control! Very natural and professional.")
+        
+        if not recommendations:
+            recommendations.append("Keep up the great work!")
+        
+        return recommendations
+    
+    def _create_empty_result(self, reason: str) -> Dict[str, Any]:
+        """Create empty result when analysis fails"""
+        return {
+            'gesture_analysis': {
+                'movement_score': 0.0,
+                'movement_category': 'unknown',
+                'gesture_frequency': 0.0,
+                'hand_activity_percentage': 0.0,
+                'body_stability_score': 0.0,
+                'nervous_gestures_detected': False,
+                'recommendations': [f"Analysis failed: {reason}"],
+                'detailed_metrics': {
+                    'avg_hand_movement_speed': 0.0,
+                    'max_hand_movement_speed': 0.0,
+                    'avg_body_movement': 0.0,
+                    'max_body_movement': 0.0,
+                    'body_sway_intensity': 'unknown',
+                    'hand_position_distribution': {
+                        'front': 0.0,
+                        'side': 0.0,
+                        'back': 0.0
+                    },
+                    'gesture_peaks_detected': 0
+                },
+                'total_frames_analyzed': 0,
+                'video_duration': 0.0
+            }
+        }

app/services/struktur_berbicara_nlp.py

@@ -0,0 +1,578 @@
+# -*- coding: utf-8 -*-
+"""Struktur_Berbicara_NLP.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/13UJp10f4bAJGPoYw--ASnK-U0JLhYdJl
+"""
+
+import os
+os.environ['WANDB_DISABLED'] = 'true'
+
+"""
+Fine-tuning IndoBERT untuk Klasifikasi Struktur Berbicara
+(Pembuka, Isi, Penutup)
+
+Requirements:
+pip install transformers torch pandas scikit-learn datasets
+"""
+
+import pandas as pd
+import torch
+from torch.utils.data import Dataset, DataLoader
+from transformers import (
+    AutoTokenizer,
+    AutoModelForSequenceClassification,
+    TrainingArguments,
+    Trainer
+)
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
+import numpy as np
+
+# ============ 1. LOAD DAN PREPROCESSING DATA ============
+
+def load_and_prepare_data(csv_path):
+    """Load data dari CSV dan siapkan untuk training"""
+    df = pd.read_csv(csv_path)
+
+    # Mapping label ke angka
+    label_map = {
+        'opening': 0,
+        'content': 1,
+        'closing': 2
+    }
+
+    df['label_id'] = df['label'].map(label_map)
+
+    # Split data: 80% train, 10% validation, 10% test
+    train_df, temp_df = train_test_split(df, test_size=0.2, random_state=42, stratify=df['label_id'])
+    val_df, test_df = train_test_split(temp_df, test_size=0.5, random_state=42, stratify=temp_df['label_id'])
+
+    print(f"Data Training: {len(train_df)}")
+    print(f"Data Validasi: {len(val_df)}")
+    print(f"Data Testing: {len(test_df)}")
+    print(f"\nDistribusi Label Training:")
+    print(train_df['label'].value_counts())
+
+    return train_df, val_df, test_df, label_map
+
+# ============ 2. CUSTOM DATASET CLASS ============
+
+class SpeechStructureDataset(Dataset):
+    """Custom Dataset untuk handling data"""
+
+    def __init__(self, texts, labels, tokenizer, max_length=128):
+        self.texts = texts
+        self.labels = labels
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+
+    def __len__(self):
+        return len(self.texts)
+
+    def __getitem__(self, idx):
+        text = str(self.texts[idx])
+        label = self.labels[idx]
+
+        encoding = self.tokenizer(
+            text,
+            add_special_tokens=True,
+            max_length=self.max_length,
+            padding='max_length',
+            truncation=True,
+            return_tensors='pt'
+        )
+
+        return {
+            'input_ids': encoding['input_ids'].flatten(),
+            'attention_mask': encoding['attention_mask'].flatten(),
+            'labels': torch.tensor(label, dtype=torch.long)
+        }
+
+# ============ 3. METRICS UNTUK EVALUASI ============
+
+def compute_metrics(pred):
+    """Fungsi untuk menghitung metrics"""
+    labels = pred.label_ids
+    preds = pred.predictions.argmax(-1)
+
+    acc = accuracy_score(labels, preds)
+
+    return {
+        'accuracy': acc,
+    }
+
+# ============ 4. TRAINING MODEL ============
+
+def train_model(train_df, val_df, label_map, model_name='indobenchmark/indobert-base-p1'):
+    """Fine-tune IndoBERT model"""
+
+    # Load tokenizer dan model
+    print(f"\nMemuat model: {model_name}")
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModelForSequenceClassification.from_pretrained(
+        model_name,
+        num_labels=len(label_map)
+    )
+
+    # Buat dataset
+    train_dataset = SpeechStructureDataset(
+        texts=train_df['text'].tolist(),
+        labels=train_df['label_id'].tolist(),
+        tokenizer=tokenizer
+    )
+
+    val_dataset = SpeechStructureDataset(
+        texts=val_df['text'].tolist(),
+        labels=val_df['label_id'].tolist(),
+        tokenizer=tokenizer
+    )
+
+    # Training arguments
+    training_args = TrainingArguments(
+        output_dir='./results',
+        num_train_epochs=30,  # Untuk dataset kecil, epoch lebih banyak
+        per_device_train_batch_size=8,
+        per_device_eval_batch_size=8,
+        warmup_steps=100,
+        weight_decay=0.01,
+        logging_dir='./logs',
+        logging_steps=10,
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        load_best_model_at_end=True,
+        metric_for_best_model="accuracy",
+        learning_rate=2e-5,
+        seed=42,
+        report_to="none",  # Disable semua logging eksternal
+        save_total_limit=2
+    )
+
+    # Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=val_dataset,
+        compute_metrics=compute_metrics
+    )
+
+    # Training
+    print("\n🚀 Mulai training...")
+    trainer.train()
+
+    # Simpan model terbaik
+    trainer.save_model('./best_model')
+    tokenizer.save_pretrained('./best_model')
+
+    print("\n✅ Training selesai! Model disimpan di './best_model'")
+
+    return trainer, tokenizer, model
+
+# ============ 5. EVALUASI MODEL ============
+
+def evaluate_model(trainer, test_df, tokenizer, label_map):
+    """Evaluasi model pada test set"""
+
+    test_dataset = SpeechStructureDataset(
+        texts=test_df['text'].tolist(),
+        labels=test_df['label_id'].tolist(),
+        tokenizer=tokenizer
+    )
+
+    # Prediksi
+    predictions = trainer.predict(test_dataset)
+    pred_labels = predictions.predictions.argmax(-1)
+    true_labels = test_df['label_id'].tolist()
+
+    # Reverse mapping untuk label
+    id_to_label = {v: k for k, v in label_map.items()}
+
+    # Classification report
+    print("\n📊 HASIL EVALUASI:")
+    print("\nClassification Report:")
+    print(classification_report(
+        true_labels,
+        pred_labels,
+        target_names=list(label_map.keys())
+    ))
+
+    # Confusion matrix
+    print("\nConfusion Matrix:")
+    cm = confusion_matrix(true_labels, pred_labels)
+    print(cm)
+
+    return predictions
+
+# ============ 6. FUNGSI PREDIKSI ============
+
+def predict_text(text, model_path='./best_model'):
+    """Prediksi label untuk teks baru"""
+
+    # Load model dan tokenizer
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    model = AutoModelForSequenceClassification.from_pretrained(model_path)
+    model.eval()
+
+    # Tokenisasi
+    inputs = tokenizer(
+        text,
+        add_special_tokens=True,
+        max_length=128,
+        padding='max_length',
+        truncation=True,
+        return_tensors='pt'
+    )
+
+    # Prediksi
+    with torch.no_grad():
+        outputs = model(**inputs)
+        predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        predicted_class = torch.argmax(predictions, dim=-1).item()
+        confidence = predictions[0][predicted_class].item()
+
+    # Mapping hasil
+    label_map = {0: 'opening', 1: 'content', 2: 'closing'}
+    predicted_label = label_map[predicted_class]
+
+    return {
+        'text': text,
+        'predicted_label': predicted_label,
+        'confidence': confidence,
+        'all_probabilities': {
+            'opening': predictions[0][0].item(),
+            'content': predictions[0][1].item(),
+            'closing': predictions[0][2].item()
+        }
+    }
+
+# ============ 7. MAIN EXECUTION ============
+
+if __name__ == "__main__":
+    # Path ke file CSV
+    CSV_PATH = '/content/drive/MyDrive/Colab Notebooks/dataset/struktur.csv'
+
+    print("="*60)
+    print("FINE-TUNING INDOBERT - KLASIFIKASI STRUKTUR BERBICARA")
+    print("="*60)
+
+    # 1. Load dan prepare data
+    train_df, val_df, test_df, label_map = load_and_prepare_data(CSV_PATH)
+
+    # 2. Training model
+    trainer, tokenizer, model = train_model(train_df, val_df, label_map)
+
+    # 3. Evaluasi model
+    evaluate_model(trainer, test_df, tokenizer, label_map)
+
+    # 4. Contoh prediksi
+    print("\n" + "="*60)
+    print("CONTOH PREDIKSI")
+    print("="*60)
+
+    test_texts = [
+        "Selamat pagi hadirin yang saya hormati",
+        "Berdasarkan data yang kami kumpulkan",
+        "Demikian yang dapat saya sampaikan terima kasih"
+    ]
+
+    for text in test_texts:
+        result = predict_text(text)
+        print(f"\nTeks: {result['text']}")
+        print(f"Prediksi: {result['predicted_label']}")
+        print(f"Confidence: {result['confidence']:.2%}")
+        print(f"Probabilitas semua kelas: {result['all_probabilities']}")
+
+    print("\n✨ Selesai!")
+
+"""
+Analisis Struktur Public Speaking
+Deteksi Opening, Content, Closing dari transkrip lengkap
+dengan scoring otomatis untuk penilaian
+"""
+
+import os
+os.environ['WANDB_DISABLED'] = 'true'
+
+import pandas as pd
+import torch
+import re
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from typing import List, Dict, Tuple
+
+# ============ 1. SENTENCE SPLITTER ============
+
+def split_into_sentences(text: str) -> List[str]:
+    """Split text menjadi kalimat-kalimat"""
+    # Split berdasarkan tanda baca
+    sentences = re.split(r'[.!?,;\n]+', text)
+    # Bersihkan whitespace dan filter kalimat kosong
+    sentences = [s.strip() for s in sentences if s.strip()]
+    return sentences
+
+# ============ 2. BATCH PREDICTION ============
+
+def predict_sentences(sentences: List[str], model_path='./best_model') -> List[Dict]:
+    """Prediksi label untuk list kalimat"""
+
+    # Load model
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    model = AutoModelForSequenceClassification.from_pretrained(model_path)
+    model.eval()
+
+    label_map = {0: 'opening', 1: 'content', 2: 'closing'}
+    results = []
+
+    for idx, sentence in enumerate(sentences):
+        # Tokenisasi
+        inputs = tokenizer(
+            sentence,
+            add_special_tokens=True,
+            max_length=128,
+            padding='max_length',
+            truncation=True,
+            return_tensors='pt'
+        )
+
+        # Prediksi
+        with torch.no_grad():
+            outputs = model(**inputs)
+            probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+            predicted_class = torch.argmax(probs, dim=-1).item()
+            confidence = probs[0][predicted_class].item()
+
+        results.append({
+            'sentence_idx': idx,
+            'text': sentence,
+            'predicted_label': label_map[predicted_class],
+            'confidence': confidence,
+            'probs': {
+                'opening': probs[0][0].item(),
+                'content': probs[0][1].item(),
+                'closing': probs[0][2].item()
+            }
+        })
+
+    return results
+
+# ============ 3. POST-PROCESSING & HEURISTICS ============
+
+def apply_structure_rules(predictions: List[Dict]) -> List[Dict]:
+    """
+    Terapkan rules untuk memperbaiki struktur:
+    - Opening di awal
+    - Closing di akhir
+    - Content di tengah
+    """
+
+    if not predictions:
+        return predictions
+
+    n = len(predictions)
+
+    # Rule 1: 2 kalimat pertama cenderung opening (jika confidence tinggi)
+    for i in range(min(2, n)):
+        if predictions[i]['probs']['opening'] > 0.8:  # Threshold
+            predictions[i]['predicted_label'] = 'opening'
+            predictions[i]['adjusted'] = True
+
+    # Rule 2: 2 kalimat terakhir cenderung closing (jika confidence tinggi)
+    for i in range(max(0, n-2), n):
+        if predictions[i]['probs']['closing'] > 0.8:  # Threshold
+            predictions[i]['predicted_label'] = 'closing'
+            predictions[i]['adjusted'] = True
+
+    # Rule 3: Detect transisi berdasarkan keyword
+    closing_keywords = ['demikian', 'terima kasih', 'sekian', 'akhir kata',
+                       'wassalam', 'selamat pagi dan', 'sampai jumpa']
+    opening_keywords = ['selamat pagi', 'selamat siang', 'assalamualaikum',
+                       'hadirin', 'pertama-tama', 'izinkan saya']
+
+    for pred in predictions:
+        text_lower = pred['text'].lower()
+
+        # Check closing keywords
+        if any(kw in text_lower for kw in closing_keywords):
+            pred['predicted_label'] = 'closing'
+            pred['keyword_match'] = True
+
+        # Check opening keywords
+        elif any(kw in text_lower for kw in opening_keywords):
+            pred['predicted_label'] = 'opening'
+            pred['keyword_match'] = True
+
+    return predictions
+
+# ============ 4. STRUCTURE SEGMENTATION ============
+
+def segment_speech_structure(predictions: List[Dict]) -> Dict:
+    """
+    Grouping kalimat berdasarkan struktur yang terdeteksi
+    """
+
+    structure = {
+        'opening': [],
+        'content': [],
+        'closing': []
+    }
+
+    for pred in predictions:
+        label = pred['predicted_label']
+        structure[label].append(pred)
+
+    return structure
+
+# ============ 5. SCORING SYSTEM ============
+
+def calculate_structure_score(structure: Dict) -> Dict:
+    """
+    Hitung skor berdasarkan kriteria:
+    - Poin 5: ada opening (1), content (1), closing (1)
+    - Poin 4: ada opening (1), content (1), closing (0)
+    - Poin 3: ada opening (1), content (0), closing (1)
+    - Poin 2: ada opening (0), content (1), closing (1)
+    - Poin 1: ada opening (1), content (0), closing (0)
+    - Poin 0: tidak ada struktur yang lengkap
+    """
+
+    has_opening = len(structure['opening']) > 0
+    has_content = len(structure['content']) > 0
+    has_closing = len(structure['closing']) > 0
+
+    # Hitung poin
+    if has_opening and has_content and has_closing:
+        score = 5
+        description = "Sempurna! Struktur lengkap (Pembuka, Isi, Penutup)"
+    elif has_opening and has_content and not has_closing:
+        score = 4
+        description = "Baik. Ada pembuka dan isi, tapi kurang penutup"
+    elif has_opening and not has_content and has_closing:
+        score = 3
+        description = "Cukup. Ada pembuka dan penutup, tapi isi kurang jelas"
+    elif not has_opening and has_content and has_closing:
+        score = 2
+        description = "Perlu perbaikan. Kurang pembuka yang jelas"
+    elif has_opening and not has_content and not has_closing:
+        score = 1
+        description = "Kurang lengkap. Hanya ada pembuka"
+    else:
+        score = 0
+        description = "Struktur tidak terdeteksi dengan baik"
+
+    return {
+        'score': score,
+        'max_score': 5,
+        'description': description,
+        'has_opening': has_opening,
+        'has_content': has_content,
+        'has_closing': has_closing,
+        'opening_count': len(structure['opening']),
+        'content_count': len(structure['content']),
+        'closing_count': len(structure['closing'])
+    }
+
+# ============ 6. MAIN ANALYSIS FUNCTION ============
+
+def analyze_speech(transcript: str, model_path='./best_model',
+                   apply_rules=True, verbose=True) -> Dict:
+    """
+    Fungsi utama untuk menganalisis struktur speech
+
+    Args:
+        transcript: Teks lengkap dari speech
+        model_path: Path ke model yang sudah di-train
+        apply_rules: Apakah menggunakan heuristic rules
+        verbose: Tampilkan detail atau tidak
+
+    Returns:
+        Dict berisi hasil analisis lengkap
+    """
+
+    # 1. Split into sentences
+    sentences = split_into_sentences(transcript)
+
+    if verbose:
+        print(f"📝 Jumlah kalimat terdeteksi: {len(sentences)}")
+
+    # 2. Predict each sentence
+    predictions = predict_sentences(sentences, model_path)
+
+    # 3. Apply rules (optional)
+    if apply_rules:
+        predictions = apply_structure_rules(predictions)
+
+    # 4. Segment structure
+    structure = segment_speech_structure(predictions)
+
+    # 5. Calculate score
+    score_result = calculate_structure_score(structure)
+
+    # 6. Generate report
+    if verbose:
+        print("\n" + "="*70)
+        print("📊 HASIL ANALISIS STRUKTUR BERBICARA")
+        print("="*70)
+
+        print(f"\n🎯 SKOR: {score_result['score']}/{score_result['max_score']}")
+        print(f"📝 {score_result['description']}")
+
+        print(f"\n✅ Struktur terdeteksi:")
+        print(f"   • Pembuka (Opening): {score_result['opening_count']} kalimat")
+        print(f"   • Isi (Content): {score_result['content_count']} kalimat")
+        print(f"   • Penutup (Closing): {score_result['closing_count']} kalimat")
+
+        print(f"\n📄 Detail per bagian:")
+        print(f"\n{'='*70}")
+
+        for section in ['opening', 'content', 'closing']:
+            if structure[section]:
+                print(f"\n🔹 {section.upper()}:")
+                for item in structure[section]:
+                    print(f"   [{item['sentence_idx']+1}] {item['text'][:80]}...")
+                    print(f"       Confidence: {item['confidence']:.2%}")
+
+        print(f"\n{'='*70}")
+
+    return {
+        'sentences': sentences,
+        'predictions': predictions,
+        'structure': structure,
+        'score': score_result,
+        'transcript': transcript
+    }
+
+
+# ============ 8. CONTOH PENGGUNAAN ============
+
+if __name__ == "__main__":
+
+    # Contoh transkrip speech
+    sample_transcript = """
+    Assalamualaikum warahmatullahi wabarakatuh. Selamat pagi hadirin yang saya hormati
+    Puji syukur kita panjatkan kehadirat Tuhan Yang Maha Esa
+
+    Pada kesempatan ini saya akan membahas tentang pentingnya pendidikan karakter
+    Menurut data dari Kemendikbud tahun 2023, tingkat literasi di Indonesia masih perlu ditingkatkan
+    Berdasarkan penelitian menunjukkan bahwa pendidikan karakter sangat penting untuk generasi muda
+    Contohnya seperti yang terjadi di negara-negara maju, mereka mengutamakan pendidikan karakter sejak dini
+
+    Oleh karena itu kita perlu bergerak bersama untuk meningkatkan kualitas pendidikan
+    Demikian yang dapat saya sampaikan
+    Terima kasih atas perhatian Bapak dan Ibu sekalian
+    Wassalamualaikum warahmatullahi wabarakatuh
+    """
+
+    print("🎤 ANALISIS STRUKTUR PUBLIC SPEAKING")
+    print("="*70)
+
+    # Jalankan analisis
+    result = analyze_speech(
+        transcript=sample_transcript,
+        model_path='./best_model',
+        apply_rules=True,
+        verbose=True
+    )
+
+    print("\n✨ Analisis selesai!")

app/services/video_processor.py

@@ -0,0 +1,319 @@
+"""
+Video Processor Orchestrator
+
+This module coordinates all AI models and creates the final analysis result.
+"""
+import cv2 as cv
+import time
+from typing import Dict, Any, Optional, Callable
+from loguru import logger
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from app.config import settings
+from app.services.eye_tracking import EyeTrackingService
+from app.services.facial_expression import FacialExpressionService
+from app.services.gesture_detection import GestureDetectionService
+from app.models import (
+    AnalysisResult,
+    VideoMetadata,
+    MainIndicators,
+    BonusIndicators,
+    IndicatorResult,
+    Level
+)
+
+
+class VideoProcessor:
+    """
+    Main video processor that orchestrates all AI models
+    """
+    
+    def __init__(self):
+        """Initialize video processor with all services"""
+        self.eye_tracking_service = None
+        self.facial_expression_service = None
+        self.gesture_service = None
+        logger.info("VideoProcessor initialized")
+    
+    def _load_models(self):
+        """Lazy load models"""
+        if self.eye_tracking_service is None:
+            logger.info("Loading Eye Tracking model...")
+            self.eye_tracking_service = EyeTrackingService()
+        
+        if self.facial_expression_service is None:
+            logger.info("Loading Facial Expression model...")
+            self.facial_expression_service = FacialExpressionService()
+        
+        if self.gesture_service is None:
+            logger.info("Loading Gesture Detection model...")
+            self.gesture_service = GestureDetectionService()
+        
+        logger.info("✓ All models loaded")
+    
+    def process_video(
+        self,
+        video_path: str,
+        level: int,
+        progress_callback: Optional[Callable] = None
+    ) -> Dict[str, Any]:
+        """
+        Process video and return analysis results
+        
+        Args:
+            video_path: Path to video file
+            level: Public speaking level (1-5)
+            progress_callback: Optional callback for progress updates
+                               Signature: callback(step: str, percentage: float, message: str)
+        
+        Returns:
+            Dict containing analysis results
+        """
+        start_time = time.time()
+        
+        try:
+            # Load models
+            if progress_callback:
+                progress_callback("loading_models", 10, "Loading AI models...")
+            self._load_models()
+            
+            # Get video metadata
+            if progress_callback:
+                progress_callback("reading_video", 15, "Reading video metadata...")
+            metadata = self._get_video_metadata(video_path)
+            
+            # Determine which indicators to process based on level
+            indicators_config = self._get_indicators_for_level(level)
+            
+            # Process all models in parallel
+            if progress_callback:
+                progress_callback("processing", 20, "Processing video with AI models...")
+            
+            results = self._process_models_parallel(
+                video_path,
+                indicators_config,
+                progress_callback
+            )
+            
+            # Build final result
+            if progress_callback:
+                progress_callback("finalizing", 90, "Building final analysis...")
+            
+            analysis_result = self._build_analysis_result(
+                level=level,
+                metadata=metadata,
+                results=results
+            )
+            
+            processing_time = time.time() - start_time
+            
+            if progress_callback:
+                progress_callback("completed", 100, f"Analysis completed in {processing_time:.2f}s")
+            
+            logger.info(f"✓ Video processed successfully in {processing_time:.2f}s")
+            
+            return analysis_result
+        
+        except Exception as e:
+            logger.error(f"✗ Video processing failed: {e}")
+            raise
+    
+    def _get_video_metadata(self, video_path: str) -> VideoMetadata:
+        """Extract video metadata"""
+        try:
+            cap = cv.VideoCapture(video_path)
+            
+            if not cap.isOpened():
+                raise ValueError(f"Cannot open video: {video_path}")
+            
+            fps = int(cap.get(cv.CAP_PROP_FPS))
+            width = int(cap.get(cv.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
+            frame_count = int(cap.get(cv.CAP_PROP_FRAME_COUNT))
+            duration = frame_count / fps if fps > 0 else 0
+            
+            cap.release()
+            
+            # Get file size
+            import os
+            file_size = os.path.getsize(video_path)
+            
+            return VideoMetadata(
+                duration=round(duration, 2),
+                fps=fps,
+                resolution=f"{width}x{height}",
+                file_size=file_size
+            )
+        
+        except Exception as e:
+            logger.error(f"Failed to get video metadata: {e}")
+            raise
+    
+    def _get_indicators_for_level(self, level: int) -> Dict[str, bool]:
+        """
+        Determine which indicators to process based on level
+        
+        Returns:
+            Dict with indicator names and whether to process them
+        """
+        config = {
+            # Main indicators (always processed if in level)
+            "kontak_mata": level >= 2,
+            "kesesuaian_topik": level >= 3,
+            "struktur_kalimat": level >= 5,
+            
+            # Bonus indicators (always processed for all levels)
+            "face_expression": True,
+            "gesture": True,
+            "first_impression": True,
+            
+            # Audio indicators (placeholder - not implemented yet)
+            "tempo": False,
+            "artikulasi": False,
+            "jeda": False,
+            "kata_pengisi": False,
+            "kata_tidak_senonoh": False
+        }
+        
+        return config
+    
+    def _process_models_parallel(
+        self,
+        video_path: str,
+        indicators_config: Dict[str, bool],
+        progress_callback: Optional[Callable] = None
+    ) -> Dict[str, Any]:
+        """
+        Process all required models in parallel
+        
+        Returns:
+            Dict with results from each model
+        """
+        results = {}
+        
+        # Define tasks to run
+        tasks = []
+        
+        # Eye tracking (for kontak_mata)
+        if indicators_config.get("kontak_mata", False):
+            tasks.append(("eye_tracking", self.eye_tracking_service.analyze_video, video_path))
+        
+        # Facial expression (always run for first_impression and face_expression)
+        if indicators_config.get("face_expression", False):
+            tasks.append(("facial_expression", self.facial_expression_service.analyze_video, video_path))
+        
+        # Gesture detection (always run)
+        if indicators_config.get("gesture", False):
+            tasks.append(("gesture", self.gesture_service.analyze_video, video_path))
+        
+        # Process tasks in parallel
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            futures = {
+                executor.submit(func, video_path): name
+                for name, func, video_path in tasks
+            }
+            
+            completed = 0
+            total = len(futures)
+            
+            for future in as_completed(futures):
+                task_name = futures[future]
+                try:
+                    result = future.result()
+                    results[task_name] = result
+                    completed += 1
+                    
+                    if progress_callback:
+                        pct = 20 + (completed / total) * 60  # 20% to 80%
+                        progress_callback(
+                            "processing",
+                            pct,
+                            f"Completed {task_name} analysis ({completed}/{total})"
+                        )
+                    
+                    logger.info(f"✓ {task_name} completed")
+                
+                except Exception as e:
+                    logger.error(f"✗ {task_name} failed: {e}")
+                    results[task_name] = {"error": str(e)}
+        
+        return results
+    
+    def _build_analysis_result(
+        self,
+        level: int,
+        metadata: VideoMetadata,
+        results: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Build final analysis result in the expected format
+        
+        Returns:
+            Dict ready to be serialized as JSON response
+        """
+        # Main indicators
+        main_indicators = {}
+        
+        # Kontak Mata (from eye tracking)
+        if "eye_tracking" in results:
+            eye_data = results["eye_tracking"]
+            main_indicators["kontak_mata"] = {
+                "score": eye_data.get("eye_contact_analysis", {}).get("score", 0),
+                "raw_data": eye_data
+            }
+        
+        # Bonus indicators
+        bonus_indicators = {}
+        
+        # First Impression (from facial expression - first 10 seconds)
+        if "facial_expression" in results:
+            face_data = results["facial_expression"]
+            bonus_indicators["first_impression"] = {
+                "detected": face_data.get("summary", {}).get("opening_smile_detected", False),
+                "raw_data": {
+                    "smile_percentage": face_data.get("summary", {}).get("opening_smile_percentage", 0),
+                    "opening_expressions": face_data.get("summary", {}).get("opening_period_expressions", [])
+                }
+            }
+            
+            # Face Expression (overall)
+            bonus_indicators["face_expression"] = {
+                "raw_data": {
+                    "dominant_expression": face_data.get("summary", {}).get("dominant_expression", "unknown"),
+                    "expression_distribution": face_data.get("summary", {}).get("expression_distribution", {})
+                }
+            }
+        
+        # Gesture
+        if "gesture" in results:
+            gesture_data = results["gesture"]
+            bonus_indicators["gesture"] = {
+                "score": gesture_data.get("gesture_analysis", {}).get("movement_score", 0),
+                "raw_data": gesture_data
+            }
+        
+        # Build final response
+        return {
+            "level": level,
+            "video_metadata": {
+                "duration": metadata.duration,
+                "fps": metadata.fps,
+                "resolution": metadata.resolution,
+                "file_size": metadata.file_size
+            },
+            "main_indicators": main_indicators,
+            "bonus_indicators": bonus_indicators,
+            "processing_time": 0  # Will be set by task handler
+        }
+
+
+# Singleton instance
+_processor_instance = None
+
+
+def get_video_processor() -> VideoProcessor:
+    """Get global video processor instance"""
+    global _processor_instance
+    if _processor_instance is None:
+        _processor_instance = VideoProcessor()
+    return _processor_instance

app/tasks.py

@@ -0,0 +1,171 @@
+"""
+Background Tasks for Video Processing
+"""
+import json
+import time
+from datetime import datetime
+from loguru import logger
+
+from app.core.redis_client import get_redis_client
+from app.core.storage import get_storage_manager
+from app.services.video_processor import VideoProcessor
+from app.models import TaskStatus
+
+
+def process_video_task(task_id: str, video_path: str, level: int):
+    """
+    Background task to process video
+    
+    This function is executed by RQ worker in the background.
+    
+    Args:
+        task_id: Unique task identifier
+        video_path: Path to uploaded video file
+        level: Public speaking level (1-5)
+    
+    Returns:
+        dict: Analysis results
+    """
+    start_time = time.time()
+    redis_client = get_redis_client().get_client()
+    task_key = f"task:{task_id}"
+    
+    try:
+        logger.info(f"📹 Processing task {task_id} (Level {level})")
+        
+        # Update task status to PROCESSING
+        update_task_status(
+            redis_client,
+            task_key,
+            TaskStatus.PROCESSING,
+            progress={
+                "current_step": "initializing",
+                "percentage": 0,
+                "message": "Initializing video processing..."
+            }
+        )
+        
+        # Initialize video processor
+        processor = VideoProcessor()
+        
+        # Update progress: Loading models
+        update_task_status(
+            redis_client,
+            task_key,
+            TaskStatus.PROCESSING,
+            progress={
+                "current_step": "loading_models",
+                "percentage": 10,
+                "message": "Loading AI models..."
+            }
+        )
+        
+        # Process video based on level
+        result = processor.process_video(
+            video_path=video_path,
+            level=level,
+            progress_callback=lambda step, pct, msg: update_task_status(
+                redis_client,
+                task_key,
+                TaskStatus.PROCESSING,
+                progress={
+                    "current_step": step,
+                    "percentage": pct,
+                    "message": msg
+                }
+            )
+        )
+        
+        # Calculate processing time
+        processing_time = time.time() - start_time
+        result["processing_time"] = round(processing_time, 2)
+        
+        # Update task status to COMPLETED
+        update_task_status(
+            redis_client,
+            task_key,
+            TaskStatus.COMPLETED,
+            result=result,
+            completed_at=datetime.utcnow().isoformat()
+        )
+        
+        logger.info(f"✅ Task {task_id} completed in {processing_time:.2f}s")
+        
+        # Cleanup video file
+        storage = get_storage_manager()
+        storage.delete_video(video_path)
+        
+        return result
+    
+    except Exception as e:
+        logger.error(f"❌ Task {task_id} failed: {e}")
+        
+        # Update task status to FAILED
+        update_task_status(
+            redis_client,
+            task_key,
+            TaskStatus.FAILED,
+            error=str(e),
+            completed_at=datetime.utcnow().isoformat()
+        )
+        
+        # Cleanup video file
+        try:
+            storage = get_storage_manager()
+            storage.delete_video(video_path)
+        except:
+            pass
+        
+        raise
+
+
+def update_task_status(
+    redis_client,
+    task_key: str,
+    status: TaskStatus,
+    progress: dict = None,
+    result: dict = None,
+    error: str = None,
+    completed_at: str = None
+):
+    """
+    Update task status in Redis
+    
+    Args:
+        redis_client: Redis client instance
+        task_key: Redis key for task
+        status: Task status
+        progress: Progress information (optional)
+        result: Analysis result (optional)
+        error: Error message (optional)
+        completed_at: Completion timestamp (optional)
+    """
+    try:
+        # Get existing task data
+        task_data_str = redis_client.get(task_key)
+        if not task_data_str:
+            logger.warning(f"Task key {task_key} not found in Redis")
+            return
+        
+        task_data = json.loads(task_data_str)
+        
+        # Update fields
+        task_data["status"] = status.value
+        
+        if progress:
+            task_data["progress"] = progress
+        
+        if result:
+            task_data["result"] = result
+        
+        if error:
+            task_data["error"] = error
+        
+        if completed_at:
+            task_data["completed_at"] = completed_at
+        
+        # Save back to Redis
+        redis_client.set(task_key, json.dumps(task_data))
+        
+    except Exception as e:
+        logger.error(f"Failed to update task status: {e}")

app/worker.py

@@ -0,0 +1,65 @@
+"""
+RQ Worker Entry Point
+"""
+import sys
+from loguru import logger
+from redis import Redis
+from rq import Worker, Queue, Connection
+
+from app.config import settings
+from app.core.redis_client import get_redis_client
+
+
+# Configure logging
+logger.remove()
+logger.add(
+    sys.stdout,
+    format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan> - <level>{message}</level>",
+    level=settings.LOG_LEVEL
+)
+logger.add(
+    "logs/swara_worker_{time:YYYY-MM-DD}.log",
+    rotation="1 day",
+    retention="7 days",
+    format="{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function} - {message}",
+    level=settings.LOG_LEVEL
+)
+
+
+def main():
+    """Start RQ worker"""
+    logger.info("=" * 70)
+    logger.info("🔧 SWARA Worker Starting...")
+    logger.info("=" * 70)
+    logger.info(f"Environment: {settings.ENV}")
+    logger.info(f"Redis URL: {settings.REDIS_URL}")
+    logger.info(f"Queue Name: {settings.TASK_QUEUE_NAME}")
+    
+    try:
+        # Connect to Redis
+        redis_client = get_redis_client()
+        redis_conn = redis_client.connect()
+        logger.info("✓ Redis connected")
+        
+        # Create queue
+        queue = Queue(settings.TASK_QUEUE_NAME, connection=redis_conn)
+        logger.info(f"✓ Queue '{settings.TASK_QUEUE_NAME}' initialized")
+        
+        logger.info("=" * 70)
+        logger.info("✓ Worker ready and listening for tasks...")
+        logger.info("=" * 70)
+        
+        # Start worker
+        with Connection(redis_conn):
+            worker = Worker([queue])
+            worker.work(with_scheduler=True)
+    
+    except KeyboardInterrupt:
+        logger.info("\n🛑 Worker interrupted by user")
+    except Exception as e:
+        logger.error(f"❌ Worker failed: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

models/.gitkeep

@@ -0,0 +1,3 @@
+# Models directory
+
+# Place your AI model files (.onnx, .pt, etc) here

models/best.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf443423d8fcd415869dcec043c4332be6f06bdd5034af0b7b31fc362ece1908
+size 10586597

requirements.txt

@@ -0,0 +1,29 @@
+# Web Framework
+fastapi==0.115.5
+uvicorn[standard]==0.32.1
+python-multipart==0.0.20
+pydantic==2.10.3
+pydantic-settings==2.6.1
+
+# Background Jobs
+rq==2.0.0
+redis==5.2.1
+
+# Computer Vision & AI
+opencv-python==4.10.0.84
+mediapipe==0.10.21
+numpy==1.26.4
+ultralytics==8.3.52
+
+# Data Processing
+pandas==2.2.3
+matplotlib==3.10.0
+scipy==1.14.1
+
+# Utilities
+python-dotenv==1.0.1
+httpx==0.28.1
+aiofiles==24.1.0
+
+# Logging & Monitoring
+loguru==0.7.3