initial commit

LICENSE

@@ -0,0 +1,30 @@
+MIT License
+
+Copyright (c) 2024 Csaba Bolyós (BladeSzaSza)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+🎭 Laban Movement Analysis - Complete Suite
+Created by: Csaba Bolyós (BladeSzaSza)
+Contact: [email protected]
+GitHub: https://github.com/bladeszasza
+LinkedIn: https://www.linkedin.com/in/csaba-bolyós-00a11767/
+Hugging Face: https://huggingface.co/BladeSzaSza 

MCP_README.md

@@ -0,0 +1,704 @@
+# MCP & Agent Integration for Laban Movement Analysis
+
+This project provides comprehensive MCP (Model Context Protocol) integration and agent-ready APIs for professional movement analysis with pose estimation, AI action recognition, and automation capabilities.
+
+## 🚀 Quick Start
+
+### 1. Install All Dependencies
+
+```bash
+# Clone the repository
+git clone https://github.com/[your-repo]/labanmovementanalysis
+cd labanmovementanalysis
+
+# Install core dependencies
+pip install -r backend/requirements.txt
+
+# Install MCP and enhanced features
+pip install -r backend/requirements-mcp.txt
+```
+
+### 2. Start the MCP Server
+
+```bash
+# Start MCP server for AI assistants
+python -m backend.mcp_server
+```
+
+### 3. Configure Your AI Assistant
+
+Add to your Claude Desktop or other MCP-compatible assistant configuration:
+
+```json
+{
+  "mcpServers": {
+    "laban-movement-analysis": {
+      "command": "python",
+      "args": ["-m", "backend.mcp_server"],
+      "env": {
+        "PYTHONPATH": "/path/to/labanmovementanalysis"
+      }
+    }
+  }
+}
+```
+
+## 🛠️ Enhanced MCP Tools
+
+### 1. `analyze_video`
+Comprehensive video analysis with enhanced features including SkateFormer AI and multiple pose models.
+
+**Parameters:**
+- `video_path` (string): Path or URL to video (supports YouTube, Vimeo, local files)
+- `model` (string, optional): Advanced pose model selection:
+  - **MediaPipe**: `mediapipe-lite`, `mediapipe-full`, `mediapipe-heavy`
+  - **MoveNet**: `movenet-lightning`, `movenet-thunder`
+  - **YOLO**: `yolo-v8-n/s/m/l`, `yolo-v11-n/s/m/l`
+
+- `enable_visualization` (boolean, optional): Generate annotated video
+- `include_keypoints` (boolean, optional): Include raw keypoint data
+- `use_skateformer` (boolean, optional): Enable AI action recognition
+
+**Examples:**
+```
+Analyze the dance video at https://youtube.com/watch?v=dQw4w9WgXcQ using SkateFormer AI
+Analyze movement in video.mp4 using yolo-v11-s model with visualization
+Process the exercise video with mediapipe-full and include keypoints
+```
+
+### 2. `get_analysis_summary`
+Get human-readable summaries with enhanced AI insights.
+
+**Parameters:**
+- `analysis_id` (string): ID from previous analysis
+
+**Enhanced Output Includes:**
+- SkateFormer action recognition results
+- Movement quality metrics (rhythm, complexity, symmetry)
+- Temporal action segmentation
+- Video source metadata (YouTube/Vimeo titles, etc.)
+
+**Example:**
+```
+Get a detailed summary of analysis dance_2024-01-01T12:00:00 including AI insights
+```
+
+### 3. `list_available_models`
+Comprehensive list of all 20+ pose estimation models with detailed specifications.
+
+**Enhanced Model Information:**
+- Performance characteristics (speed, accuracy, memory usage)
+- Recommended use cases (real-time, research, production)
+- Hardware requirements (CPU, GPU, memory)
+- Keypoint specifications (17 COCO, 33 MediaPipe)
+
+**Example:**
+```
+What pose estimation models are available for real-time processing?
+List all YOLO v11 model variants with their specifications
+```
+
+### 4. `batch_analyze`
+Enhanced batch processing with parallel execution and progress tracking.
+
+**Parameters:**
+- `video_paths` (array): List of video paths/URLs (supports mixed sources)
+- `model` (string, optional): Pose estimation model for all videos
+- `parallel` (boolean, optional): Enable parallel processing
+- `use_skateformer` (boolean, optional): Enable AI analysis for all videos
+- `output_format` (string, optional): Output format ("summary", "structured", "full")
+
+**Enhanced Features:**
+- Mixed source support (local files + YouTube URLs)
+- Progress tracking and partial results
+- Resource management and optimization
+- Failure recovery and retry logic
+
+**Examples:**
+```
+Analyze all dance videos in the playlist with SkateFormer AI
+Batch process exercise videos using yolo-v11-s with parallel execution
+```
+
+### 5. `compare_movements`
+Advanced movement comparison with AI-powered insights.
+
+**Parameters:**
+- `analysis_id1` (string): First analysis ID  
+- `analysis_id2` (string): Second analysis ID
+- `comparison_type` (string, optional): Type of comparison ("basic", "detailed", "ai_enhanced")
+
+**Enhanced Comparison Features:**
+- SkateFormer action similarity analysis
+- Movement quality comparisons (rhythm, complexity, symmetry)
+- Temporal pattern matching
+- Statistical significance testing
+
+**Example:**
+```
+Compare the movement patterns between the two dance analyses with AI insights
+Detailed comparison of exercise form between beginner and expert videos
+```
+
+### 6. `real_time_analysis` (New)
+Start/stop real-time WebRTC analysis.
+
+**Parameters:**
+- `action` (string): "start" or "stop"
+- `model` (string, optional): Real-time optimized model
+- `stream_config` (object, optional): WebRTC configuration
+
+**Example:**
+```
+Start real-time movement analysis using mediapipe-lite
+```
+
+### 7. `filter_videos_advanced` (New)
+Advanced video filtering with AI-powered criteria.
+
+**Parameters:**
+- `video_paths` (array): List of video paths/URLs
+- `criteria` (object): Enhanced filtering criteria including:
+  - Traditional LMA metrics (direction, intensity, fluidity)
+  - SkateFormer actions (dancing, jumping, etc.)
+  - Movement qualities (rhythm, complexity, symmetry)
+  - Temporal characteristics (duration, segment count)
+
+**Example:**
+```
+Filter videos for high-energy dance movements with good rhythm
+Find exercise videos with proper form (high fluidity and symmetry)
+```
+
+## 🤖 Enhanced Agent API
+
+### Comprehensive Python Agent API
+
+```python
+from gradio_labanmovementanalysis import LabanMovementAnalysis
+from gradio_labanmovementanalysis.agent_api import (
+    LabanAgentAPI,
+    PoseModel,
+    MovementDirection,
+    MovementIntensity,
+    analyze_and_summarize
+)
+
+# Initialize with all features enabled
+analyzer = LabanMovementAnalysis(
+    enable_skateformer=True,
+    enable_webrtc=True,
+    enable_visualization=True
+)
+
+agent_api = LabanAgentAPI(analyzer=analyzer)
+```
+
+### Advanced Analysis Workflows
+
+```python
+# YouTube video analysis with AI
+result = agent_api.analyze(
+    "https://youtube.com/watch?v=...",
+    model=PoseModel.YOLO_V11_S,
+    use_skateformer=True,
+    generate_visualization=True
+)
+
+# Enhanced batch processing
+results = agent_api.batch_analyze(
+    ["video1.mp4", "https://youtube.com/watch?v=...", "https://vimeo.com/..."],
+    model=PoseModel.YOLO_V11_S,
+    parallel=True,
+    use_skateformer=True
+)
+
+# AI-powered movement filtering
+filtered = agent_api.filter_by_movement_advanced(
+    video_paths,
+    skateformer_actions=["dancing", "jumping"],
+    movement_qualities={"rhythm": 0.8, "complexity": 0.6},
+    traditional_criteria={
+        "direction": MovementDirection.UP,
+        "intensity": MovementIntensity.HIGH,
+        "min_fluidity": 0.7
+    }
+)
+
+# Real-time analysis control
+agent_api.start_realtime_analysis(model=PoseModel.MEDIAPIPE_LITE)
+live_metrics = agent_api.get_realtime_metrics()
+agent_api.stop_realtime_analysis()
+```
+
+### Enhanced Quick Functions
+
+```python
+from gradio_labanmovementanalysis import (
+    quick_analyze_enhanced,
+    analyze_and_summarize_with_ai,
+    compare_videos_detailed
+)
+
+# Enhanced analysis with AI
+data = quick_analyze_enhanced(
+    "https://youtube.com/watch?v=...",
+    model="yolo-v11-s",
+    use_skateformer=True
+)
+
+# AI-powered summary
+summary = analyze_and_summarize_with_ai(
+    "dance_video.mp4",
+    include_skateformer=True,
+    detail_level="comprehensive"
+)
+
+# Detailed video comparison
+comparison = compare_videos_detailed(
+    "video1.mp4", 
+    "video2.mp4",
+    include_ai_analysis=True
+)
+```
+
+## 🌐 Enhanced Gradio 5 Agent Features
+
+### Comprehensive API Endpoints
+
+The unified Gradio 5 app exposes these endpoints optimized for agents:
+
+1. **`/analyze_standard`** - Basic LMA analysis
+2. **`/analyze_enhanced`** - Advanced analysis with all features
+3. **`/analyze_agent`** - Agent-optimized structured output
+4. **`/batch_analyze`** - Efficient multiple video processing
+5. **`/filter_videos`** - Movement-based filtering
+6. **`/compare_models`** - Model performance comparison
+7. **`/real_time_start`** - Start WebRTC real-time analysis
+8. **`/real_time_stop`** - Stop WebRTC real-time analysis
+
+### Enhanced Gradio Client Usage
+
+```python
+from gradio_client import Client
+
+# Connect to unified demo
+client = Client("http://localhost:7860")
+
+# Enhanced single analysis
+result = client.predict(
+    video_input="https://youtube.com/watch?v=...",
+    model="yolo-v11-s",
+    enable_viz=True,
+    use_skateformer=True,
+    include_keypoints=False,
+    api_name="/analyze_enhanced"
+)
+
+# Agent-optimized batch processing
+batch_results = client.predict(
+    files=["video1.mp4", "video2.mp4"],
+    model="yolo-v11-s",
+    api_name="/batch_analyze"
+)
+
+# Advanced movement filtering
+filtered_results = client.predict(
+    files=video_list,
+    direction_filter="up",
+    intensity_filter="high", 
+    fluidity_threshold=0.7,
+    expansion_threshold=0.5,
+    api_name="/filter_videos"
+)
+
+# Model comparison analysis
+comparison = client.predict(
+    video="test_video.mp4",
+    model1="mediapipe-full",
+    model2="yolo-v11-s",
+    api_name="/compare_models"
+)
+```
+
+## 📊 Enhanced Output Formats
+
+### AI-Enhanced Summary Format
+```
+🎭 Movement Analysis Summary for "Dance Performance"
+Source: YouTube (10.5 seconds, 30fps)
+Model: YOLO-v11-S with SkateFormer AI
+
+📊 Traditional LMA Metrics:
+• Primary direction: up (65% of frames)
+• Movement intensity: high (80% of frames)  
+• Average speed: fast (2.3 units/frame)
+• Fluidity score: 0.85/1.00 (very smooth)
+• Expansion score: 0.72/1.00 (moderately extended)
+
+🤖 SkateFormer AI Analysis:
+• Detected actions: dancing (95% confidence), jumping (78% confidence)
+• Movement qualities:
+  - Rhythm: 0.89/1.00 (highly rhythmic)
+  - Complexity: 0.76/1.00 (moderately complex)
+  - Symmetry: 0.68/1.00 (slightly asymmetric)
+  - Smoothness: 0.85/1.00 (very smooth)
+  - Energy: 0.88/1.00 (high energy)
+
+���️ Temporal Analysis:
+• 7 movement segments identified
+• Average segment duration: 1.5 seconds
+• Transition quality: smooth (0.82/1.00)
+
+🎯 Overall Assessment: Excellent dance performance with high energy, 
+good rhythm, and smooth transitions. Slightly asymmetric but shows 
+advanced movement complexity.
+```
+
+### Enhanced Structured Format
+```json
+{
+    "success": true,
+    "video_metadata": {
+        "source": "youtube",
+        "title": "Dance Performance",
+        "duration": 10.5,
+        "platform_id": "dQw4w9WgXcQ"
+    },
+    "model_info": {
+        "pose_model": "yolo-v11-s",
+        "ai_enhanced": true,
+        "skateformer_enabled": true
+    },
+    "lma_metrics": {
+        "direction": "up",
+        "intensity": "high",
+        "speed": "fast",
+        "fluidity": 0.85,
+        "expansion": 0.72
+    },
+    "skateformer_analysis": {
+        "actions": [
+            {"type": "dancing", "confidence": 0.95, "duration": 8.2},
+            {"type": "jumping", "confidence": 0.78, "duration": 2.3}
+        ],
+        "movement_qualities": {
+            "rhythm": 0.89,
+            "complexity": 0.76,
+            "symmetry": 0.68,
+            "smoothness": 0.85,
+            "energy": 0.88
+        },
+        "temporal_segments": 7,
+        "transition_quality": 0.82
+    },
+    "performance_metrics": {
+        "processing_time": 12.3,
+        "frames_analyzed": 315,
+        "keypoints_detected": 24
+    }
+}
+```
+
+### Comprehensive JSON Format
+Complete analysis including frame-by-frame data, SkateFormer attention maps, movement trajectories, and statistical summaries.
+
+## 🏗️ Enhanced Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    AI Assistant Integration                  │
+│          (Claude, GPT, Local Models via MCP)               │
+└─────────────────────┬───────────────────────────────────────┘
+                      │
+┌─────────────────────▼───────────────────────────────────────┐
+│                   MCP Server                                │
+│  ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐│
+│  │   Video     │ │   Enhanced  │ │      Real-time          ││
+│  │  Analysis   │ │    Batch    │ │      WebRTC             ││
+│  │   Tools     │ │ Processing  │ │     Analysis            ││
+│  └─────────────┘ └─────────────┘ └─────────────────────────┘│
+└─────────────────────┬───────────────────────────────────────┘
+                      │
+┌─────────────────────▼───────────────────────────────────────┐
+│              Enhanced Agent API Layer                       │
+│  ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐│
+│  │  Movement   │ │ AI-Enhanced │ │     Advanced            ││
+│  │  Filtering  │ │ Comparisons │ │    Workflows            ││
+│  └─────────────┘ └─────────────┘ └─────────────────────────┘│
+└─────────────────────┬───────────────────────────────────────┘
+                      │
+┌─────────────────────▼───────────────────────────────────────┐
+│             Core Analysis Engine                            │
+│                                                             │
+│  📹 Video Input    🤖 Pose Models   🎭 SkateFormer AI      │
+│  ┌─────────────┐   ┌─────────────┐   ┌─────────────────────┐│
+│  │Local Files  │   │MediaPipe(3) │   │  Action Recognition ││
+│  │YouTube URLs │   │MoveNet(2)   │   │Movement Qualities   ││
+│  │Vimeo URLs   │   │YOLO(8)      │   │Temporal Segments    ││
+│  │Direct URLs  │   │            │   │Attention Analysis   ││
+│  └─────────────┘   └─────────────┘   └─────────────────────┘│
+│                                                             │
+│  📊 LMA Engine     📹 WebRTC       🎨 Visualization        │
+│  ┌─────────────┐   ┌─────────────┐   ┌─────────────────────┐│
+│  │Direction    │   │Live Camera  │   │  Pose Overlays      ││
+│  │Intensity    │   │Real-time    │   │  Motion Trails      ││
+│  │Speed/Flow   │   │Sub-100ms    │   │  Metric Displays    ││
+│  │Expansion    │   │Adaptive FPS │   │  AI Visualizations  ││
+│  └─────────────┘   └─────────────┘   └─────────────────────┘│
+└─────────────────────────────────────────────────────────────┘
+```
+
+## 📝 Advanced Agent Workflows
+
+### 1. Comprehensive Dance Analysis Pipeline
+```python
+# Multi-source dance video analysis
+videos = [
+    "local_dance.mp4",
+    "https://youtube.com/watch?v=dance1",
+    "https://vimeo.com/dance2"
+]
+
+# Batch analyze with AI
+results = agent_api.batch_analyze(
+    videos,
+    model=PoseModel.YOLO_V11_S,
+    use_skateformer=True,
+    parallel=True
+)
+
+# Filter for high-quality performances
+excellent_dances = agent_api.filter_by_movement_advanced(
+    videos,
+    skateformer_actions=["dancing"],
+    movement_qualities={
+        "rhythm": 0.8,
+        "complexity": 0.7,
+        "energy": 0.8
+    },
+    traditional_criteria={
+        "intensity": MovementIntensity.HIGH,
+        "min_fluidity": 0.75
+    }
+)
+
+# Generate comprehensive report
+report = agent_api.generate_analysis_report(
+    results,
+    include_comparisons=True,
+    include_recommendations=True
+)
+```
+
+### 2. Real-time Exercise Form Checker
+```python
+# Start real-time analysis
+agent_api.start_realtime_analysis(
+    model=PoseModel.MEDIAPIPE_FULL,
+    enable_skateformer=True
+)
+
+# Monitor form in real-time
+while exercise_in_progress:
+    metrics = agent_api.get_realtime_metrics()
+    
+    # Check form quality
+    if metrics["fluidity"] < 0.6:
+        send_feedback("Improve movement smoothness")
+    
+    if metrics["symmetry"] < 0.7:
+        send_feedback("Balance left and right movements")
+    
+    time.sleep(0.1)  # 10Hz monitoring
+
+# Stop and get session summary
+agent_api.stop_realtime_analysis()
+session_summary = agent_api.get_session_summary()
+```
+
+### 3. Movement Pattern Research Workflow
+```python
+# Large-scale analysis for research
+research_videos = get_research_dataset()
+
+# Batch process with comprehensive analysis
+results = agent_api.batch_analyze(
+    research_videos,
+    model=PoseModel.YOLO_V11_L,  # High accuracy for research
+    use_skateformer=True,
+    include_keypoints=True,  # Full data for research
+    parallel=True
+)
+
+# Statistical analysis
+patterns = agent_api.extract_movement_patterns(
+    results,
+    pattern_types=["temporal", "spatial", "quality"],
+    clustering_method="hierarchical"
+)
+
+# Generate research insights
+insights = agent_api.generate_research_insights(
+    patterns,
+    include_visualizations=True,
+    statistical_tests=True
+)
+```
+
+## 🔧 Advanced Configuration & Customization
+
+### Environment Variables
+
+```bash
+# Core configuration
+export LABAN_DEFAULT_MODEL="mediapipe-full"
+export LABAN_CACHE_DIR="/path/to/cache"
+export LABAN_MAX_WORKERS=4
+
+# Enhanced features
+export LABAN_ENABLE_SKATEFORMER=true
+export LABAN_ENABLE_WEBRTC=true
+export LABAN_SKATEFORMER_MODEL_PATH="/path/to/skateformer"
+
+# Performance tuning
+export LABAN_GPU_ENABLED=true
+export LABAN_BATCH_SIZE=8
+export LABAN_REALTIME_FPS=30
+
+# Video download configuration
+export LABAN_YOUTUBE_QUALITY="720p"
+export LABAN_MAX_DOWNLOAD_SIZE="500MB"
+export LABAN_TEMP_DIR="/tmp/laban_downloads"
+```
+
+### Custom MCP Tools
+
+```python
+# Add custom MCP tool
+from backend.mcp_server import server
+
+@server.tool("custom_movement_analysis")
+async def custom_analysis(
+    video_path: str,
+    custom_params: dict
+) -> dict:
+    """Custom movement analysis with specific parameters."""
+    # Your custom implementation
+    return results
+
+# Register enhanced filters
+@server.tool("filter_by_sport_type")
+async def filter_by_sport(
+    videos: list,
+    sport_type: str
+) -> dict:
+    """Filter videos by detected sport type using SkateFormer."""
+    # Implementation using SkateFormer sport classification
+    return filtered_videos
+```
+
+### WebRTC Configuration
+
+```python
+# Custom WebRTC configuration
+webrtc_config = {
+    "video_constraints": {
+        "width": 1280,
+        "height": 720,
+        "frameRate": 30
+    },
+    "processing_config": {
+        "max_latency_ms": 100,
+        "quality_adaptation": True,
+        "model_switching": True
+    }
+}
+
+agent_api.configure_webrtc(webrtc_config)
+```
+
+## 🤝 Contributing to Agent Features
+
+### Adding New MCP Tools
+
+1. Define tool in `backend/mcp_server.py`
+2. Implement core logic in agent API
+3. Add comprehensive documentation
+4. Include usage examples
+5. Write integration tests
+
+### Extending Agent API
+
+1. Add methods to `LabanAgentAPI` class
+2. Ensure compatibility with existing workflows
+3. Add structured output formats
+4. Include error handling and validation
+5. Update documentation
+
+### Enhancing SkateFormer Integration
+
+1. Extend action recognition types
+2. Add custom movement quality metrics  
+3. Implement temporal analysis features
+4. Add visualization components
+5. Validate with research datasets
+
+## 📚 Resources & References
+
+- [MCP Specification](https://github.com/anthropics/mcp)
+- [SkateFormer Research Paper](https://kaist-viclab.github.io/SkateFormer_site/)
+- [Gradio 5 Documentation](https://www.gradio.app/docs)
+- [Unified Demo Application](demo/app.py)
+- [Core Component Code](backend/gradio_labanmovementanalysis/)
+
+## 🎯 Production Deployment
+
+### Docker Deployment
+
+```dockerfile
+FROM python:3.9-slim
+
+COPY . /app
+WORKDIR /app
+
+RUN pip install -r backend/requirements.txt
+RUN pip install -r backend/requirements-mcp.txt
+
+EXPOSE 7860 8080
+
+CMD ["python", "-m", "backend.mcp_server"]
+```
+
+### Kubernetes Configuration
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: laban-mcp-server
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: laban-mcp
+  template:
+    metadata:
+      labels:
+        app: laban-mcp
+    spec:
+      containers:
+      - name: mcp-server
+        image: laban-movement-analysis:latest
+        ports:
+        - containerPort: 8080
+        env:
+        - name: LABAN_MAX_WORKERS
+          value: "2"
+        - name: LABAN_ENABLE_SKATEFORMER
+          value: "true"
+```
+
+---
+
+**🤖 Transform your AI assistant into a movement analysis expert with comprehensive MCP integration and agent-ready automation.** 

README.md

@@ -1,14 +1,1144 @@
 ---
-title: Laban Movement Analysis
-emoji: 😻
+title: Laban Movement Analysis - Complete Suite
+emoji: 🎭
 colorFrom: blue
-colorTo: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.32.1
-app_file: app.py
+sdk_version: 5.0.0
+app_file: space.py
 pinned: false
-license: apache-2.0
-short_description: Professional movement analysis from pose estimation
+license: mit
+tags:
+  - laban-movement-analysis
+  - pose-estimation
+  - movement-analysis
+  - video-analysis
+  - webrtc
+  - youtube
+  - vimeo
+  - mcp
+  - agent-ready
+  - computer-vision
+  - mediapipe
+  - yolo
+  - gradio
+short_description: Professional movement analysis with pose estimation and AI
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# `gradio_labanmovementanalysis`
+<a href="https://pypi.org/project/gradio_labanmovementanalysis/" target="_blank"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/gradio_labanmovementanalysis"></a>  
+
+A Gradio 5 component for video movement analysis using Laban Movement Analysis (LMA) with MCP support for AI agents
+
+## Installation
+
+```bash
+pip install gradio_labanmovementanalysis
+```
+
+## Usage
+
+```python
+"""
+Unified Laban Movement Analysis Demo
+Comprehensive interface combining all features: 
+- Standard LMA analysis
+- Enhanced features (WebRTC, YouTube/Vimeo)
+- Agent API (batch processing, filtering)
+- Real-time analysis
+- Model comparison
+
+Created by: Csaba Bolyós (BladeSzaSza)
+Contact: [email protected]
+GitHub: https://github.com/bladeszasza
+LinkedIn: https://www.linkedin.com/in/csaba-bolyós-00a11767/
+Hugging Face: https://huggingface.co/BladeSzaSza
+
+Heavy Beta Version - Under Active Development
+"""
+
+import gradio as gr
+import sys
+from pathlib import Path
+from typing import Dict, Any, List, Tuple
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent / "backend"))
+
+from gradio_labanmovementanalysis import LabanMovementAnalysis
+
+# Import agent API if available
+try:
+    from gradio_labanmovementanalysis.agent_api import (
+        LabanAgentAPI,
+        PoseModel,
+        MovementDirection,
+        MovementIntensity
+    )
+    HAS_AGENT_API = True
+except ImportError:
+    HAS_AGENT_API = False
+
+# Import WebRTC components if available
+try:
+    from gradio_webrtc import WebRTC
+    from gradio_labanmovementanalysis.webrtc_handler import (
+        webrtc_detection,
+        get_rtc_configuration
+    )
+    HAS_WEBRTC = True
+except ImportError as e:
+    print(f"WebRTC import failed: {e}")
+    HAS_WEBRTC = False
+
+# Initialize components
+try:
+    # Initialize with WebRTC support
+    analyzer = LabanMovementAnalysis(
+        enable_webrtc=True,
+        enable_visualization=True
+    )
+    print("✅ Core features initialized successfully")
+except Exception as e:
+    print(f"Warning: Some features may not be available: {e}")
+    analyzer = LabanMovementAnalysis(enable_webrtc=False)
+
+# Initialize agent API if available
+agent_api = None
+if HAS_AGENT_API:
+    try:
+        agent_api = LabanAgentAPI()
+    except Exception as e:
+        print(f"Warning: Agent API not available: {e}")
+        agent_api = None
+
+
+def process_video_standard(video, model, enable_viz, include_keypoints):
+    """Standard video processing function."""
+    if video is None:
+        return None, None
+    
+    try:
+        json_output, video_output = analyzer.process_video(
+            video,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_output, video_output
+    except Exception as e:
+        return {"error": str(e)}, None
+
+
+def process_video_enhanced(video_input, model, enable_viz, include_keypoints):
+    """Enhanced video processing with all new features."""
+    if not video_input:
+        return {"error": "No video provided"}, None
+    
+    try:
+        # Handle both file upload and URL input
+        video_path = video_input.name if hasattr(video_input, 'name') else video_input
+        
+        json_result, viz_result = analyzer.process_video(
+            video_path,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_result, viz_result
+    except Exception as e:
+        error_result = {"error": str(e)}
+        return error_result, None
+
+
+def process_video_for_agent(video, model, output_format="summary"):
+    """Process video with agent-friendly output format."""
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not video:
+        return {"error": "No video provided"}
+    
+    try:
+        model_enum = PoseModel(model)
+        result = agent_api.analyze(video, model=model_enum, generate_visualization=False)
+        
+        if output_format == "summary":
+            return {"summary": agent_api.get_movement_summary(result)}
+        elif output_format == "structured":
+            return {
+                "success": result.success,
+                "direction": result.dominant_direction.value,
+                "intensity": result.dominant_intensity.value,
+                "speed": result.dominant_speed,
+                "fluidity": result.fluidity_score,
+                "expansion": result.expansion_score,
+                "segments": len(result.movement_segments)
+            }
+        else:  # json
+            return result.raw_data
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def batch_process_videos(files, model):
+    """Process multiple videos in batch."""
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not files:
+        return {"error": "No videos provided"}
+    
+    try:
+        video_paths = [f.name for f in files]
+        results = agent_api.batch_analyze(video_paths, model=PoseModel(model), parallel=True)
+        
+        output = {
+            "total_videos": len(results),
+            "successful": sum(1 for r in results if r.success),
+            "failed": sum(1 for r in results if not r.success),
+            "results": []
+        }
+        
+        for result in results:
+            output["results"].append({
+                "video": Path(result.video_path).name,
+                "success": result.success,
+                "summary": agent_api.get_movement_summary(result) if result.success else result.error
+            })
+        
+        return output
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def filter_videos_by_movement(files, direction, intensity, min_fluidity, min_expansion):
+    """Filter videos based on movement characteristics."""
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not files:
+        return {"error": "No videos provided"}
+    
+    try:
+        video_paths = [f.name for f in files]
+        
+        dir_filter = MovementDirection(direction) if direction != "any" else None
+        int_filter = MovementIntensity(intensity) if intensity != "any" else None
+        
+        filtered = agent_api.filter_by_movement(
+            video_paths,
+            direction=dir_filter,
+            intensity=int_filter,
+            min_fluidity=min_fluidity if min_fluidity > 0 else None,
+            min_expansion=min_expansion if min_expansion > 0 else None
+        )
+        
+        return {
+            "total_analyzed": len(video_paths),
+            "matching_videos": len(filtered),
+            "matches": [
+                {
+                    "video": Path(r.video_path).name,
+                    "direction": r.dominant_direction.value,
+                    "intensity": r.dominant_intensity.value,
+                    "fluidity": r.fluidity_score,
+                    "expansion": r.expansion_score
+                }
+                for r in filtered
+            ]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def compare_models(video, model1, model2):
+    """Compare two different pose models on the same video."""
+    if not video:
+        return "No video provided"
+    
+    try:
+        # Analyze with both models
+        result1, _ = analyzer.process_video(video, model=model1, enable_visualization=False)
+        result2, _ = analyzer.process_video(video, model=model2, enable_visualization=False)
+        
+        # Extract key metrics for comparison
+        def extract_metrics(result):
+            summary = result.get("movement_analysis", {}).get("summary", {})
+            return {
+                "direction": summary.get("direction", {}).get("dominant", "unknown"),
+                "intensity": summary.get("intensity", {}).get("dominant", "unknown"), 
+                "speed": summary.get("speed", {}).get("dominant", "unknown"),
+                "frame_count": result.get("video_info", {}).get("frame_count", 0)
+            }
+        
+        metrics1 = extract_metrics(result1)
+        metrics2 = extract_metrics(result2)
+        
+        # Create comparison table data
+        comparison_data = [
+            ["Direction", metrics1["direction"], metrics2["direction"], 
+             "✓" if metrics1["direction"] == metrics2["direction"] else "✗"],
+            ["Intensity", metrics1["intensity"], metrics2["intensity"],
+             "✓" if metrics1["intensity"] == metrics2["intensity"] else "✗"],
+            ["Speed", metrics1["speed"], metrics2["speed"],
+             "✓" if metrics1["speed"] == metrics2["speed"] else "✗"],
+            ["Frames Processed", str(metrics1["frame_count"]), str(metrics2["frame_count"]),
+             "✓" if metrics1["frame_count"] == metrics2["frame_count"] else "✗"]
+        ]
+        
+        return comparison_data
+        
+    except Exception as e:
+        return [["Error", str(e), "", ""]]
+
+
+def start_webrtc_stream(model):
+    """Start WebRTC real-time analysis."""
+    try:
+        success = analyzer.start_webrtc_stream(model)
+        if success:
+            return "🟢 Stream Active", {"status": "streaming", "model": model}
+        else:
+            return "🔴 Failed to start", {"status": "error"}
+    except Exception as e:
+        return f"🔴 Error: {str(e)}", {"status": "error"}
+
+
+def stop_webrtc_stream():
+    """Stop WebRTC real-time analysis."""
+    try:
+        success = analyzer.stop_webrtc_stream()
+        if success:
+            return "🟡 Stream Stopped", {"status": "stopped"}
+        else:
+            return "🔴 Failed to stop", {"status": "error"}
+    except Exception as e:
+        return f"🔴 Error: {str(e)}", {"status": "error"}
+
+
+def create_unified_demo():
+    """Create the unified comprehensive demo."""
+    
+    with gr.Blocks(
+        title="Laban Movement Analysis - Complete Suite by Csaba Bolyós",
+        theme=gr.themes.Soft(),
+        css="""
+        .main-header {
+            background: linear-gradient(135deg, #40826D 0%, #2E5E4A 50%, #1B3A2F 100%);
+            color: white;
+            padding: 30px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+            text-align: center;
+        }
+        .feature-card {
+            border: 1px solid #e1e5e9;
+            border-radius: 8px;
+            padding: 16px;
+            margin: 8px 0;
+            background: #f8f9fa;
+        }
+        .json-output {
+            max-height: 600px;
+            overflow-y: auto;
+            font-family: monospace;
+            font-size: 12px;
+        }
+        .author-info {
+            background: linear-gradient(135deg, #40826D 0%, #2E5E4A 100%);
+            color: white;
+            padding: 15px;
+            border-radius: 8px;
+            margin: 10px 0;
+            text-align: center;
+        }
+        """
+    ) as demo:
+        
+        # Main Header
+        gr.HTML("""
+        <div class="main-header">
+            <h1>🎭 Laban Movement Analysis - Complete Suite</h1>
+            <p style="font-size: 18px; margin: 10px 0;">
+                Professional movement analysis with pose estimation, AI action recognition, 
+                real-time processing, and agent automation
+            </p>
+            <p style="font-size: 14px; opacity: 0.9;">
+                Supports YouTube/Vimeo URLs • WebRTC Streaming • 20+ Pose Models • MCP Integration
+            </p>
+            <p style="font-size: 12px; margin-top: 15px; opacity: 0.8;">
+                <strong>Version 0.01-beta</strong> - Heavy Beta Under Active Development
+            </p>
+        </div>
+        """)
+     
+        with gr.Tabs():
+            # Tab 1: Standard Analysis
+            with gr.Tab("🎬 Standard Analysis"):
+                gr.Markdown("""
+                ### Classic Laban Movement Analysis
+                Upload a video file to analyze movement using traditional LMA metrics with pose estimation.
+                """)
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        video_input_std = gr.Video(
+                            label="Upload Video",
+                            sources=["upload"],
+                            format="mp4"
+                        )
+                        
+                        model_dropdown_std = gr.Dropdown(
+                            choices=["mediapipe", "movenet", "yolo"],
+                            value="mediapipe",
+                            label="Pose Estimation Model"
+                        )
+                        
+                        with gr.Row():
+                            enable_viz_std = gr.Checkbox(
+                                value=True,
+                                label="Generate Visualization"
+                            )
+                            
+                            include_keypoints_std = gr.Checkbox(
+                                value=False,
+                                label="Include Keypoints"
+                            )
+                        
+                        process_btn_std = gr.Button("Analyze Movement", variant="primary")
+                        
+                        gr.Examples(
+                            examples=[
+                                ["examples/balette.mov"],
+                                ["examples/balette.mp4"],
+                            ],
+                            inputs=video_input_std,
+                            label="Example Videos"
+                        )
+                    
+                    with gr.Column(scale=2):
+                        with gr.Tab("Analysis Results"):
+                            json_output_std = gr.JSON(
+                                label="Movement Analysis (JSON)",
+                                elem_classes=["json-output"]
+                            )
+                        
+                        with gr.Tab("Visualization"):
+                            video_output_std = gr.Video(
+                                label="Annotated Video",
+                                format="mp4"
+                            )
+                            
+                            gr.Markdown("""
+                            **Visualization Guide:**
+                            - 🦴 **Skeleton**: Pose keypoints and connections
+                            - 🌊 **Trails**: Motion history (fading lines)
+                            - ➡️ **Arrows**: Movement direction indicators
+                            - 🎨 **Colors**: Green (low) → Orange (medium) → Red (high) intensity
+                            """)
+                
+                process_btn_std.click(
+                    fn=process_video_standard,
+                    inputs=[video_input_std, model_dropdown_std, enable_viz_std, include_keypoints_std],
+                    outputs=[json_output_std, video_output_std],
+                    api_name="analyze_standard"
+                )
+            
+            # Tab 2: Enhanced Analysis
+            with gr.Tab("🚀 Enhanced Analysis"):
+                gr.Markdown("""
+                ### Advanced Analysis with AI and URL Support
+                Analyze videos from URLs (YouTube/Vimeo), use advanced pose models, and get AI-powered insights.
+                """)
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.HTML('<div class="feature-card">')
+                        gr.Markdown("**Video Input**")
+                        
+                        # Changed from textbox to file upload as requested
+                        video_input_enh = gr.File(
+                            label="Upload Video or Drop File",
+                            file_types=["video"],
+                            type="filepath"
+                        )
+                        
+                        # URL input option
+                        url_input_enh = gr.Textbox(
+                            label="Or Enter Video URL",
+                            placeholder="YouTube URL, Vimeo URL, or direct video URL",
+                            info="Leave file upload empty to use URL"
+                        )
+                        
+                        gr.Examples(
+                            examples=[
+                                ["examples/balette.mov"],
+                                ["https://www.youtube.com/shorts/RX9kH2l3L8U"],
+                                ["https://vimeo.com/815392738"]
+                            ],
+                            inputs=url_input_enh,
+                            label="Example URLs"
+                        )
+                        
+                        gr.Markdown("**Model Selection**")
+                        
+                        model_select_enh = gr.Dropdown(
+                            choices=[
+                                # MediaPipe variants
+                                "mediapipe-lite", "mediapipe-full", "mediapipe-heavy",
+                                # MoveNet variants  
+                                "movenet-lightning", "movenet-thunder",
+                                # YOLO variants (added X models)
+                                "yolo-v8-n", "yolo-v8-s", "yolo-v8-m", "yolo-v8-l", "yolo-v8-x",
+                                # YOLO v11 variants
+                                "yolo-v11-n", "yolo-v11-s", "yolo-v11-m", "yolo-v11-l", "yolo-v11-x"
+                            ],
+                            value="mediapipe-full",
+                            label="Advanced Pose Models",
+                            info="17+ model variants available"
+                        )
+                        
+                        gr.Markdown("**Analysis Options**")
+                        
+                        with gr.Row():
+                            enable_viz_enh = gr.Checkbox(value=True, label="Visualization")
+                        
+                        with gr.Row():
+                            include_keypoints_enh = gr.Checkbox(value=False, label="Raw Keypoints")
+                        
+                        analyze_btn_enh = gr.Button("🚀 Enhanced Analysis", variant="primary", size="lg")
+                        gr.HTML('</div>')
+                    
+                    with gr.Column(scale=2):
+                        with gr.Tab("📊 Analysis"):
+                            analysis_output_enh = gr.JSON(label="Enhanced Analysis Results")
+                        
+                        with gr.Tab("🎥 Visualization"):
+                            viz_output_enh = gr.Video(label="Annotated Video")
+                
+                def process_enhanced_input(file_input, url_input, model, enable_viz, include_keypoints):
+                    """Process either file upload or URL input."""
+                    video_source = file_input if file_input else url_input
+                    return process_video_enhanced(video_source, model, enable_viz, include_keypoints)
+                
+                analyze_btn_enh.click(
+                    fn=process_enhanced_input,
+                    inputs=[video_input_enh, url_input_enh, model_select_enh, enable_viz_enh, include_keypoints_enh],
+                    outputs=[analysis_output_enh, viz_output_enh],
+                    api_name="analyze_enhanced"
+                )
+            
+            # Tab 3: Agent API
+            with gr.Tab("🤖 Agent API"):
+                gr.Markdown("""
+                ### AI Agent & Automation Features
+                Batch processing, filtering, and structured outputs designed for AI agents and automation.
+                """)
+                
+                with gr.Tabs():
+                    with gr.Tab("Single Analysis"):
+                        with gr.Row():
+                            with gr.Column():
+                                video_input_agent = gr.Video(label="Upload Video", sources=["upload"])
+                                model_select_agent = gr.Dropdown(
+                                    choices=["mediapipe", "movenet", "yolo"],
+                                    value="mediapipe",
+                                    label="Model"
+                                )
+                                output_format_agent = gr.Radio(
+                                    choices=["summary", "structured", "json"],
+                                    value="summary",
+                                    label="Output Format"
+                                )
+                                analyze_btn_agent = gr.Button("Analyze", variant="primary")
+                            
+                            with gr.Column():
+                                output_display_agent = gr.JSON(label="Agent Output")
+                        
+                        analyze_btn_agent.click(
+                            fn=process_video_for_agent,
+                            inputs=[video_input_agent, model_select_agent, output_format_agent],
+                            outputs=output_display_agent,
+                            api_name="analyze_agent"
+                        )
+                    
+                    with gr.Tab("Batch Processing"):
+                        with gr.Row():
+                            with gr.Column():
+                                batch_files = gr.File(
+                                    label="Upload Multiple Videos",
+                                    file_count="multiple",
+                                    file_types=["video"]
+                                )
+                                batch_model = gr.Dropdown(
+                                    choices=["mediapipe", "movenet", "yolo"],
+                                    value="mediapipe",
+                                    label="Model"
+                                )
+                                batch_btn = gr.Button("Process Batch", variant="primary")
+                            
+                            with gr.Column():
+                                batch_output = gr.JSON(label="Batch Results")
+                        
+                        batch_btn.click(
+                            fn=batch_process_videos,
+                            inputs=[batch_files, batch_model],
+                            outputs=batch_output,
+                            api_name="batch_analyze"
+                        )
+                    
+                    with gr.Tab("Movement Filter"):
+                        with gr.Row():
+                            with gr.Column():
+                                filter_files = gr.File(
+                                    label="Videos to Filter",
+                                    file_count="multiple",
+                                    file_types=["video"]
+                                )
+                                
+                                with gr.Group():
+                                    direction_filter = gr.Dropdown(
+                                        choices=["any", "up", "down", "left", "right", "stationary"],
+                                        value="any",
+                                        label="Direction Filter"
+                                    )
+                                    intensity_filter = gr.Dropdown(
+                                        choices=["any", "low", "medium", "high"],
+                                        value="any",
+                                        label="Intensity Filter"
+                                    )
+                                    fluidity_threshold = gr.Slider(0.0, 1.0, 0.0, label="Min Fluidity")
+                                    expansion_threshold = gr.Slider(0.0, 1.0, 0.0, label="Min Expansion")
+                                
+                                filter_btn = gr.Button("Apply Filters", variant="primary")
+                            
+                            with gr.Column():
+                                filter_output = gr.JSON(label="Filtered Results")
+                        
+                        filter_btn.click(
+                            fn=filter_videos_by_movement,
+                            inputs=[filter_files, direction_filter, intensity_filter,
+                                   fluidity_threshold, expansion_threshold],
+                            outputs=filter_output,
+                            api_name="filter_videos"
+                        )
+            
+            # Tab 4: Real-time WebRTC
+            with gr.Tab("📹 Real-time Analysis"):
+                gr.Markdown("""
+                ### Live Camera Movement Analysis
+                Real-time pose detection and movement analysis from your webcam using WebRTC.
+                **Grant camera permissions when prompted for best experience.**
+                """)
+                
+                # Official Gradio WebRTC approach (compatible with NumPy 1.x)
+                if HAS_WEBRTC:
+                    
+                    # Get RTC configuration
+                    rtc_config = get_rtc_configuration()
+                    
+                    # Custom CSS following official guide
+                    css_webrtc = """
+                    .my-group {max-width: 480px !important; max-height: 480px !important;}
+                    .my-column {display: flex !important; justify-content: center !important; align-items: center !important;}
+                    """
+                    
+                    with gr.Column(elem_classes=["my-column"]):
+                        with gr.Group(elem_classes=["my-group"]):
+                            # Official WebRTC Component
+                            webrtc_stream = WebRTC(
+                                label="🎥 Live Camera Stream", 
+                                rtc_configuration=rtc_config
+                            )
+                        
+                            webrtc_model = gr.Dropdown(
+                                choices=["mediapipe-lite", "movenet-lightning", "yolo-v11-n"],
+                                value="mediapipe-lite",
+                                label="Pose Model",
+                                info="Optimized for real-time processing"
+                            )
+                            
+                            confidence_slider = gr.Slider(
+                                label="Detection Confidence",
+                                minimum=0.0,
+                                maximum=1.0,
+                                step=0.05,
+                                value=0.5,
+                                info="Higher = fewer false positives"
+                            )
+                    
+                    # Official WebRTC streaming setup following Gradio guide
+                    webrtc_stream.stream(
+                        fn=webrtc_detection,
+                        inputs=[webrtc_stream, webrtc_model, confidence_slider],
+                        outputs=[webrtc_stream],
+                        time_limit=10  # Following official guide: 10 seconds per user
+                    )
+                    
+                    # Info display
+                    gr.HTML("""
+                    <div style="background: #e8f4fd; padding: 15px; border-radius: 8px; margin-top: 10px;">
+                        <h4>📹 WebRTC Pose Analysis</h4>
+                        <p style="margin: 5px 0;">Real-time movement analysis using your webcam</p>
+                        
+                        <h4>🔒 Privacy</h4>
+                        <p style="margin: 5px 0;">Processing happens locally - no video data stored</p>
+                        
+                        <h4>💡 Usage</h4>
+                        <ul style="margin: 5px 0; padding-left: 20px;">
+                            <li>Grant camera permission when prompted</li>
+                            <li>Move in front of camera to see pose detection</li>
+                            <li>Adjust confidence threshold as needed</li>
+                        </ul>
+                    </div>
+                                         """)
+                    
+                else:
+                    # Fallback if WebRTC component not available  
+                    gr.HTML("""
+                    <div style="text-align: center; padding: 50px; border: 2px dashed #ff6b6b; border-radius: 8px; background: #ffe0e0;">
+                        <h3>📦 WebRTC Component Required</h3>
+                        <p><strong>To enable real-time camera analysis, install:</strong></p>
+                        <code style="background: #f0f0f0; padding: 10px; border-radius: 4px; display: block; margin: 10px 0;">
+                            pip install gradio-webrtc twilio
+                        </code>
+                        <p style="margin-top: 15px;"><em>Use Enhanced Analysis tab for video files meanwhile</em></p>
+                    </div>
+                    """)
+            
+            # Tab 5: Model Comparison
+            with gr.Tab("⚖️ Model Comparison"):
+                gr.Markdown("""
+                ### Compare Pose Estimation Models
+                Analyze the same video with different models to compare accuracy and results.
+                """)
+                
+                with gr.Column():
+                    comparison_video = gr.Video(
+                        label="Video for Comparison",
+                        sources=["upload"]
+                    )
+                    
+                    with gr.Row():
+                        model1_comp = gr.Dropdown(
+                            choices=["mediapipe-full", "movenet-thunder", "yolo-v11-s"],
+                            value="mediapipe-full",
+                            label="Model 1"
+                        )
+                        
+                        model2_comp = gr.Dropdown(
+                            choices=["mediapipe-full", "movenet-thunder", "yolo-v11-s"],
+                            value="yolo-v11-s",
+                            label="Model 2"
+                        )
+                    
+                    compare_btn = gr.Button("🔄 Compare Models", variant="primary")
+                    
+                    comparison_results = gr.DataFrame(
+                        headers=["Metric", "Model 1", "Model 2", "Match"],
+                        label="Comparison Results"
+                    )
+                
+                compare_btn.click(
+                    fn=compare_models,
+                    inputs=[comparison_video, model1_comp, model2_comp],
+                    outputs=comparison_results,
+                    api_name="compare_models"
+                )
+            
+            # Tab 6: Documentation
+            with gr.Tab("📚 Documentation"):
+                gr.Markdown("""
+                # Complete Feature Documentation
+                
+                ## 🎥 Video Input Support
+                - **Local Files**: MP4, AVI, MOV, WebM formats
+                - **YouTube**: Automatic download from YouTube URLs
+                - **Vimeo**: Automatic download from Vimeo URLs
+                - **Direct URLs**: Any direct video file URL
+                
+                ## 🤖 Pose Estimation Models
+                
+                ### MediaPipe (Google) - 33 3D Landmarks
+                - **Lite**: Fastest CPU performance
+                - **Full**: Balanced accuracy/speed (recommended)
+                - **Heavy**: Highest accuracy
+                
+                ### MoveNet (Google) - 17 COCO Keypoints  
+                - **Lightning**: Mobile-optimized, very fast
+                - **Thunder**: Higher accuracy variant
+                
+                ### YOLO (Ultralytics) - 17 COCO Keypoints
+                - **v8 variants**: n/s/m/l/x sizes (nano to extra-large)
+                - **v11 variants**: Latest with improved accuracy (n/s/m/l/x)
+                - **Multi-person**: Supports multiple people in frame
+                
+                ## 📹 Real-time WebRTC
+                
+                - **Live Camera**: Direct webcam access via WebRTC
+                - **Low Latency**: Sub-100ms processing
+                - **Adaptive Quality**: Automatic performance optimization
+                - **Live Overlay**: Real-time pose and metrics display
+                
+                ## 🤖 Agent & MCP Integration
+                
+                ### API Endpoints
+                - `/analyze_standard` - Basic LMA analysis
+                - `/analyze_enhanced` - Advanced analysis with all features
+                - `/analyze_agent` - Agent-optimized output
+                - `/batch_analyze` - Multiple video processing
+                - `/filter_videos` - Movement-based filtering
+                - `/compare_models` - Model comparison
+                
+                ### MCP Server
+                ```bash
+                # Start MCP server for AI assistants
+                python -m backend.mcp_server
+                ```
+                
+                ### Python API
+                ```python
+                from gradio_labanmovementanalysis import LabanMovementAnalysis
+                
+                # Initialize with all features
+                analyzer = LabanMovementAnalysis(
+                    enable_webrtc=True
+                )
+                
+                # Analyze YouTube video
+                result, viz = analyzer.process_video(
+                    "https://youtube.com/watch?v=...",
+                    model="yolo-v11-s"
+                )
+                ```
+                
+                ## 📊 Output Formats
+                
+                ### Summary Format
+                Human-readable movement analysis summary.
+                
+                ### Structured Format  
+                ```json
+                {
+                    "success": true,
+                    "direction": "up", 
+                    "intensity": "medium",
+                    "fluidity": 0.85,
+                    "expansion": 0.72
+                }
+                ```
+                
+                ### Full JSON Format
+                Complete frame-by-frame analysis with all metrics.
+                
+                ## 🎯 Applications
+                
+                - **Sports**: Technique analysis and performance tracking
+                - **Dance**: Choreography analysis and movement quality
+                - **Healthcare**: Physical therapy and rehabilitation
+                - **Research**: Large-scale movement pattern studies
+                - **Entertainment**: Interactive applications and games
+                - **Education**: Movement teaching and body awareness
+                
+                ## 🔗 Integration Examples
+                
+                ### Gradio Client
+                ```python
+                from gradio_client import Client
+                
+                client = Client("http://localhost:7860")
+                result = client.predict(
+                    video="path/to/video.mp4",
+                    model="mediapipe-full",
+                    api_name="/analyze_enhanced"
+                )
+                ```
+                
+                ### Batch Processing
+                ```python
+                results = client.predict(
+                    files=["video1.mp4", "video2.mp4"],
+                    model="yolo-v11-s", 
+                    api_name="/batch_analyze"
+                )
+                ```
+                """)
+                gr.HTML("""
+                        <div class="author-info">
+                            <p><strong>Created by:</strong> Csaba Bolyós (BladeSzaSza)</p>
+                            <p style="margin: 5px 0;">
+                                <a href="https://github.com/bladeszasza" style="color: #a8e6cf; text-decoration: none;">🔗 GitHub</a> • 
+                                <a href="https://huggingface.co/BladeSzaSza" style="color: #a8e6cf; text-decoration: none;">🤗 Hugging Face</a> • 
+                                <a href="https://www.linkedin.com/in/csaba-bolyós-00a11767/" style="color: #a8e6cf; text-decoration: none;">💼 LinkedIn</a>
+                            </p>
+                            <p style="font-size: 12px; opacity: 0.9;">Contact: [email protected]</p>
+                        </div>
+                        """)
+                        
+                        # Footer with proper attribution
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; margin-top: 30px; border-top: 1px solid #eee;">
+            <p style="color: #666; margin-bottom: 10px;">
+                🎭 Laban Movement Analysis - Complete Suite | Heavy Beta Version
+            </p>
+            <p style="color: #666; font-size: 12px;">
+                Created by <strong>Csaba Bolyós</strong> | Powered by MediaPipe, MoveNet & YOLO
+            </p>
+            <p style="color: #666; font-size: 10px; margin-top: 10px;">
+                <a href="https://github.com/bladeszasza" style="color: #40826D;">GitHub</a> • 
+                <a href="https://huggingface.co/BladeSzaSza" style="color: #40826D;">Hugging Face</a> • 
+                <a href="https://www.linkedin.com/in/csaba-bolyós-00a11767/" style="color: #40826D;">LinkedIn</a>
+            </p>
+        </div>
+        """)
+    
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_unified_demo()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        favicon_path=None
+    )
+
+```
+
+## `LabanMovementAnalysis`
+
+### Initialization
+
+<table>
+<thead>
+<tr>
+<th align="left">name</th>
+<th align="left" style="width: 25%;">type</th>
+<th align="left">default</th>
+<th align="left">description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td align="left"><code>default_model</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+str
+```
+
+</td>
+<td align="left"><code>"mediapipe"</code></td>
+<td align="left">Default pose estimation model ("mediapipe", "movenet", "yolo")</td>
+</tr>
+
+<tr>
+<td align="left"><code>enable_visualization</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+bool
+```
+
+</td>
+<td align="left"><code>True</code></td>
+<td align="left">Whether to generate visualization video by default</td>
+</tr>
+
+<tr>
+<td align="left"><code>include_keypoints</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+bool
+```
+
+</td>
+<td align="left"><code>False</code></td>
+<td align="left">Whether to include raw keypoints in JSON output</td>
+</tr>
+
+<tr>
+<td align="left"><code>enable_webrtc</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+bool
+```
+
+</td>
+<td align="left"><code>False</code></td>
+<td align="left">Whether to enable WebRTC real-time analysis</td>
+</tr>
+
+<tr>
+<td align="left"><code>label</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+typing.Optional[str][str, None]
+```
+
+</td>
+<td align="left"><code>None</code></td>
+<td align="left">Component label</td>
+</tr>
+
+<tr>
+<td align="left"><code>every</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+typing.Optional[float][float, None]
+```
+
+</td>
+<td align="left"><code>None</code></td>
+<td align="left">None</td>
+</tr>
+
+<tr>
+<td align="left"><code>show_label</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+typing.Optional[bool][bool, None]
+```
+
+</td>
+<td align="left"><code>None</code></td>
+<td align="left">None</td>
+</tr>
+
+<tr>
+<td align="left"><code>container</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+bool
+```
+
+</td>
+<td align="left"><code>True</code></td>
+<td align="left">None</td>
+</tr>
+
+<tr>
+<td align="left"><code>scale</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+typing.Optional[int][int, None]
+```
+
+</td>
+<td align="left"><code>None</code></td>
+<td align="left">None</td>
+</tr>
+
+<tr>
+<td align="left"><code>min_width</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+int
+```
+
+</td>
+<td align="left"><code>160</code></td>
+<td align="left">None</td>
+</tr>
+
+<tr>
+<td align="left"><code>interactive</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+typing.Optional[bool][bool, None]
+```
+
+</td>
+<td align="left"><code>None</code></td>
+<td align="left">None</td>
+</tr>
+
+<tr>
+<td align="left"><code>visible</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+bool
+```
+
+</td>
+<td align="left"><code>True</code></td>
+<td align="left">None</td>
+</tr>
+
+<tr>
+<td align="left"><code>elem_id</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+typing.Optional[str][str, None]
+```
+
+</td>
+<td align="left"><code>None</code></td>
+<td align="left">None</td>
+</tr>
+
+<tr>
+<td align="left"><code>elem_classes</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+typing.Optional[typing.List[str]][
+    typing.List[str][str], None
+]
+```
+
+</td>
+<td align="left"><code>None</code></td>
+<td align="left">None</td>
+</tr>
+
+<tr>
+<td align="left"><code>render</code></td>
+<td align="left" style="width: 25%;">
+
+```python
+bool
+```
+
+</td>
+<td align="left"><code>True</code></td>
+<td align="left">None</td>
+</tr>
+</tbody></table>
+
+
+
+
+### User function
+
+The impact on the users predict function varies depending on whether the component is used as an input or output for an event (or both).
+
+- When used as an Input, the component only impacts the input signature of the user function.
+- When used as an output, the component only impacts the return signature of the user function.
+
+The code snippet below is accurate in cases where the component is used as both an input and an output.
+
+- **As output:** Is passed, processed data for analysis.
+- **As input:** Should return, analysis results.
+
+ ```python
+ def predict(
+     value: typing.Dict[str, typing.Any][str, typing.Any]
+ ) -> typing.Any:
+     return value
+ ```
+ 

app.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""
+Laban Movement Analysis - Complete Suite
+Hugging Face Spaces Deployment
+
+Created by: Csaba Bolyós (BladeSzaSza)
+Contact: [email protected]
+GitHub: https://github.com/bladeszasza
+LinkedIn: https://www.linkedin.com/in/csaba-bolyós-00a11767/
+Hugging Face: https://huggingface.co/BladeSzaSza
+
+Heavy Beta Version - Under Active Development
+"""
+
+import sys
+from pathlib import Path
+
+# Import version info
+try:
+    from version import __version__, __author__, get_version_info
+    print(f"🎭 Laban Movement Analysis v{__version__} by {__author__}")
+except ImportError:
+    __version__ = "0.01-beta"
+    print("🎭 Laban Movement Analysis - Version info not found")
+
+# Add demo directory to path
+sys.path.insert(0, str(Path(__file__).parent / "demo"))
+
+try:
+    from app import create_unified_demo
+    
+    if __name__ == "__main__":
+        demo = create_unified_demo()
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True,
+            favicon_path=None,
+            show_api=True
+        )
+        
+except ImportError as e:
+    print(f"Import error: {e}")
+    print("Make sure all dependencies are installed.")
+    
+except Exception as e:
+    print(f"Error launching demo: {e}") 

backend/gradio_labanmovementanalysis/__init__.py

@@ -0,0 +1,51 @@
+from .labanmovementanalysis import LabanMovementAnalysis
+from . import video_utils
+from . import pose_estimation
+from . import notation_engine
+from . import json_generator
+from . import visualizer
+
+# Import agent API if available
+try:
+    from . import agent_api
+    from .agent_api import LabanAgentAPI, quick_analyze, analyze_and_summarize
+    _has_agent_api = True
+except ImportError:
+    _has_agent_api = False
+
+__all__ = [
+    'LabanMovementAnalysis',
+    'video_utils',
+    'pose_estimation', 
+    'notation_engine',
+    'json_generator',
+    'visualizer'
+]
+
+# Add agent API to exports if available
+if _has_agent_api:
+    __all__.extend(['agent_api', 'LabanAgentAPI', 'quick_analyze', 'analyze_and_summarize'])
+
+# Import enhanced features if available
+try:
+    from . import video_downloader
+    from .video_downloader import VideoDownloader, SmartVideoInput
+    __all__.extend(['video_downloader', 'VideoDownloader', 'SmartVideoInput'])
+except ImportError:
+    pass
+
+try:
+    from . import webrtc_handler
+    from .webrtc_handler import WebRTCMovementAnalyzer, WebRTCGradioInterface
+    __all__.extend(['webrtc_handler', 'WebRTCMovementAnalyzer', 'WebRTCGradioInterface'])
+except ImportError:
+    pass
+
+try:
+    # SkateFormer integration reserved for Version 2
+    # from . import skateformer_integration
+    # from .skateformer_integration import SkateFormerAnalyzer, SkateFormerConfig
+    # __all__.extend(['skateformer_integration', 'SkateFormerAnalyzer', 'SkateFormerConfig'])
+    pass
+except ImportError:
+    pass

backend/gradio_labanmovementanalysis/agent_api.py

@@ -0,0 +1,434 @@
+"""
+Agent-friendly API for Laban Movement Analysis
+Provides simplified interfaces for AI agents and automation
+"""
+
+import asyncio
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, asdict
+from enum import Enum
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Import the main component
+from .labanmovementanalysis import LabanMovementAnalysis
+
+
+class PoseModel(str, Enum):
+    """Available pose estimation models"""
+    MEDIAPIPE = "mediapipe"
+    MOVENET = "movenet" 
+    YOLO = "yolo"
+
+
+class MovementIntensity(str, Enum):
+    """Movement intensity levels"""
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class MovementDirection(str, Enum):
+    """Movement direction categories"""
+    UP = "up"
+    DOWN = "down"
+    LEFT = "left"
+    RIGHT = "right"
+    STATIONARY = "stationary"
+
+
+@dataclass
+class AnalysisResult:
+    """Structured analysis result for agents"""
+    success: bool
+    video_path: str
+    duration_seconds: float
+    fps: float
+    dominant_direction: MovementDirection
+    dominant_intensity: MovementIntensity
+    dominant_speed: str
+    movement_segments: List[Dict[str, Any]]
+    fluidity_score: float
+    expansion_score: float
+    error: Optional[str] = None
+    raw_data: Optional[Dict[str, Any]] = None
+    visualization_path: Optional[str] = None
+
+
+class LabanAgentAPI:
+    """
+    Simplified API for AI agents to analyze movement in videos.
+    Provides high-level methods with structured outputs.
+    """
+    
+    # Gradio component compatibility
+    events = {}
+    
+    def __init__(self, default_model: PoseModel = PoseModel.MEDIAPIPE):
+        """
+        Initialize the agent API.
+        
+        Args:
+            default_model: Default pose estimation model to use
+        """
+        self.analyzer = LabanMovementAnalysis(default_model=default_model.value)
+        self.default_model = default_model
+        self._analysis_cache = {}
+        
+    def analyze(
+        self,
+        video_path: Union[str, Path],
+        model: Optional[PoseModel] = None,
+        generate_visualization: bool = False,
+        cache_results: bool = True
+    ) -> AnalysisResult:
+        """
+        Analyze a video and return structured results.
+        
+        Args:
+            video_path: Path to video file
+            model: Pose estimation model to use (defaults to instance default)
+            generate_visualization: Whether to create annotated video
+            cache_results: Whether to cache results for later retrieval
+            
+        Returns:
+            AnalysisResult with structured movement data
+        """
+        try:
+            # Convert path to string
+            video_path = str(video_path)
+            
+            # Use default model if not specified
+            if model is None:
+                model = self.default_model
+                
+            # Process video
+            json_output, viz_video = self.analyzer.process_video(
+                video_path,
+                model=model.value,
+                enable_visualization=generate_visualization,
+                include_keypoints=False
+            )
+            
+            # Parse results
+            result = self._parse_analysis_output(
+                json_output, 
+                video_path,
+                viz_video
+            )
+            
+            # Cache if requested
+            if cache_results:
+                cache_key = f"{Path(video_path).stem}_{model.value}"
+                self._analysis_cache[cache_key] = result
+                
+            return result
+            
+        except Exception as e:
+            logger.error(f"Analysis failed: {str(e)}")
+            return AnalysisResult(
+                success=False,
+                video_path=str(video_path),
+                duration_seconds=0.0,
+                fps=0.0,
+                dominant_direction=MovementDirection.STATIONARY,
+                dominant_intensity=MovementIntensity.LOW,
+                dominant_speed="unknown",
+                movement_segments=[],
+                fluidity_score=0.0,
+                expansion_score=0.0,
+                error=str(e)
+            )
+    
+    async def analyze_async(
+        self,
+        video_path: Union[str, Path],
+        model: Optional[PoseModel] = None,
+        generate_visualization: bool = False
+    ) -> AnalysisResult:
+        """
+        Asynchronously analyze a video.
+        
+        Args:
+            video_path: Path to video file
+            model: Pose estimation model to use
+            generate_visualization: Whether to create annotated video
+            
+        Returns:
+            AnalysisResult with structured movement data
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(
+            None,
+            self.analyze,
+            video_path,
+            model,
+            generate_visualization
+        )
+    
+    def batch_analyze(
+        self,
+        video_paths: List[Union[str, Path]],
+        model: Optional[PoseModel] = None,
+        parallel: bool = True,
+        max_workers: int = 4
+    ) -> List[AnalysisResult]:
+        """
+        Analyze multiple videos in batch.
+        
+        Args:
+            video_paths: List of video file paths
+            model: Pose estimation model to use
+            parallel: Whether to process in parallel
+            max_workers: Maximum parallel workers
+            
+        Returns:
+            List of AnalysisResult objects
+        """
+        if parallel:
+            from concurrent.futures import ThreadPoolExecutor
+            
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                futures = [
+                    executor.submit(self.analyze, path, model, False)
+                    for path in video_paths
+                ]
+                results = [future.result() for future in futures]
+        else:
+            results = [
+                self.analyze(path, model, False)
+                for path in video_paths
+            ]
+            
+        return results
+    
+    def get_movement_summary(self, analysis_result: AnalysisResult) -> str:
+        """
+        Generate a natural language summary of movement analysis.
+        
+        Args:
+            analysis_result: Analysis result to summarize
+            
+        Returns:
+            Human-readable summary string
+        """
+        if not analysis_result.success:
+            return f"Analysis failed: {analysis_result.error}"
+            
+        summary_parts = [
+            f"Movement Analysis Summary for {Path(analysis_result.video_path).name}:",
+            f"- Duration: {analysis_result.duration_seconds:.1f} seconds",
+            f"- Primary movement direction: {analysis_result.dominant_direction.value}",
+            f"- Movement intensity: {analysis_result.dominant_intensity.value}",
+            f"- Movement speed: {analysis_result.dominant_speed}",
+            f"- Fluidity score: {analysis_result.fluidity_score:.2f}/1.00",
+            f"- Expansion score: {analysis_result.expansion_score:.2f}/1.00"
+        ]
+        
+        if analysis_result.movement_segments:
+            summary_parts.append(f"- Detected {len(analysis_result.movement_segments)} movement segments")
+            
+        return "\n".join(summary_parts)
+    
+    def compare_videos(
+        self,
+        video_path1: Union[str, Path],
+        video_path2: Union[str, Path],
+        model: Optional[PoseModel] = None
+    ) -> Dict[str, Any]:
+        """
+        Compare movement patterns between two videos.
+        
+        Args:
+            video_path1: First video path
+            video_path2: Second video path
+            model: Pose estimation model to use
+            
+        Returns:
+            Comparison results dictionary
+        """
+        # Analyze both videos
+        result1 = self.analyze(video_path1, model, False)
+        result2 = self.analyze(video_path2, model, False)
+        
+        if not result1.success or not result2.success:
+            return {
+                "success": False,
+                "error": "One or both analyses failed"
+            }
+            
+        # Compare metrics
+        comparison = {
+            "success": True,
+            "video1": Path(video_path1).name,
+            "video2": Path(video_path2).name,
+            "metrics": {
+                "direction_match": result1.dominant_direction == result2.dominant_direction,
+                "intensity_match": result1.dominant_intensity == result2.dominant_intensity,
+                "speed_match": result1.dominant_speed == result2.dominant_speed,
+                "fluidity_difference": abs(result1.fluidity_score - result2.fluidity_score),
+                "expansion_difference": abs(result1.expansion_score - result2.expansion_score)
+            },
+            "details": {
+                "video1": {
+                    "direction": result1.dominant_direction.value,
+                    "intensity": result1.dominant_intensity.value,
+                    "speed": result1.dominant_speed,
+                    "fluidity": result1.fluidity_score,
+                    "expansion": result1.expansion_score
+                },
+                "video2": {
+                    "direction": result2.dominant_direction.value,
+                    "intensity": result2.dominant_intensity.value,
+                    "speed": result2.dominant_speed,
+                    "fluidity": result2.fluidity_score,
+                    "expansion": result2.expansion_score
+                }
+            }
+        }
+        
+        return comparison
+    
+    def filter_by_movement(
+        self,
+        video_paths: List[Union[str, Path]],
+        direction: Optional[MovementDirection] = None,
+        intensity: Optional[MovementIntensity] = None,
+        min_fluidity: Optional[float] = None,
+        min_expansion: Optional[float] = None
+    ) -> List[AnalysisResult]:
+        """
+        Filter videos based on movement characteristics.
+        
+        Args:
+            video_paths: List of video paths to analyze
+            direction: Filter by movement direction
+            intensity: Filter by movement intensity
+            min_fluidity: Minimum fluidity score
+            min_expansion: Minimum expansion score
+            
+        Returns:
+            List of AnalysisResults that match criteria
+        """
+        # Analyze all videos
+        results = self.batch_analyze(video_paths)
+        
+        # Apply filters
+        filtered = []
+        for result in results:
+            if not result.success:
+                continue
+                
+            if direction and result.dominant_direction != direction:
+                continue
+                
+            if intensity and result.dominant_intensity != intensity:
+                continue
+                
+            if min_fluidity and result.fluidity_score < min_fluidity:
+                continue
+                
+            if min_expansion and result.expansion_score < min_expansion:
+                continue
+                
+            filtered.append(result)
+            
+        return filtered
+    
+    def _parse_analysis_output(
+        self,
+        json_output: Dict[str, Any],
+        video_path: str,
+        viz_path: Optional[str]
+    ) -> AnalysisResult:
+        """Parse JSON output into structured result"""
+        try:
+            # Extract video info
+            video_info = json_output.get("video_info", {})
+            duration = video_info.get("duration_seconds", 0.0)
+            fps = video_info.get("fps", 0.0)
+            
+            # Extract movement summary
+            movement_analysis = json_output.get("movement_analysis", {})
+            summary = movement_analysis.get("summary", {})
+            
+            # Parse dominant metrics
+            direction_data = summary.get("direction", {})
+            dominant_direction = direction_data.get("dominant", "stationary")
+            dominant_direction = MovementDirection(dominant_direction.lower())
+            
+            intensity_data = summary.get("intensity", {})
+            dominant_intensity = intensity_data.get("dominant", "low")
+            dominant_intensity = MovementIntensity(dominant_intensity.lower())
+            
+            speed_data = summary.get("speed", {})
+            dominant_speed = speed_data.get("dominant", "unknown")
+            
+            # Get segments
+            segments = summary.get("movement_segments", [])
+            
+            # Calculate aggregate scores
+            frames = movement_analysis.get("frames", [])
+            fluidity_scores = [f.get("metrics", {}).get("fluidity", 0) for f in frames]
+            expansion_scores = [f.get("metrics", {}).get("expansion", 0) for f in frames]
+            
+            avg_fluidity = sum(fluidity_scores) / len(fluidity_scores) if fluidity_scores else 0.0
+            avg_expansion = sum(expansion_scores) / len(expansion_scores) if expansion_scores else 0.0
+            
+            return AnalysisResult(
+                success=True,
+                video_path=video_path,
+                duration_seconds=duration,
+                fps=fps,
+                dominant_direction=dominant_direction,
+                dominant_intensity=dominant_intensity,
+                dominant_speed=dominant_speed,
+                movement_segments=segments,
+                fluidity_score=avg_fluidity,
+                expansion_score=avg_expansion,
+                raw_data=json_output,
+                visualization_path=viz_path
+            )
+            
+        except Exception as e:
+            logger.error(f"Failed to parse analysis output: {str(e)}")
+            return AnalysisResult(
+                success=False,
+                video_path=video_path,
+                duration_seconds=0.0,
+                fps=0.0,
+                dominant_direction=MovementDirection.STATIONARY,
+                dominant_intensity=MovementIntensity.LOW,
+                dominant_speed="unknown",
+                movement_segments=[],
+                fluidity_score=0.0,
+                expansion_score=0.0,
+                error=f"Parse error: {str(e)}",
+                raw_data=json_output
+            )
+
+
+# Convenience functions for quick analysis
+def quick_analyze(video_path: Union[str, Path]) -> Dict[str, Any]:
+    """Quick analysis with default settings, returns dict"""
+    api = LabanAgentAPI()
+    result = api.analyze(video_path)
+    return asdict(result)
+
+# Gradio component compatibility
+quick_analyze.events = {}
+
+
+def analyze_and_summarize(video_path: Union[str, Path]) -> str:
+    """Analyze video and return natural language summary"""
+    api = LabanAgentAPI()
+    result = api.analyze(video_path)
+    return api.get_movement_summary(result)
+
+# Gradio component compatibility
+analyze_and_summarize.events = {} 

backend/gradio_labanmovementanalysis/json_generator.py

@@ -0,0 +1,250 @@
+"""
+JSON generator for converting movement annotations and keypoint data to structured JSON format.
+"""
+
+import json
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+from .pose_estimation import PoseResult, Keypoint
+from .notation_engine import MovementMetrics, Direction, Intensity, Speed
+
+
+def generate_json(
+    movement_metrics: List[MovementMetrics],
+    pose_results: Optional[List[List[PoseResult]]] = None,
+    video_metadata: Optional[Dict[str, Any]] = None,
+    include_keypoints: bool = False
+) -> Dict[str, Any]:
+    """
+    Generate structured JSON output from movement analysis results.
+    
+    Args:
+        movement_metrics: List of movement metrics per frame
+        pose_results: Optional pose keypoints per frame
+        video_metadata: Optional video metadata (fps, dimensions, etc.)
+        include_keypoints: Whether to include raw keypoint data
+        
+    Returns:
+        Dictionary containing formatted analysis results
+    """
+    output = {
+        "analysis_metadata": {
+            "timestamp": datetime.now().isoformat(),
+            "version": "1.0.0",
+            "model_info": video_metadata.get("model_info", {}) if video_metadata else {}
+        },
+        "video_info": {},
+        "movement_analysis": {
+            "frame_count": len(movement_metrics),
+            "frames": []
+        }
+    }
+    
+    # Add video metadata if provided
+    if video_metadata:
+        output["video_info"] = {
+            "fps": video_metadata.get("fps", 30.0),
+            "duration_seconds": len(movement_metrics) / video_metadata.get("fps", 30.0),
+            "width": video_metadata.get("width"),
+            "height": video_metadata.get("height"),
+            "frame_count": video_metadata.get("frame_count", len(movement_metrics))
+        }
+    
+    # Process each frame's metrics
+    for i, metrics in enumerate(movement_metrics):
+        frame_data = {
+            "frame_index": metrics.frame_index,
+            "timestamp": metrics.timestamp,
+            "metrics": {
+                "direction": metrics.direction.value,
+                "intensity": metrics.intensity.value,
+                "speed": metrics.speed.value,
+                "velocity": round(metrics.velocity, 4),
+                "acceleration": round(metrics.acceleration, 4),
+                "fluidity": round(metrics.fluidity, 3),
+                "expansion": round(metrics.expansion, 3),
+                "total_displacement": round(metrics.total_displacement, 4)
+            }
+        }
+        
+        # Add displacement if available
+        if metrics.center_displacement:
+            frame_data["metrics"]["center_displacement"] = {
+                "x": round(metrics.center_displacement[0], 4),
+                "y": round(metrics.center_displacement[1], 4)
+            }
+        
+        # Add keypoints if requested and available
+        if include_keypoints and pose_results and i < len(pose_results):
+            frame_poses = pose_results[i]
+            if frame_poses:
+                frame_data["keypoints"] = []
+                for pose in frame_poses:
+                    keypoint_data = {
+                        "person_id": pose.person_id,
+                        "points": []
+                    }
+                    for kp in pose.keypoints:
+                        keypoint_data["points"].append({
+                            "name": kp.name,
+                            "x": round(kp.x, 4),
+                            "y": round(kp.y, 4),
+                            "confidence": round(kp.confidence, 3)
+                        })
+                    frame_data["keypoints"].append(keypoint_data)
+        
+        output["movement_analysis"]["frames"].append(frame_data)
+    
+    # Add summary statistics
+    output["movement_analysis"]["summary"] = _generate_summary(movement_metrics)
+    
+    return output
+
+
+def _generate_summary(metrics: List[MovementMetrics]) -> Dict[str, Any]:
+    """Generate summary statistics from movement metrics."""
+    if not metrics:
+        return {}
+    
+    # Count occurrences of each category
+    direction_counts = {}
+    intensity_counts = {}
+    speed_counts = {}
+    
+    velocities = []
+    accelerations = []
+    fluidities = []
+    expansions = []
+    
+    for m in metrics:
+        # Count categories
+        direction_counts[m.direction.value] = direction_counts.get(m.direction.value, 0) + 1
+        intensity_counts[m.intensity.value] = intensity_counts.get(m.intensity.value, 0) + 1
+        speed_counts[m.speed.value] = speed_counts.get(m.speed.value, 0) + 1
+        
+        # Collect numeric values
+        velocities.append(m.velocity)
+        accelerations.append(m.acceleration)
+        fluidities.append(m.fluidity)
+        expansions.append(m.expansion)
+    
+    # Calculate statistics
+    import numpy as np
+    
+    summary = {
+        "direction": {
+            "distribution": direction_counts,
+            "dominant": max(direction_counts, key=direction_counts.get)
+        },
+        "intensity": {
+            "distribution": intensity_counts,
+            "dominant": max(intensity_counts, key=intensity_counts.get)
+        },
+        "speed": {
+            "distribution": speed_counts,
+            "dominant": max(speed_counts, key=speed_counts.get)
+        },
+        "velocity": {
+            "mean": round(float(np.mean(velocities)), 4),
+            "std": round(float(np.std(velocities)), 4),
+            "min": round(float(np.min(velocities)), 4),
+            "max": round(float(np.max(velocities)), 4)
+        },
+        "acceleration": {
+            "mean": round(float(np.mean(accelerations)), 4),
+            "std": round(float(np.std(accelerations)), 4),
+            "min": round(float(np.min(accelerations)), 4),
+            "max": round(float(np.max(accelerations)), 4)
+        },
+        "fluidity": {
+            "mean": round(float(np.mean(fluidities)), 3),
+            "std": round(float(np.std(fluidities)), 3)
+        },
+        "expansion": {
+            "mean": round(float(np.mean(expansions)), 3),
+            "std": round(float(np.std(expansions)), 3)
+        }
+    }
+    
+    # Identify significant movement segments
+    summary["movement_segments"] = _identify_movement_segments(metrics)
+    
+    return summary
+
+
+def _identify_movement_segments(metrics: List[MovementMetrics]) -> List[Dict[str, Any]]:
+    """Identify significant movement segments (e.g., bursts of activity)."""
+    segments = []
+    
+    # Simple segmentation based on intensity changes
+    current_segment = None
+    intensity_threshold = Intensity.MEDIUM
+    
+    for i, m in enumerate(metrics):
+        if m.intensity.value >= intensity_threshold.value:
+            if current_segment is None:
+                # Start new segment
+                current_segment = {
+                    "start_frame": i,
+                    "start_time": m.timestamp,
+                    "peak_velocity": m.velocity,
+                    "dominant_direction": m.direction.value
+                }
+            else:
+                # Update segment
+                if m.velocity > current_segment["peak_velocity"]:
+                    current_segment["peak_velocity"] = m.velocity
+                    current_segment["dominant_direction"] = m.direction.value
+        else:
+            if current_segment is not None:
+                # End segment
+                current_segment["end_frame"] = i - 1
+                current_segment["end_time"] = metrics[i-1].timestamp if i > 0 else 0
+                current_segment["duration"] = (
+                    current_segment["end_time"] - current_segment["start_time"]
+                )
+                current_segment["peak_velocity"] = round(current_segment["peak_velocity"], 4)
+                segments.append(current_segment)
+                current_segment = None
+    
+    # Handle segment that extends to end
+    if current_segment is not None:
+        current_segment["end_frame"] = len(metrics) - 1
+        current_segment["end_time"] = metrics[-1].timestamp
+        current_segment["duration"] = (
+            current_segment["end_time"] - current_segment["start_time"]
+        )
+        current_segment["peak_velocity"] = round(current_segment["peak_velocity"], 4)
+        segments.append(current_segment)
+    
+    return segments
+
+
+def save_json(data: Dict[str, Any], output_path: str, pretty: bool = True) -> None:
+    """
+    Save JSON data to file.
+    
+    Args:
+        data: Dictionary to save
+        output_path: Path to output file
+        pretty: Whether to format JSON with indentation
+    """
+    with open(output_path, 'w') as f:
+        if pretty:
+            json.dump(data, f, indent=2, sort_keys=False)
+        else:
+            json.dump(data, f)
+
+
+def format_for_display(data: Dict[str, Any]) -> str:
+    """
+    Format JSON data for display in Gradio.
+    
+    Args:
+        data: Dictionary to format
+        
+    Returns:
+        Formatted JSON string
+    """
+    return json.dumps(data, indent=2, sort_keys=False) 

backend/gradio_labanmovementanalysis/labanmovementanalysis.py

@@ -0,0 +1,442 @@
+"""
+Custom Gradio v5 component for video-based pose analysis with LMA-inspired metrics.
+"""
+
+import gradio as gr
+from gradio.components.base import Component
+from typing import Dict, Any, Optional, Tuple, List, Union
+import tempfile
+import os
+import numpy as np
+
+from .video_utils import extract_frames, get_video_info
+from .pose_estimation import get_pose_estimator
+from .notation_engine import analyze_pose_sequence
+from .json_generator import generate_json, format_for_display
+from .visualizer import PoseVisualizer
+from .video_downloader import SmartVideoInput
+
+# Advanced features reserved for Version 2
+# SkateFormer AI integration will be available in future release
+
+try:
+    from .webrtc_handler import WebRTCMovementAnalyzer, WebRTCGradioInterface
+    HAS_WEBRTC = True
+except ImportError:
+    HAS_WEBRTC = False
+
+
+# SkateFormerCompatibility class removed for Version 1 stability
+# Will be reimplemented in Version 2 with enhanced AI features
+
+
+class LabanMovementAnalysis(Component):
+    """
+    Gradio component for video-based pose analysis with Laban Movement Analysis metrics.
+    """
+    
+    # Component metadata
+    COMPONENT_TYPE = "composite"
+    DEFAULT_MODEL = "mediapipe"
+    
+    def __init__(self,
+                 default_model: str = DEFAULT_MODEL,
+                 enable_visualization: bool = True,
+                 include_keypoints: bool = False,
+                 enable_webrtc: bool = False,
+                 label: Optional[str] = None,
+                 every: Optional[float] = None,
+                 show_label: Optional[bool] = None,
+                 container: bool = True,
+                 scale: Optional[int] = None,
+                 min_width: int = 160,
+                 interactive: Optional[bool] = None,
+                 visible: bool = True,
+                 elem_id: Optional[str] = None,
+                 elem_classes: Optional[List[str]] = None,
+                 render: bool = True,
+                 **kwargs):
+        """
+        Initialize the Laban Movement Analysis component.
+        
+        Args:
+            default_model: Default pose estimation model ("mediapipe", "movenet", "yolo")
+            enable_visualization: Whether to generate visualization video by default
+            include_keypoints: Whether to include raw keypoints in JSON output
+            enable_webrtc: Whether to enable WebRTC real-time analysis
+            label: Component label
+            ... (other standard Gradio component args)
+        """
+        super().__init__(
+            label=label,
+            every=every,
+            show_label=show_label,
+            container=container,
+            scale=scale,
+            min_width=min_width,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+            **kwargs
+        )
+        
+        self.default_model = default_model
+        self.enable_visualization = enable_visualization
+        self.include_keypoints = include_keypoints
+        self.enable_webrtc = enable_webrtc and HAS_WEBRTC
+        
+        # Cache for pose estimators
+        self._estimators = {}
+        
+        # Video input handler for URLs
+        self.video_input = SmartVideoInput()
+        
+        # SkateFormer features reserved for Version 2
+        
+        self.webrtc_analyzer = None
+        if self.enable_webrtc:
+            try:
+                self.webrtc_analyzer = WebRTCMovementAnalyzer(model=default_model)
+            except Exception as e:
+                print(f"Warning: Failed to initialize WebRTC: {e}")
+                self.enable_webrtc = False
+    
+    def preprocess(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Preprocess input from the frontend.
+        
+        Args:
+            payload: Input data containing video file and options
+            
+        Returns:
+            Processed data for analysis
+        """
+        if not payload:
+            return None
+            
+        # Extract video file path
+        video_data = payload.get("video")
+        if not video_data:
+            return None
+            
+        # Handle different input formats
+        if isinstance(video_data, str):
+            video_path = video_data
+        elif isinstance(video_data, dict):
+            video_path = video_data.get("path") or video_data.get("name")
+        else:
+            # Assume it's a file object
+            video_path = video_data.name if hasattr(video_data, "name") else str(video_data)
+        
+        # Extract options
+        options = {
+            "video_path": video_path,
+            "model": payload.get("model", self.default_model),
+            "enable_visualization": payload.get("enable_visualization", self.enable_visualization),
+            "include_keypoints": payload.get("include_keypoints", self.include_keypoints)
+        }
+        
+        return options
+    
+    def postprocess(self, value: Any) -> Dict[str, Any]:
+        """
+        Postprocess analysis results for the frontend.
+        
+        Args:
+            value: Analysis results
+            
+        Returns:
+            Formatted output for display
+        """
+        if value is None:
+            return {"json_output": {}, "video_output": None}
+        
+        # Ensure we have the expected format
+        if isinstance(value, tuple) and len(value) == 2:
+            json_data, video_path = value
+        else:
+            json_data = value
+            video_path = None
+        
+        return {
+            "json_output": json_data,
+            "video_output": video_path
+        }
+    
+    def process_video(self, video_input: Union[str, os.PathLike], model: str = DEFAULT_MODEL,
+                     enable_visualization: bool = True,
+                     include_keypoints: bool = False) -> Tuple[Dict[str, Any], Optional[str]]:
+        """
+        Main processing function that performs pose analysis on a video.
+        
+        Args:
+            video_input: Path to input video, video URL (YouTube/Vimeo), or file object
+            model: Pose estimation model to use (supports enhanced syntax like "yolo-v11-s")
+            enable_visualization: Whether to generate visualization video
+            include_keypoints: Whether to include keypoints in JSON
+            
+        Returns:
+            Tuple of (analysis_json, visualization_video_path)
+        """
+        # Handle video input (local file, URL, etc.)
+        try:
+            video_path, video_metadata = self.video_input.process_input(str(video_input))
+            print(f"Processing video: {video_metadata.get('title', 'Unknown')}")
+            if video_metadata.get('platform') in ['youtube', 'vimeo']:
+                print(f"Downloaded from {video_metadata['platform']}")
+        except Exception as e:
+            raise ValueError(f"Failed to process video input: {str(e)}")
+        # Get video metadata
+        frame_count, fps, (width, height) = get_video_info(video_path)
+        
+        # Create or get pose estimator
+        if model not in self._estimators:
+            self._estimators[model] = get_pose_estimator(model)
+        estimator = self._estimators[model]
+        
+        # Process video frame by frame
+        print(f"Processing {frame_count} frames with {model} model...")
+        
+        all_frames = []
+        all_pose_results = []
+        
+        for i, frame in enumerate(extract_frames(video_path)):
+            # Store frame if visualization is needed
+            if enable_visualization:
+                all_frames.append(frame)
+            
+            # Detect poses
+            pose_results = estimator.detect(frame)
+            
+            # Update frame indices
+            for result in pose_results:
+                result.frame_index = i
+            
+            all_pose_results.append(pose_results)
+            
+            # Progress indicator
+            if i % 30 == 0:
+                print(f"Processed {i}/{frame_count} frames...")
+        
+        print("Analyzing movement patterns...")
+        
+        # Analyze movement
+        movement_metrics = analyze_pose_sequence(all_pose_results, fps=fps)
+        
+        # Enhanced AI analysis reserved for Version 2
+        print("LMA analysis complete - advanced AI features coming in Version 2!")
+        
+        # Generate JSON output
+        video_metadata = {
+            "fps": fps,
+            "width": width,
+            "height": height,
+            "frame_count": frame_count,
+            "model_info": {
+                "name": model,
+                "type": "pose_estimation"
+            },
+            "input_metadata": video_metadata  # Include video source metadata
+        }
+        
+        json_output = generate_json(
+            movement_metrics,
+            all_pose_results if include_keypoints else None,
+            video_metadata,
+            include_keypoints=include_keypoints
+        )
+        
+        # Enhanced AI analysis will be added in Version 2
+        
+        # Generate visualization if requested
+        visualization_path = None
+        if enable_visualization:
+            print("Generating visualization video...")
+            
+            # Create temporary output file
+            with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp:
+                visualization_path = tmp.name
+            
+            # Create visualizer
+            visualizer = PoseVisualizer(
+                show_trails=True,
+                show_skeleton=True,
+                show_direction_arrows=True,
+                show_metrics=True
+            )
+            
+            # Generate overlay video
+            visualization_path = visualizer.generate_overlay_video(
+                all_frames,
+                all_pose_results,
+                movement_metrics,
+                visualization_path,
+                fps
+            )
+            
+            print(f"Visualization saved to: {visualization_path}")
+        
+        return json_output, visualization_path
+    
+    def __call__(self, video_path: str, **kwargs) -> Tuple[Dict[str, Any], Optional[str]]:
+        """
+        Make the component callable for easy use.
+        
+        Args:
+            video_path: Path to video file
+            **kwargs: Additional options
+            
+        Returns:
+            Analysis results
+        """
+        return self.process_video(video_path, **kwargs)
+    
+    def start_webrtc_stream(self, model: str = None) -> bool:
+        """
+        Start WebRTC real-time analysis stream.
+        
+        Args:
+            model: Pose model to use for real-time analysis
+            
+        Returns:
+            True if stream started successfully
+        """
+        if not self.enable_webrtc or not self.webrtc_analyzer:
+            print("WebRTC not enabled or available")
+            return False
+            
+        try:
+            if model:
+                self.webrtc_analyzer.model = model
+                self.webrtc_analyzer.pose_estimator = get_pose_estimator(model)
+            
+            self.webrtc_analyzer.start_stream()
+            print(f"WebRTC stream started with {self.webrtc_analyzer.model} model")
+            return True
+        except Exception as e:
+            print(f"Failed to start WebRTC stream: {e}")
+            return False
+    
+    def stop_webrtc_stream(self) -> bool:
+        """
+        Stop WebRTC real-time analysis stream.
+        
+        Returns:
+            True if stream stopped successfully
+        """
+        if not self.webrtc_analyzer:
+            return False
+            
+        try:
+            self.webrtc_analyzer.stop_stream()
+            print("WebRTC stream stopped")
+            return True
+        except Exception as e:
+            print(f"Failed to stop WebRTC stream: {e}")
+            return False
+    
+    def get_webrtc_interface(self):
+        """
+        Get WebRTC Gradio interface for real-time streaming.
+        
+        Returns:
+            WebRTCGradioInterface instance or None
+        """
+        if not self.enable_webrtc or not self.webrtc_analyzer:
+            return None
+            
+        return WebRTCGradioInterface(self.webrtc_analyzer)
+    
+    # SkateFormer methods moved to Version 2 development
+    # get_skateformer_compatibility() and get_skateformer_status_report() 
+    # will be available in the next major release
+    
+    def cleanup(self):
+        """Clean up temporary files and resources."""
+        # Clean up video input handler
+        if hasattr(self, 'video_input'):
+            self.video_input.cleanup()
+        
+        # Stop WebRTC if running
+        if self.webrtc_analyzer and self.webrtc_analyzer.is_running:
+            self.stop_webrtc_stream()
+    
+    def example_payload(self) -> Dict[str, Any]:
+        """Example input payload for documentation."""
+        return {
+            "video": {"path": "/path/to/video.mp4"},
+            "model": "mediapipe",
+            "enable_visualization": True,
+            "include_keypoints": False
+        }
+    
+    def example_value(self) -> Dict[str, Any]:
+        """Example output value for documentation."""
+        return {
+            "json_output": {
+                "analysis_metadata": {
+                    "timestamp": "2024-01-01T00:00:00",
+                    "version": "1.0.0",
+                    "model_info": {"name": "mediapipe", "type": "pose_estimation"}
+                },
+                "video_info": {
+                    "fps": 30.0,
+                    "duration_seconds": 5.0,
+                    "width": 1920,
+                    "height": 1080,
+                    "frame_count": 150
+                },
+                "movement_analysis": {
+                    "frame_count": 150,
+                    "frames": [
+                        {
+                            "frame_index": 0,
+                            "timestamp": 0.0,
+                            "metrics": {
+                                "direction": "stationary",
+                                "intensity": "low",
+                                "speed": "slow",
+                                "velocity": 0.0,
+                                "acceleration": 0.0,
+                                "fluidity": 1.0,
+                                "expansion": 0.5
+                            }
+                        }
+                    ],
+                    "summary": {
+                        "direction": {
+                            "distribution": {"stationary": 50, "up": 30, "down": 20},
+                            "dominant": "stationary"
+                        },
+                        "intensity": {
+                            "distribution": {"low": 80, "medium": 15, "high": 5},
+                            "dominant": "low"
+                        }
+                    }
+                }
+            },
+            "video_output": "/tmp/visualization.mp4"
+        }
+    
+    def api_info(self) -> Dict[str, Any]:
+        """API information for the component."""
+        return {
+            "type": "composite",
+            "description": "Video-based pose analysis with Laban Movement Analysis metrics",
+            "parameters": {
+                "video": {"type": "file", "description": "Input video file or URL (YouTube/Vimeo)"},
+                "model": {"type": "string", "description": "Pose model: mediapipe, movenet, or yolo variants"},
+                "enable_visualization": {"type": "boolean", "description": "Generate visualization video"},
+                "include_keypoints": {"type": "boolean", "description": "Include keypoints in JSON"}
+            },
+            "returns": {
+                "json_output": {"type": "object", "description": "LMA analysis results"},
+                "video_output": {"type": "file", "description": "Visualization video (optional)"}
+            },
+            "version_2_preview": {
+                "planned_features": ["SkateFormer AI integration", "Enhanced movement recognition", "Real-time analysis"],
+                "note": "Advanced AI features coming in Version 2!"
+            }
+        }

backend/gradio_labanmovementanalysis/labanmovementanalysis.pyi

@@ -0,0 +1,448 @@
+"""
+Custom Gradio v5 component for video-based pose analysis with LMA-inspired metrics.
+"""
+
+import gradio as gr
+from gradio.components.base import Component
+from typing import Dict, Any, Optional, Tuple, List, Union
+import tempfile
+import os
+import numpy as np
+
+from .video_utils import extract_frames, get_video_info
+from .pose_estimation import get_pose_estimator
+from .notation_engine import analyze_pose_sequence
+from .json_generator import generate_json, format_for_display
+from .visualizer import PoseVisualizer
+from .video_downloader import SmartVideoInput
+
+# Optional advanced features
+try:
+    from .skateformer_integration import SkateFormerAnalyzer
+    HAS_SKATEFORMER = True
+except ImportError:
+    HAS_SKATEFORMER = False
+
+try:
+    from .webrtc_handler import WebRTCMovementAnalyzer, WebRTCGradioInterface
+    HAS_WEBRTC = True
+except ImportError:
+    HAS_WEBRTC = False
+
+from gradio.events import Dependency
+
+class LabanMovementAnalysis(Component):
+    """
+    Gradio component for video-based pose analysis with Laban Movement Analysis metrics.
+    """
+    
+    # Component metadata
+    COMPONENT_TYPE = "composite"
+    DEFAULT_MODEL = "mediapipe"
+    
+    def __init__(self,
+                 default_model: str = DEFAULT_MODEL,
+                 enable_visualization: bool = True,
+                 include_keypoints: bool = False,
+                 enable_webrtc: bool = False,
+                 label: Optional[str] = None,
+                 every: Optional[float] = None,
+                 show_label: Optional[bool] = None,
+                 container: bool = True,
+                 scale: Optional[int] = None,
+                 min_width: int = 160,
+                 interactive: Optional[bool] = None,
+                 visible: bool = True,
+                 elem_id: Optional[str] = None,
+                 elem_classes: Optional[List[str]] = None,
+                 render: bool = True,
+                 **kwargs):
+        """
+        Initialize the Laban Movement Analysis component.
+        
+        Args:
+            default_model: Default pose estimation model ("mediapipe", "movenet", "yolo")
+            enable_visualization: Whether to generate visualization video by default
+            include_keypoints: Whether to include raw keypoints in JSON output
+            enable_webrtc: Whether to enable WebRTC real-time analysis
+            label: Component label
+            ... (other standard Gradio component args)
+        """
+        super().__init__(
+            label=label,
+            every=every,
+            show_label=show_label,
+            container=container,
+            scale=scale,
+            min_width=min_width,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+            **kwargs
+        )
+        
+        self.default_model = default_model
+        self.enable_visualization = enable_visualization
+        self.include_keypoints = include_keypoints
+        self.enable_webrtc = enable_webrtc and HAS_WEBRTC
+        
+        # Cache for pose estimators
+        self._estimators = {}
+        
+        # Video input handler for URLs
+        self.video_input = SmartVideoInput()
+        
+        # SkateFormer features reserved for Version 2
+        
+        self.webrtc_analyzer = None
+        if self.enable_webrtc:
+            try:
+                self.webrtc_analyzer = WebRTCMovementAnalyzer(model=default_model)
+            except Exception as e:
+                print(f"Warning: Failed to initialize WebRTC: {e}")
+                self.enable_webrtc = False
+    
+    def preprocess(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Preprocess input from the frontend.
+        
+        Args:
+            payload: Input data containing video file and options
+            
+        Returns:
+            Processed data for analysis
+        """
+        if not payload:
+            return None
+            
+        # Extract video file path
+        video_data = payload.get("video")
+        if not video_data:
+            return None
+            
+        # Handle different input formats
+        if isinstance(video_data, str):
+            video_path = video_data
+        elif isinstance(video_data, dict):
+            video_path = video_data.get("path") or video_data.get("name")
+        else:
+            # Assume it's a file object
+            video_path = video_data.name if hasattr(video_data, "name") else str(video_data)
+        
+        # Extract options
+        options = {
+            "video_path": video_path,
+            "model": payload.get("model", self.default_model),
+            "enable_visualization": payload.get("enable_visualization", self.enable_visualization),
+            "include_keypoints": payload.get("include_keypoints", self.include_keypoints)
+        }
+        
+        return options
+    
+    def postprocess(self, value: Any) -> Dict[str, Any]:
+        """
+        Postprocess analysis results for the frontend.
+        
+        Args:
+            value: Analysis results
+            
+        Returns:
+            Formatted output for display
+        """
+        if value is None:
+            return {"json_output": {}, "video_output": None}
+        
+        # Ensure we have the expected format
+        if isinstance(value, tuple) and len(value) == 2:
+            json_data, video_path = value
+        else:
+            json_data = value
+            video_path = None
+        
+        return {
+            "json_output": json_data,
+            "video_output": video_path
+        }
+    
+    def process_video(self, video_input: Union[str, os.PathLike], model: str = DEFAULT_MODEL,
+                     enable_visualization: bool = True,
+                     include_keypoints: bool = False) -> Tuple[Dict[str, Any], Optional[str]]:
+        """
+        Main processing function that performs pose analysis on a video.
+        
+        Args:
+            video_input: Path to input video, video URL (YouTube/Vimeo), or file object
+            model: Pose estimation model to use (supports enhanced syntax like "yolo-v11-s")
+            enable_visualization: Whether to generate visualization video
+            include_keypoints: Whether to include keypoints in JSON
+            
+        Returns:
+            Tuple of (analysis_json, visualization_video_path)
+        """
+        # Handle video input (local file, URL, etc.)
+        try:
+            video_path, video_metadata = self.video_input.process_input(str(video_input))
+            print(f"Processing video: {video_metadata.get('title', 'Unknown')}")
+            if video_metadata.get('platform') in ['youtube', 'vimeo']:
+                print(f"Downloaded from {video_metadata['platform']}")
+        except Exception as e:
+            raise ValueError(f"Failed to process video input: {str(e)}")
+        # Get video metadata
+        frame_count, fps, (width, height) = get_video_info(video_path)
+        
+        # Create or get pose estimator
+        if model not in self._estimators:
+            self._estimators[model] = get_pose_estimator(model)
+        estimator = self._estimators[model]
+        
+        # Process video frame by frame
+        print(f"Processing {frame_count} frames with {model} model...")
+        
+        all_frames = []
+        all_pose_results = []
+        
+        for i, frame in enumerate(extract_frames(video_path)):
+            # Store frame if visualization is needed
+            if enable_visualization:
+                all_frames.append(frame)
+            
+            # Detect poses
+            pose_results = estimator.detect(frame)
+            
+            # Update frame indices
+            for result in pose_results:
+                result.frame_index = i
+            
+            all_pose_results.append(pose_results)
+            
+            # Progress indicator
+            if i % 30 == 0:
+                print(f"Processed {i}/{frame_count} frames...")
+        
+        print("Analyzing movement patterns...")
+        
+        # Analyze movement
+        movement_metrics = analyze_pose_sequence(all_pose_results, fps=fps)
+        
+        # Enhanced AI analysis reserved for Version 2
+        print("LMA analysis complete - advanced AI features coming in Version 2!")
+        
+        # Generate JSON output
+        video_metadata = {
+            "fps": fps,
+            "width": width,
+            "height": height,
+            "frame_count": frame_count,
+            "model_info": {
+                "name": model,
+                "type": "pose_estimation"
+            },
+            "input_metadata": video_metadata  # Include video source metadata
+        }
+        
+        json_output = generate_json(
+            movement_metrics,
+            all_pose_results if include_keypoints else None,
+            video_metadata,
+            include_keypoints=include_keypoints
+        )
+        
+        # Enhanced AI analysis will be added in Version 2
+        
+        # Generate visualization if requested
+        visualization_path = None
+        if enable_visualization:
+            print("Generating visualization video...")
+            
+            # Create temporary output file
+            with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp:
+                visualization_path = tmp.name
+            
+            # Create visualizer
+            visualizer = PoseVisualizer(
+                show_trails=True,
+                show_skeleton=True,
+                show_direction_arrows=True,
+                show_metrics=True
+            )
+            
+            # Generate overlay video
+            visualization_path = visualizer.generate_overlay_video(
+                all_frames,
+                all_pose_results,
+                movement_metrics,
+                visualization_path,
+                fps
+            )
+            
+            print(f"Visualization saved to: {visualization_path}")
+        
+        return json_output, visualization_path
+    
+    def __call__(self, video_path: str, **kwargs) -> Tuple[Dict[str, Any], Optional[str]]:
+        """
+        Make the component callable for easy use.
+        
+        Args:
+            video_path: Path to video file
+            **kwargs: Additional options
+            
+        Returns:
+            Analysis results
+        """
+        return self.process_video(video_path, **kwargs)
+    
+    def start_webrtc_stream(self, model: str = None) -> bool:
+        """
+        Start WebRTC real-time analysis stream.
+        
+        Args:
+            model: Pose model to use for real-time analysis
+            
+        Returns:
+            True if stream started successfully
+        """
+        if not self.enable_webrtc or not self.webrtc_analyzer:
+            print("WebRTC not enabled or available")
+            return False
+            
+        try:
+            if model:
+                self.webrtc_analyzer.model = model
+                self.webrtc_analyzer.pose_estimator = get_pose_estimator(model)
+            
+            self.webrtc_analyzer.start_stream()
+            print(f"WebRTC stream started with {self.webrtc_analyzer.model} model")
+            return True
+        except Exception as e:
+            print(f"Failed to start WebRTC stream: {e}")
+            return False
+    
+    def stop_webrtc_stream(self) -> bool:
+        """
+        Stop WebRTC real-time analysis stream.
+        
+        Returns:
+            True if stream stopped successfully
+        """
+        if not self.webrtc_analyzer:
+            return False
+            
+        try:
+            self.webrtc_analyzer.stop_stream()
+            print("WebRTC stream stopped")
+            return True
+        except Exception as e:
+            print(f"Failed to stop WebRTC stream: {e}")
+            return False
+    
+    def get_webrtc_interface(self):
+        """
+        Get WebRTC Gradio interface for real-time streaming.
+        
+        Returns:
+            WebRTCGradioInterface instance or None
+        """
+        if not self.enable_webrtc or not self.webrtc_analyzer:
+            return None
+            
+        return WebRTCGradioInterface(self.webrtc_analyzer)
+    
+    # SkateFormer methods moved to Version 2 development
+    # get_skateformer_compatibility() and get_skateformer_status_report() 
+    # will be available in the next major release
+    
+    def cleanup(self):
+        """Clean up temporary files and resources."""
+        # Clean up video input handler
+        if hasattr(self, 'video_input'):
+            self.video_input.cleanup()
+        
+        # Stop WebRTC if running
+        if self.webrtc_analyzer and self.webrtc_analyzer.is_running:
+            self.stop_webrtc_stream()
+    
+    def example_payload(self) -> Dict[str, Any]:
+        """Example input payload for documentation."""
+        return {
+            "video": {"path": "/path/to/video.mp4"},
+            "model": "mediapipe",
+            "enable_visualization": True,
+            "include_keypoints": False
+        }
+    
+    def example_value(self) -> Dict[str, Any]:
+        """Example output value for documentation."""
+        return {
+            "json_output": {
+                "analysis_metadata": {
+                    "timestamp": "2024-01-01T00:00:00",
+                    "version": "1.0.0",
+                    "model_info": {"name": "mediapipe", "type": "pose_estimation"}
+                },
+                "video_info": {
+                    "fps": 30.0,
+                    "duration_seconds": 5.0,
+                    "width": 1920,
+                    "height": 1080,
+                    "frame_count": 150
+                },
+                "movement_analysis": {
+                    "frame_count": 150,
+                    "frames": [
+                        {
+                            "frame_index": 0,
+                            "timestamp": 0.0,
+                            "metrics": {
+                                "direction": "stationary",
+                                "intensity": "low",
+                                "speed": "slow",
+                                "velocity": 0.0,
+                                "acceleration": 0.0,
+                                "fluidity": 1.0,
+                                "expansion": 0.5
+                            }
+                        }
+                    ],
+                    "summary": {
+                        "direction": {
+                            "distribution": {"stationary": 50, "up": 30, "down": 20},
+                            "dominant": "stationary"
+                        },
+                        "intensity": {
+                            "distribution": {"low": 80, "medium": 15, "high": 5},
+                            "dominant": "low"
+                        }
+                    }
+                }
+            },
+            "video_output": "/tmp/visualization.mp4"
+        }
+    
+    def api_info(self) -> Dict[str, Any]:
+        """API information for the component."""
+        return {
+            "type": "composite",
+            "description": "Video-based pose analysis with Laban Movement Analysis metrics",
+            "parameters": {
+                "video": {"type": "file", "description": "Input video file or URL (YouTube/Vimeo)"},
+                "model": {"type": "string", "description": "Pose model: mediapipe, movenet, or yolo variants"},
+                "enable_visualization": {"type": "boolean", "description": "Generate visualization video"},
+                "include_keypoints": {"type": "boolean", "description": "Include keypoints in JSON"}
+            },
+            "returns": {
+                "json_output": {"type": "object", "description": "LMA analysis results"},
+                "video_output": {"type": "file", "description": "Visualization video (optional)"}
+            },
+            "version_2_preview": {
+                "planned_features": ["SkateFormer AI integration", "Enhanced movement recognition", "Real-time analysis"],
+                "note": "Advanced AI features coming in Version 2!"
+            }
+        }
+    from typing import Callable, Literal, Sequence, Any, TYPE_CHECKING
+    from gradio.blocks import Block
+    if TYPE_CHECKING:
+        from gradio.components import Timer
+        from gradio.components.base import Component

backend/gradio_labanmovementanalysis/notation_engine.py

@@ -0,0 +1,317 @@
+"""
+Laban Movement Analysis (LMA) inspired notation engine.
+Computes movement metrics like direction, intensity, and speed from pose keypoints.
+"""
+
+import numpy as np
+from typing import List, Dict, Optional, Tuple, Any
+from dataclasses import dataclass
+from enum import Enum
+
+from .pose_estimation import PoseResult, Keypoint
+
+
+class Direction(Enum):
+    """Movement direction categories."""
+    UP = "up"
+    DOWN = "down"
+    LEFT = "left"
+    RIGHT = "right"
+    FORWARD = "forward"
+    BACKWARD = "backward"
+    STATIONARY = "stationary"
+
+
+class Intensity(Enum):
+    """Movement intensity levels."""
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+
+class Speed(Enum):
+    """Movement speed categories."""
+    SLOW = "slow"
+    MODERATE = "moderate"
+    FAST = "fast"
+
+
+@dataclass
+class MovementMetrics:
+    """LMA-inspired movement metrics for a frame or segment."""
+    frame_index: int
+    timestamp: Optional[float] = None
+    
+    # Primary metrics
+    direction: Direction = Direction.STATIONARY
+    intensity: Intensity = Intensity.LOW
+    speed: Speed = Speed.SLOW
+    
+    # Numeric values
+    velocity: float = 0.0  # pixels/second or normalized units
+    acceleration: float = 0.0
+    
+    # Additional qualities
+    fluidity: float = 0.0  # 0-1, smoothness of movement
+    expansion: float = 0.0  # 0-1, how spread out the pose is
+    
+    # Raw displacement data
+    center_displacement: Optional[Tuple[float, float]] = None
+    total_displacement: float = 0.0
+
+
+class MovementAnalyzer:
+    """Analyzes pose sequences to extract LMA-style movement metrics."""
+    
+    def __init__(self, fps: float = 30.0, 
+                 velocity_threshold_slow: float = 0.01,
+                 velocity_threshold_fast: float = 0.1,
+                 intensity_accel_threshold: float = 0.05):
+        """
+        Initialize movement analyzer.
+        
+        Args:
+            fps: Frames per second of the video
+            velocity_threshold_slow: Threshold for slow movement (normalized)
+            velocity_threshold_fast: Threshold for fast movement (normalized)
+            intensity_accel_threshold: Acceleration threshold for intensity
+        """
+        self.fps = fps
+        self.frame_duration = 1.0 / fps
+        self.velocity_threshold_slow = velocity_threshold_slow
+        self.velocity_threshold_fast = velocity_threshold_fast
+        self.intensity_accel_threshold = intensity_accel_threshold
+    
+    def analyze_movement(self, pose_sequence: List[List[PoseResult]]) -> List[MovementMetrics]:
+        """
+        Analyze a sequence of poses to compute movement metrics.
+        
+        Args:
+            pose_sequence: List of pose results per frame
+            
+        Returns:
+            List of movement metrics per frame
+        """
+        if not pose_sequence:
+            return []
+        
+        metrics = []
+        prev_centers = None
+        prev_velocity = None
+        
+        for frame_idx, frame_poses in enumerate(pose_sequence):
+            if not frame_poses:
+                # No pose detected in this frame
+                metrics.append(MovementMetrics(
+                    frame_index=frame_idx,
+                    timestamp=frame_idx * self.frame_duration
+                ))
+                continue
+            
+            # For now, analyze first person only
+            # TODO: Extend to multi-person analysis
+            pose = frame_poses[0]
+            
+            # Compute body center and limb positions
+            center = self._compute_body_center(pose.keypoints)
+            limb_positions = self._get_limb_positions(pose.keypoints)
+            
+            # Initialize metrics for this frame
+            frame_metrics = MovementMetrics(
+                frame_index=frame_idx,
+                timestamp=frame_idx * self.frame_duration
+            )
+            
+            if prev_centers is not None and frame_idx > 0:
+                # Compute displacement and velocity
+                displacement = (
+                    center[0] - prev_centers[0],
+                    center[1] - prev_centers[1]
+                )
+                frame_metrics.center_displacement = displacement
+                frame_metrics.total_displacement = np.sqrt(
+                    displacement[0]**2 + displacement[1]**2
+                )
+                
+                # Velocity (normalized units per second)
+                frame_metrics.velocity = frame_metrics.total_displacement * self.fps
+                
+                # Direction
+                frame_metrics.direction = self._compute_direction(displacement)
+                
+                # Speed category
+                frame_metrics.speed = self._categorize_speed(frame_metrics.velocity)
+                
+                # Acceleration and intensity
+                if prev_velocity is not None:
+                    frame_metrics.acceleration = abs(
+                        frame_metrics.velocity - prev_velocity
+                    ) * self.fps
+                    frame_metrics.intensity = self._compute_intensity(
+                        frame_metrics.acceleration,
+                        frame_metrics.velocity
+                    )
+                
+                # Fluidity (based on acceleration smoothness)
+                frame_metrics.fluidity = self._compute_fluidity(
+                    frame_metrics.acceleration
+                )
+            
+            # Expansion (how spread out the pose is)
+            frame_metrics.expansion = self._compute_expansion(pose.keypoints)
+            
+            metrics.append(frame_metrics)
+            
+            # Update previous values
+            prev_centers = center
+            prev_velocity = frame_metrics.velocity
+        
+        # Post-process to smooth metrics if needed
+        metrics = self._smooth_metrics(metrics)
+        
+        return metrics
+    
+    def _compute_body_center(self, keypoints: List[Keypoint]) -> Tuple[float, float]:
+        """Compute the center of mass of the body."""
+        # Use major body joints for center calculation
+        major_joints = ["left_hip", "right_hip", "left_shoulder", "right_shoulder"]
+        
+        x_coords = []
+        y_coords = []
+        
+        for kp in keypoints:
+            if kp.name in major_joints and kp.confidence > 0.5:
+                x_coords.append(kp.x)
+                y_coords.append(kp.y)
+        
+        if not x_coords:
+            # Fallback to all keypoints
+            x_coords = [kp.x for kp in keypoints if kp.confidence > 0.3]
+            y_coords = [kp.y for kp in keypoints if kp.confidence > 0.3]
+        
+        if x_coords:
+            return (np.mean(x_coords), np.mean(y_coords))
+        return (0.5, 0.5)  # Default center
+    
+    def _get_limb_positions(self, keypoints: List[Keypoint]) -> Dict[str, Tuple[float, float]]:
+        """Get positions of major limbs."""
+        positions = {}
+        for kp in keypoints:
+            if kp.confidence > 0.3:
+                positions[kp.name] = (kp.x, kp.y)
+        return positions
+    
+    def _compute_direction(self, displacement: Tuple[float, float]) -> Direction:
+        """Compute movement direction from displacement vector."""
+        dx, dy = displacement
+        
+        # Threshold for considering movement
+        threshold = 0.005
+        
+        if abs(dx) < threshold and abs(dy) < threshold:
+            return Direction.STATIONARY
+        
+        # Determine primary direction
+        if abs(dx) > abs(dy):
+            return Direction.RIGHT if dx > 0 else Direction.LEFT
+        else:
+            return Direction.DOWN if dy > 0 else Direction.UP
+    
+    def _categorize_speed(self, velocity: float) -> Speed:
+        """Categorize velocity into speed levels."""
+        if velocity < self.velocity_threshold_slow:
+            return Speed.SLOW
+        elif velocity < self.velocity_threshold_fast:
+            return Speed.FAST
+        else:
+            return Speed.FAST
+    
+    def _compute_intensity(self, acceleration: float, velocity: float) -> Intensity:
+        """Compute movement intensity based on acceleration and velocity."""
+        # High acceleration or high velocity indicates high intensity
+        if acceleration > self.intensity_accel_threshold * 2 or velocity > self.velocity_threshold_fast:
+            return Intensity.HIGH
+        elif acceleration > self.intensity_accel_threshold or velocity > self.velocity_threshold_slow:
+            return Intensity.MEDIUM
+        else:
+            return Intensity.LOW
+    
+    def _compute_fluidity(self, acceleration: float) -> float:
+        """
+        Compute fluidity score (0-1) based on acceleration.
+        Lower acceleration = higher fluidity (smoother movement).
+        """
+        # Normalize acceleration to 0-1 range
+        max_accel = 0.2  # Expected maximum acceleration
+        norm_accel = min(acceleration / max_accel, 1.0)
+        
+        # Invert so low acceleration = high fluidity
+        return 1.0 - norm_accel
+    
+    def _compute_expansion(self, keypoints: List[Keypoint]) -> float:
+        """
+        Compute how expanded/contracted the pose is.
+        Returns 0-1 where 1 is fully expanded.
+        """
+        # Calculate distances between opposite limbs
+        limb_pairs = [
+            ("left_wrist", "right_wrist"),
+            ("left_ankle", "right_ankle"),
+            ("left_wrist", "left_ankle"),
+            ("right_wrist", "right_ankle")
+        ]
+        
+        kp_dict = {kp.name: kp for kp in keypoints if kp.confidence > 0.3}
+        
+        distances = []
+        for limb1, limb2 in limb_pairs:
+            if limb1 in kp_dict and limb2 in kp_dict:
+                kp1 = kp_dict[limb1]
+                kp2 = kp_dict[limb2]
+                dist = np.sqrt((kp1.x - kp2.x)**2 + (kp1.y - kp2.y)**2)
+                distances.append(dist)
+        
+        if distances:
+            # Normalize by expected maximum distance
+            avg_dist = np.mean(distances)
+            max_expected = 1.4  # Diagonal of normalized space
+            return min(avg_dist / max_expected, 1.0)
+        
+        return 0.5  # Default neutral expansion
+    
+    def _smooth_metrics(self, metrics: List[MovementMetrics]) -> List[MovementMetrics]:
+        """Apply smoothing to reduce noise in metrics."""
+        # Simple moving average for numeric values
+        window_size = 3
+        
+        if len(metrics) <= window_size:
+            return metrics
+        
+        # Smooth velocity and acceleration
+        for i in range(window_size, len(metrics)):
+            velocities = [m.velocity for m in metrics[i-window_size:i+1]]
+            metrics[i].velocity = np.mean(velocities)
+            
+            accels = [m.acceleration for m in metrics[i-window_size:i+1]]
+            metrics[i].acceleration = np.mean(accels)
+            
+            fluidities = [m.fluidity for m in metrics[i-window_size:i+1]]
+            metrics[i].fluidity = np.mean(fluidities)
+        
+        return metrics
+
+
+def analyze_pose_sequence(pose_sequence: List[List[PoseResult]], 
+                         fps: float = 30.0) -> List[MovementMetrics]:
+    """
+    Convenience function to analyze a pose sequence.
+    
+    Args:
+        pose_sequence: List of pose results per frame
+        fps: Video frame rate
+        
+    Returns:
+        List of movement metrics
+    """
+    analyzer = MovementAnalyzer(fps=fps)
+    return analyzer.analyze_movement(pose_sequence) 

backend/gradio_labanmovementanalysis/pose_estimation.py

@@ -0,0 +1,380 @@
+"""
+Model-agnostic pose estimation interface with adapters for various pose detection models.
+Each adapter provides a uniform interface for pose estimation, abstracting model-specific details.
+"""
+
+from abc import ABC, abstractmethod
+import numpy as np
+from typing import List, Dict, Optional, Tuple, Any
+from dataclasses import dataclass
+
+
+@dataclass
+class Keypoint:
+    """Represents a single pose keypoint."""
+    x: float  # Normalized x coordinate (0-1)
+    y: float  # Normalized y coordinate (0-1)
+    confidence: float  # Confidence score (0-1)
+    name: Optional[str] = None  # Joint name (e.g., "left_shoulder")
+
+
+@dataclass
+class PoseResult:
+    """Result of pose estimation for a single frame."""
+    keypoints: List[Keypoint]
+    frame_index: int
+    timestamp: Optional[float] = None
+    person_id: Optional[int] = None  # For multi-person tracking
+
+
+class PoseEstimator(ABC):
+    """Abstract base class for pose estimation models."""
+    
+    @abstractmethod
+    def detect(self, frame: np.ndarray) -> List[PoseResult]:
+        """
+        Detect poses in a single frame.
+        
+        Args:
+            frame: Input frame as numpy array (BGR format)
+            
+        Returns:
+            List of PoseResult objects (one per detected person)
+        """
+        pass
+    
+    @abstractmethod
+    def get_keypoint_names(self) -> List[str]:
+        """Get the list of keypoint names this model provides."""
+        pass
+    
+    def detect_batch(self, frames: List[np.ndarray]) -> List[List[PoseResult]]:
+        """
+        Process multiple frames (default implementation processes sequentially).
+        
+        Args:
+            frames: List of frames
+            
+        Returns:
+            List of results per frame
+        """
+        results = []
+        for i, frame in enumerate(frames):
+            frame_results = self.detect(frame)
+            # Update frame indices
+            for result in frame_results:
+                result.frame_index = i
+            results.append(frame_results)
+        return results
+
+
+class MoveNetPoseEstimator(PoseEstimator):
+    """MoveNet pose estimation adapter (TensorFlow-based)."""
+    
+    # COCO keypoint names used by MoveNet
+    KEYPOINT_NAMES = [
+        "nose", "left_eye", "right_eye", "left_ear", "right_ear",
+        "left_shoulder", "right_shoulder", "left_elbow", "right_elbow",
+        "left_wrist", "right_wrist", "left_hip", "right_hip",
+        "left_knee", "right_knee", "left_ankle", "right_ankle"
+    ]
+    
+    def __init__(self, model_variant: str = "lightning"):
+        """
+        Initialize MoveNet model.
+        
+        Args:
+            model_variant: "lightning" (faster) or "thunder" (more accurate)
+        """
+        self.model_variant = model_variant
+        self.model = None
+        self._load_model()
+    
+    def _load_model(self):
+        """Load MoveNet model using TensorFlow."""
+        try:
+            import tensorflow as tf
+            import tensorflow_hub as hub
+            
+            # Model URLs for different variants
+            model_urls = {
+                "lightning": "https://tfhub.dev/google/movenet/singlepose/lightning/4",
+                "thunder": "https://tfhub.dev/google/movenet/singlepose/thunder/4"
+            }
+            
+            self.model = hub.load(model_urls[self.model_variant])
+            self.movenet = self.model.signatures['serving_default']
+            
+        except ImportError:
+            raise ImportError("TensorFlow and tensorflow_hub required for MoveNet. "
+                            "Install with: pip install tensorflow tensorflow_hub")
+    
+    def detect(self, frame: np.ndarray) -> List[PoseResult]:
+        """Detect pose using MoveNet."""
+        if self.model is None:
+            self._load_model()
+        
+        import tensorflow as tf
+        
+        # Prepare input
+        height, width = frame.shape[:2]
+        
+        # MoveNet expects RGB
+        rgb_frame = frame[:, :, ::-1]  # BGR to RGB
+        
+        # Resize and normalize
+        input_size = 192 if self.model_variant == "lightning" else 256
+        input_image = tf.image.resize_with_pad(
+            tf.expand_dims(rgb_frame, axis=0), input_size, input_size
+        )
+        input_image = tf.cast(input_image, dtype=tf.int32)
+        
+        # Run inference
+        outputs = self.movenet(input_image)
+        keypoints_with_scores = outputs['output_0'].numpy()[0, 0, :, :]
+        
+        # Convert to our format
+        keypoints = []
+        for i, (y, x, score) in enumerate(keypoints_with_scores):
+            keypoints.append(Keypoint(
+                x=float(x),
+                y=float(y),
+                confidence=float(score),
+                name=self.KEYPOINT_NAMES[i]
+            ))
+        
+        return [PoseResult(keypoints=keypoints, frame_index=0)]
+    
+    def get_keypoint_names(self) -> List[str]:
+        return self.KEYPOINT_NAMES.copy()
+
+
+class MediaPipePoseEstimator(PoseEstimator):
+    """MediaPipe Pose (BlazePose) estimation adapter."""
+    
+    # MediaPipe landmark names
+    LANDMARK_NAMES = [
+        "nose", "left_eye_inner", "left_eye", "left_eye_outer",
+        "right_eye_inner", "right_eye", "right_eye_outer",
+        "left_ear", "right_ear", "mouth_left", "mouth_right",
+        "left_shoulder", "right_shoulder", "left_elbow", "right_elbow",
+        "left_wrist", "right_wrist", "left_pinky", "right_pinky",
+        "left_index", "right_index", "left_thumb", "right_thumb",
+        "left_hip", "right_hip", "left_knee", "right_knee",
+        "left_ankle", "right_ankle", "left_heel", "right_heel",
+        "left_foot_index", "right_foot_index"
+    ]
+    
+    def __init__(self, model_complexity: int = 1, min_detection_confidence: float = 0.5):
+        """
+        Initialize MediaPipe Pose.
+        
+        Args:
+            model_complexity: 0 (lite), 1 (full), or 2 (heavy)
+            min_detection_confidence: Minimum confidence for detection
+        """
+        self.model_complexity = model_complexity
+        self.min_detection_confidence = min_detection_confidence
+        self.pose = None
+        self._initialize()
+    
+    def _initialize(self):
+        """Initialize MediaPipe Pose."""
+        try:
+            import mediapipe as mp
+            self.mp_pose = mp.solutions.pose
+            self.pose = self.mp_pose.Pose(
+                static_image_mode=False,
+                model_complexity=self.model_complexity,
+                min_detection_confidence=self.min_detection_confidence,
+                min_tracking_confidence=0.5
+            )
+        except ImportError:
+            raise ImportError("MediaPipe required. Install with: pip install mediapipe")
+    
+    def detect(self, frame: np.ndarray) -> List[PoseResult]:
+        """Detect pose using MediaPipe."""
+        if self.pose is None:
+            self._initialize()
+        
+        # MediaPipe expects RGB
+        rgb_frame = frame[:, :, ::-1]  # BGR to RGB
+        height, width = frame.shape[:2]
+        
+        # Process frame
+        results = self.pose.process(rgb_frame)
+        
+        if not results.pose_landmarks:
+            return []
+        
+        # Convert landmarks to keypoints
+        keypoints = []
+        for i, landmark in enumerate(results.pose_landmarks.landmark):
+            keypoints.append(Keypoint(
+                x=landmark.x,
+                y=landmark.y,
+                confidence=landmark.visibility if hasattr(landmark, 'visibility') else 1.0,
+                name=self.LANDMARK_NAMES[i] if i < len(self.LANDMARK_NAMES) else f"landmark_{i}"
+            ))
+        
+        return [PoseResult(keypoints=keypoints, frame_index=0)]
+    
+    def get_keypoint_names(self) -> List[str]:
+        return self.LANDMARK_NAMES.copy()
+    
+    def __del__(self):
+        """Clean up MediaPipe resources."""
+        if self.pose:
+            self.pose.close()
+
+
+class YOLOPoseEstimator(PoseEstimator):
+    """YOLO-based pose estimation adapter (supports YOLOv8 and YOLOv11)."""
+    
+    # COCO keypoint format used by YOLO
+    KEYPOINT_NAMES = [
+        "nose", "left_eye", "right_eye", "left_ear", "right_ear",
+        "left_shoulder", "right_shoulder", "left_elbow", "right_elbow",
+        "left_wrist", "right_wrist", "left_hip", "right_hip",
+        "left_knee", "right_knee", "left_ankle", "right_ankle"
+    ]
+    
+    def __init__(self, model_version: str = "v11", model_size: str = "n", confidence_threshold: float = 0.25):
+        """
+        Initialize YOLO pose model.
+        
+        Args:
+            model_version: "v8" or "v11"
+            model_size: Model size - "n" (nano), "s" (small), "m" (medium), "l" (large), "x" (xlarge)
+            confidence_threshold: Minimum confidence for detections
+        """
+        self.model_version = model_version
+        self.model_size = model_size
+        self.confidence_threshold = confidence_threshold
+        self.model = None
+        
+        # Determine model path
+        if model_version == "v8":
+            self.model_path = f"yolov8{model_size}-pose.pt"
+        else:  # v11
+            self.model_path = f"yolo11{model_size}-pose.pt"
+            
+        self._load_model()
+    
+    def _load_model(self):
+        """Load YOLO model."""
+        try:
+            from ultralytics import YOLO
+            self.model = YOLO(self.model_path)
+        except ImportError:
+            raise ImportError("Ultralytics required for YOLO. "
+                            "Install with: pip install ultralytics")
+    
+    def detect(self, frame: np.ndarray) -> List[PoseResult]:
+        """Detect poses using YOLO."""
+        if self.model is None:
+            self._load_model()
+        
+        # Run inference
+        results = self.model(frame, conf=self.confidence_threshold)
+        
+        pose_results = []
+        
+        # Process each detection
+        for r in results:
+            if r.keypoints is not None:
+                for person_idx, keypoints_data in enumerate(r.keypoints.data):
+                    keypoints = []
+                    
+                    # YOLO returns keypoints as [x, y, conf]
+                    height, width = frame.shape[:2]
+                    for i, (x, y, conf) in enumerate(keypoints_data):
+                        keypoints.append(Keypoint(
+                            x=float(x) / width,  # Normalize to 0-1
+                            y=float(y) / height,  # Normalize to 0-1
+                            confidence=float(conf),
+                            name=self.KEYPOINT_NAMES[i] if i < len(self.KEYPOINT_NAMES) else f"joint_{i}"
+                        ))
+                    
+                    pose_results.append(PoseResult(
+                        keypoints=keypoints,
+                        frame_index=0,
+                        person_id=person_idx
+                    ))
+        
+        return pose_results
+    
+    def get_keypoint_names(self) -> List[str]:
+        return self.KEYPOINT_NAMES.copy()
+
+
+# Note: Sapiens models removed due to complex setup requirements
+# They require the official repository and cannot be integrated cleanly
+# with the agent/MCP pipeline without significant complexity
+
+
+def create_pose_estimator(model_type: str, **kwargs) -> PoseEstimator:
+    """
+    Factory function to create pose estimator instances.
+    
+    Args:
+        model_type: One of "movenet", "mediapipe", "yolo"
+        **kwargs: Model-specific parameters
+        
+    Returns:
+        PoseEstimator instance
+    """
+    estimators = {
+        "movenet": MoveNetPoseEstimator,
+        "mediapipe": MediaPipePoseEstimator,
+        "yolo": YOLOPoseEstimator,
+    }
+    
+    if model_type not in estimators:
+        raise ValueError(f"Unknown model type: {model_type}. "
+                        f"Available: {list(estimators.keys())}")
+    
+    return estimators[model_type](**kwargs)
+
+
+def get_pose_estimator(model_spec: str) -> PoseEstimator:
+    """
+    Get pose estimator from model specification string.
+    
+    Args:
+        model_spec: Model specification string, e.g.:
+            - "mediapipe" or "mediapipe-lite" or "mediapipe-full" or "mediapipe-heavy"
+            - "movenet-lightning" or "movenet-thunder"
+            - "yolo-v8-n" or "yolo-v11-s" etc.
+            
+    Returns:
+        PoseEstimator instance
+    """
+    model_spec = model_spec.lower()
+    
+    # MediaPipe variants
+    if model_spec.startswith("mediapipe"):
+        complexity_map = {
+            "mediapipe-lite": 0,
+            "mediapipe-full": 1,
+            "mediapipe-heavy": 2,
+            "mediapipe": 1  # default
+        }
+        complexity = complexity_map.get(model_spec, 1)
+        return create_pose_estimator("mediapipe", model_complexity=complexity)
+    
+    # MoveNet variants
+    elif model_spec.startswith("movenet"):
+        variant = "lightning" if "lightning" in model_spec else "thunder"
+        return create_pose_estimator("movenet", model_variant=variant)
+    
+    # YOLO variants
+    elif model_spec.startswith("yolo"):
+        parts = model_spec.split("-")
+        version = "v8" if "v8" in model_spec else "v11"
+        size = parts[-1] if len(parts) > 2 else "n"
+        return create_pose_estimator("yolo", model_version=version, model_size=size)
+    
+    # Legacy format support
+    else:
+        return create_pose_estimator(model_spec) 

backend/gradio_labanmovementanalysis/video_downloader.py

@@ -0,0 +1,295 @@
+"""
+Video downloader for YouTube, Vimeo and other platforms
+"""
+
+import os
+import re
+import tempfile
+import logging
+from typing import Optional, Tuple, Dict, Any
+from urllib.parse import urlparse, parse_qs
+import subprocess
+
+logger = logging.getLogger(__name__)
+
+
+class VideoDownloader:
+    """Download videos from various platforms"""
+    
+    # Gradio component compatibility
+    events = {}
+    
+    def __init__(self, temp_dir: Optional[str] = None):
+        """
+        Initialize video downloader.
+        
+        Args:
+            temp_dir: Directory for temporary files
+        """
+        self.temp_dir = temp_dir or tempfile.mkdtemp(prefix="laban_video_")
+        self.supported_platforms = {
+            'youtube': self._download_youtube,
+            'vimeo': self._download_vimeo,
+            'direct': self._download_direct
+        }
+        
+    def download(self, url: str) -> Tuple[str, Dict[str, Any]]:
+        """
+        Download video from URL.
+        
+        Args:
+            url: Video URL (YouTube, Vimeo, or direct video link)
+            
+        Returns:
+            Tuple of (local_path, metadata)
+        """
+        platform = self._detect_platform(url)
+        
+        if platform not in self.supported_platforms:
+            raise ValueError(f"Unsupported platform: {platform}")
+            
+        logger.info(f"Downloading video from {platform}: {url}")
+        
+        try:
+            return self.supported_platforms[platform](url)
+        except Exception as e:
+            logger.error(f"Failed to download video: {str(e)}")
+            raise
+    
+    def _detect_platform(self, url: str) -> str:
+        """Detect video platform from URL"""
+        domain = urlparse(url).netloc.lower()
+        
+        if 'youtube.com' in domain or 'youtu.be' in domain:
+            return 'youtube'
+        elif 'vimeo.com' in domain:
+            return 'vimeo'
+        elif url.endswith(('.mp4', '.avi', '.mov', '.webm')):
+            return 'direct'
+        else:
+            # Try to determine if it's a direct video link
+            return 'direct'
+    
+    def _download_youtube(self, url: str) -> Tuple[str, Dict[str, Any]]:
+        """Download video from YouTube using yt-dlp"""
+        try:
+            import yt_dlp
+        except ImportError:
+            raise ImportError("yt-dlp is required for YouTube downloads. Install with: pip install yt-dlp")
+        
+        # Extract video ID
+        video_id = self._extract_youtube_id(url)
+        output_path = os.path.join(self.temp_dir, f"youtube_{video_id}.mp4")
+        
+        # yt-dlp options
+        ydl_opts = {
+            'format': 'best[height<=720][ext=mp4]/best[height<=720]/best',  # Limit to 720p for performance
+            'outtmpl': output_path,
+            'quiet': True,
+            'no_warnings': True,
+            'extract_flat': False,
+        }
+        
+        metadata = {}
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            try:
+                # Extract info
+                info = ydl.extract_info(url, download=True)
+                
+                # Store metadata
+                metadata = {
+                    'title': info.get('title', 'Unknown'),
+                    'duration': info.get('duration', 0),
+                    'uploader': info.get('uploader', 'Unknown'),
+                    'view_count': info.get('view_count', 0),
+                    'description': info.get('description', ''),
+                    'platform': 'youtube',
+                    'video_id': video_id
+                }
+                
+                logger.info(f"Downloaded YouTube video: {metadata['title']}")
+                
+            except Exception as e:
+                raise Exception(f"Failed to download YouTube video: {str(e)}")
+        
+        return output_path, metadata
+    
+    def _download_vimeo(self, url: str) -> Tuple[str, Dict[str, Any]]:
+        """Download video from Vimeo using yt-dlp"""
+        try:
+            import yt_dlp
+        except ImportError:
+            raise ImportError("yt-dlp is required for Vimeo downloads. Install with: pip install yt-dlp")
+        
+        # Extract video ID
+        video_id = self._extract_vimeo_id(url)
+        output_path = os.path.join(self.temp_dir, f"vimeo_{video_id}.mp4")
+        
+        # yt-dlp options
+        ydl_opts = {
+            'format': 'best[height<=720][ext=mp4]/best[height<=720]/best',
+            'outtmpl': output_path,
+            'quiet': True,
+            'no_warnings': True,
+        }
+        
+        metadata = {}
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            try:
+                # Extract info
+                info = ydl.extract_info(url, download=True)
+                
+                # Store metadata
+                metadata = {
+                    'title': info.get('title', 'Unknown'),
+                    'duration': info.get('duration', 0),
+                    'uploader': info.get('uploader', 'Unknown'),
+                    'description': info.get('description', ''),
+                    'platform': 'vimeo',
+                    'video_id': video_id
+                }
+                
+                logger.info(f"Downloaded Vimeo video: {metadata['title']}")
+                
+            except Exception as e:
+                raise Exception(f"Failed to download Vimeo video: {str(e)}")
+        
+        return output_path, metadata
+    
+    def _download_direct(self, url: str) -> Tuple[str, Dict[str, Any]]:
+        """Download video from direct URL"""
+        import requests
+        
+        # Generate filename from URL
+        filename = os.path.basename(urlparse(url).path) or "video.mp4"
+        output_path = os.path.join(self.temp_dir, filename)
+        
+        try:
+            # Download with streaming
+            response = requests.get(url, stream=True)
+            response.raise_for_status()
+            
+            # Get content length
+            total_size = int(response.headers.get('content-length', 0))
+            
+            # Write to file
+            with open(output_path, 'wb') as f:
+                downloaded = 0
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        
+                        # Progress logging
+                        if total_size > 0:
+                            progress = (downloaded / total_size) * 100
+                            if int(progress) % 10 == 0:
+                                logger.debug(f"Download progress: {progress:.1f}%")
+            
+            metadata = {
+                'title': filename,
+                'platform': 'direct',
+                'url': url,
+                'size': total_size
+            }
+            
+            logger.info(f"Downloaded direct video: {filename}")
+            
+        except Exception as e:
+            raise Exception(f"Failed to download direct video: {str(e)}")
+        
+        return output_path, metadata
+    
+    def _extract_youtube_id(self, url: str) -> str:
+        """Extract YouTube video ID from URL"""
+        patterns = [
+            r'(?:v=|\/)([0-9A-Za-z_-]{11}).*',
+            r'(?:embed\/)([0-9A-Za-z_-]{11})',
+            r'(?:watch\?v=)([0-9A-Za-z_-]{11})',
+            r'youtu\.be\/([0-9A-Za-z_-]{11})'
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, url)
+            if match:
+                return match.group(1)
+                
+        raise ValueError(f"Could not extract YouTube video ID from: {url}")
+    
+    def _extract_vimeo_id(self, url: str) -> str:
+        """Extract Vimeo video ID from URL"""
+        patterns = [
+            r'vimeo\.com\/(\d+)',
+            r'player\.vimeo\.com\/video\/(\d+)'
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, url)
+            if match:
+                return match.group(1)
+                
+        raise ValueError(f"Could not extract Vimeo video ID from: {url}")
+    
+    def cleanup(self):
+        """Clean up temporary files"""
+        import shutil
+        if os.path.exists(self.temp_dir):
+            try:
+                shutil.rmtree(self.temp_dir)
+                logger.info(f"Cleaned up temporary directory: {self.temp_dir}")
+            except Exception as e:
+                logger.warning(f"Failed to clean up temporary directory: {str(e)}")
+
+
+class SmartVideoInput:
+    """Smart video input handler that supports URLs and local files"""
+    
+    events = {}  # Gradio component compatibility
+    
+    def __init__(self):
+        self.downloader = VideoDownloader()
+        self._temp_files = []
+        
+    def process_input(self, input_path: str) -> Tuple[str, Dict[str, Any]]:
+        """
+        Process video input - can be local file or URL.
+        
+        Args:
+            input_path: Local file path or video URL
+            
+        Returns:
+            Tuple of (local_path, metadata)
+        """
+        # Check if it's a URL
+        if input_path.startswith(('http://', 'https://', 'www.')):
+            # Download video
+            local_path, metadata = self.downloader.download(input_path)
+            self._temp_files.append(local_path)
+            return local_path, metadata
+        else:
+            # Local file
+            if not os.path.exists(input_path):
+                raise FileNotFoundError(f"Video file not found: {input_path}")
+                
+            metadata = {
+                'title': os.path.basename(input_path),
+                'platform': 'local',
+                'path': input_path
+            }
+            
+            return input_path, metadata
+    
+    def cleanup(self):
+        """Clean up temporary files"""
+        for temp_file in self._temp_files:
+            try:
+                if os.path.exists(temp_file):
+                    os.remove(temp_file)
+                    logger.debug(f"Removed temporary file: {temp_file}")
+            except Exception as e:
+                logger.warning(f"Failed to remove temporary file: {str(e)}")
+        
+        self._temp_files.clear()
+        self.downloader.cleanup() 

backend/gradio_labanmovementanalysis/video_utils.py

@@ -0,0 +1,150 @@
+"""
+Video utilities for reading and writing video files, extracting frames, and assembling videos.
+This module isolates video I/O logic from the rest of the pipeline.
+"""
+
+import cv2
+import numpy as np
+from typing import Generator, List, Tuple, Optional
+from pathlib import Path
+
+
+def extract_frames(video_path: str) -> Generator[np.ndarray, None, None]:
+    """
+    Extract frames from a video file.
+    
+    Args:
+        video_path: Path to the input video file
+        
+    Yields:
+        numpy arrays representing each frame (BGR format)
+    """
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise ValueError(f"Could not open video file: {video_path}")
+    
+    try:
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            yield frame
+    finally:
+        cap.release()
+
+
+def get_video_info(video_path: str) -> Tuple[int, float, Tuple[int, int]]:
+    """
+    Get video metadata.
+    
+    Args:
+        video_path: Path to the video file
+        
+    Returns:
+        Tuple of (frame_count, fps, (width, height))
+    """
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise ValueError(f"Could not open video file: {video_path}")
+    
+    try:
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        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))
+        return frame_count, fps, (width, height)
+    finally:
+        cap.release()
+
+
+def assemble_video(frames: List[np.ndarray], output_path: str, fps: float) -> str:
+    """
+    Assemble frames into a video file.
+    
+    Args:
+        frames: List of frame arrays (BGR format)
+        output_path: Path for the output video file
+        fps: Frames per second for the output video
+        
+    Returns:
+        Path to the created video file
+    """
+    if not frames:
+        raise ValueError("No frames provided for video assembly")
+    
+    # Get frame dimensions from first frame
+    height, width = frames[0].shape[:2]
+    
+    # Create video writer
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    
+    if not out.isOpened():
+        raise ValueError(f"Could not create video writer for: {output_path}")
+    
+    try:
+        for frame in frames:
+            out.write(frame)
+        return output_path
+    finally:
+        out.release()
+
+
+def resize_frame(frame: np.ndarray, size: Optional[Tuple[int, int]] = None, 
+                 max_dimension: Optional[int] = None) -> np.ndarray:
+    """
+    Resize a frame to specified dimensions.
+    
+    Args:
+        frame: Input frame array
+        size: Target (width, height) if provided
+        max_dimension: Max dimension to constrain to while maintaining aspect ratio
+        
+    Returns:
+        Resized frame
+    """
+    if size is not None:
+        return cv2.resize(frame, size)
+    
+    if max_dimension is not None:
+        h, w = frame.shape[:2]
+        if max(h, w) > max_dimension:
+            scale = max_dimension / max(h, w)
+            new_w = int(w * scale)
+            new_h = int(h * scale)
+            return cv2.resize(frame, (new_w, new_h))
+    
+    return frame
+
+
+def frames_to_video_buffer(frames: List[np.ndarray], fps: float) -> bytes:
+    """
+    Convert frames to video buffer in memory (useful for Gradio).
+    
+    Args:
+        frames: List of frame arrays
+        fps: Frames per second
+        
+    Returns:
+        Video data as bytes
+    """
+    import tempfile
+    import os
+    
+    # Create temporary file
+    with tempfile.NamedTemporaryFile(suffix='.mp4', delete=False) as tmp:
+        tmp_path = tmp.name
+    
+    try:
+        # Write video to temp file
+        assemble_video(frames, tmp_path, fps)
+        
+        # Read back as bytes
+        with open(tmp_path, 'rb') as f:
+            video_data = f.read()
+        
+        return video_data
+    finally:
+        # Clean up temp file
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path) 

backend/gradio_labanmovementanalysis/visualizer.py

@@ -0,0 +1,402 @@
+"""
+Visualizer for creating annotated videos with pose overlays and movement indicators.
+"""
+
+import cv2
+import numpy as np
+from typing import List, Tuple, Optional, Dict, Any
+from collections import deque
+import colorsys
+
+from .pose_estimation import PoseResult, Keypoint
+from .notation_engine import MovementMetrics, Direction, Intensity, Speed
+
+
+class PoseVisualizer:
+    """Creates visual overlays for pose and movement analysis."""
+    
+    # COCO skeleton connections for visualization
+    COCO_SKELETON = [
+        # Face
+        (0, 1), (0, 2), (1, 3), (2, 4),  # nose to eyes, eyes to ears
+        # Upper body
+        (5, 6),  # shoulders
+        (5, 7), (7, 9),  # left arm
+        (6, 8), (8, 10),  # right arm
+        (5, 11), (6, 12),  # shoulders to hips
+        # Lower body
+        (11, 12),  # hips
+        (11, 13), (13, 15),  # left leg
+        (12, 14), (14, 16),  # right leg
+    ]
+    
+    # MediaPipe skeleton connections (33 landmarks)
+    MEDIAPIPE_SKELETON = [
+        # Face connections
+        (0, 1), (1, 2), (2, 3), (3, 7),  # left eye region
+        (0, 4), (4, 5), (5, 6), (6, 8),  # right eye region
+        (9, 10),  # mouth
+        # Upper body
+        (11, 12),  # shoulders
+        (11, 13), (13, 15),  # left arm
+        (12, 14), (14, 16),  # right arm
+        (11, 23), (12, 24),  # shoulders to hips
+        (23, 24),  # hips
+        # Lower body
+        (23, 25), (25, 27), (27, 29), (27, 31),  # left leg
+        (24, 26), (26, 28), (28, 30), (28, 32),  # right leg
+        # Hands
+        (15, 17), (15, 19), (15, 21),  # left hand
+        (16, 18), (16, 20), (16, 22),  # right hand
+    ]
+    
+    def __init__(self, 
+                 trail_length: int = 10,
+                 show_skeleton: bool = True,
+                 show_trails: bool = True,
+                 show_direction_arrows: bool = True,
+                 show_metrics: bool = True):
+        """
+        Initialize visualizer.
+        
+        Args:
+            trail_length: Number of previous frames to show in motion trail
+            show_skeleton: Whether to draw pose skeleton
+            show_trails: Whether to draw motion trails
+            show_direction_arrows: Whether to show movement direction arrows
+            show_metrics: Whether to display text metrics on frame
+        """
+        self.trail_length = trail_length
+        self.show_skeleton = show_skeleton
+        self.show_trails = show_trails
+        self.show_direction_arrows = show_direction_arrows
+        self.show_metrics = show_metrics
+        
+        # Trail history for each keypoint
+        self.trails = {}
+        
+        # Color mapping for intensity
+        self.intensity_colors = {
+            Intensity.LOW: (0, 255, 0),      # Green
+            Intensity.MEDIUM: (0, 165, 255),  # Orange
+            Intensity.HIGH: (0, 0, 255)       # Red
+        }
+    
+    def visualize_frame(self,
+                       frame: np.ndarray,
+                       pose_results: List[PoseResult],
+                       movement_metrics: Optional[MovementMetrics] = None,
+                       frame_index: int = 0) -> np.ndarray:
+        """
+        Add visual annotations to a single frame.
+        
+        Args:
+            frame: Input frame
+            pose_results: Pose detection results for this frame
+            movement_metrics: Movement analysis metrics for this frame
+            frame_index: Current frame index
+            
+        Returns:
+            Annotated frame
+        """
+        # Create a copy to avoid modifying original
+        vis_frame = frame.copy()
+        
+        # Draw for each detected person
+        for person_idx, pose in enumerate(pose_results):
+            # Update trails
+            if self.show_trails:
+                self._update_trails(pose, person_idx)
+                self._draw_trails(vis_frame, person_idx)
+            
+            # Draw skeleton
+            if self.show_skeleton:
+                color = self._get_color_for_metrics(movement_metrics)
+                self._draw_skeleton(vis_frame, pose, color)
+            
+            # Draw keypoints
+            self._draw_keypoints(vis_frame, pose, movement_metrics)
+            
+            # Draw direction arrow
+            if self.show_direction_arrows and movement_metrics:
+                self._draw_direction_arrow(vis_frame, pose, movement_metrics)
+        
+        # Draw metrics overlay
+        if self.show_metrics and movement_metrics:
+            self._draw_metrics_overlay(vis_frame, movement_metrics)
+        
+        return vis_frame
+    
+    def generate_overlay_video(self,
+                              frames: List[np.ndarray],
+                              all_pose_results: List[List[PoseResult]],
+                              all_movement_metrics: List[MovementMetrics],
+                              output_path: str,
+                              fps: float) -> str:
+        """
+        Generate complete video with overlays.
+        
+        Args:
+            frames: List of video frames
+            all_pose_results: Pose results for each frame
+            all_movement_metrics: Movement metrics for each frame
+            output_path: Path for output video
+            fps: Frames per second
+            
+        Returns:
+            Path to created video
+        """
+        if len(frames) != len(all_pose_results) or len(frames) != len(all_movement_metrics):
+            raise ValueError("Mismatched lengths between frames, poses, and metrics")
+        
+        # Reset trails
+        self.trails = {}
+        
+        # Process each frame
+        annotated_frames = []
+        for i, (frame, poses, metrics) in enumerate(
+            zip(frames, all_pose_results, all_movement_metrics)
+        ):
+            annotated_frame = self.visualize_frame(frame, poses, metrics, i)
+            annotated_frames.append(annotated_frame)
+        
+        # Import video_utils locally to avoid circular import
+        from . import video_utils
+        return video_utils.assemble_video(annotated_frames, output_path, fps)
+    
+    def _update_trails(self, pose: PoseResult, person_id: int):
+        """Update motion trails for a person."""
+        if person_id not in self.trails:
+            self.trails[person_id] = {}
+        
+        for kp in pose.keypoints:
+            if kp.confidence < 0.3:
+                continue
+                
+            if kp.name not in self.trails[person_id]:
+                self.trails[person_id][kp.name] = deque(maxlen=self.trail_length)
+            
+            # Convert normalized coordinates to pixel coordinates
+            # This assumes we'll scale them when drawing
+            self.trails[person_id][kp.name].append((kp.x, kp.y))
+    
+    def _draw_trails(self, frame: np.ndarray, person_id: int):
+        """Draw motion trails for a person."""
+        if person_id not in self.trails:
+            return
+        
+        h, w = frame.shape[:2]
+        
+        for joint_name, trail in self.trails[person_id].items():
+            if len(trail) < 2:
+                continue
+            
+            # Draw trail with fading effect
+            for i in range(1, len(trail)):
+                # Calculate opacity based on position in trail
+                alpha = i / len(trail)
+                color = tuple(int(c * alpha) for c in (255, 255, 255))
+                
+                # Convert normalized to pixel coordinates
+                pt1 = (int(trail[i-1][0] * w), int(trail[i-1][1] * h))
+                pt2 = (int(trail[i][0] * w), int(trail[i][1] * h))
+                
+                # Draw trail segment
+                cv2.line(frame, pt1, pt2, color, thickness=max(1, int(3 * alpha)))
+    
+    def _draw_skeleton(self, frame: np.ndarray, pose: PoseResult, color: Tuple[int, int, int]):
+        """Draw pose skeleton."""
+        h, w = frame.shape[:2]
+        
+        # Create keypoint lookup
+        kp_dict = {kp.name: kp for kp in pose.keypoints if kp.confidence > 0.3}
+        
+        # Determine which skeleton to use based on available keypoints
+        skeleton = self._get_skeleton_for_model(pose.keypoints)
+        
+        # Map keypoint names to indices
+        keypoint_names = self._get_keypoint_names_for_model(pose.keypoints)
+        name_to_idx = {name: i for i, name in enumerate(keypoint_names)}
+        
+        # Draw skeleton connections
+        for connection in skeleton:
+            idx1, idx2 = connection
+            if idx1 < len(keypoint_names) and idx2 < len(keypoint_names):
+                name1 = keypoint_names[idx1]
+                name2 = keypoint_names[idx2]
+                
+                if name1 in kp_dict and name2 in kp_dict:
+                    kp1 = kp_dict[name1]
+                    kp2 = kp_dict[name2]
+                    
+                    # Convert to pixel coordinates
+                    pt1 = (int(kp1.x * w), int(kp1.y * h))
+                    pt2 = (int(kp2.x * w), int(kp2.y * h))
+                    
+                    # Draw line
+                    cv2.line(frame, pt1, pt2, color, thickness=2)
+    
+    def _draw_keypoints(self, frame: np.ndarray, pose: PoseResult, 
+                       metrics: Optional[MovementMetrics] = None):
+        """Draw individual keypoints."""
+        h, w = frame.shape[:2]
+        
+        for kp in pose.keypoints:
+            if kp.confidence < 0.3:
+                continue
+            
+            # Convert to pixel coordinates
+            pt = (int(kp.x * w), int(kp.y * h))
+            
+            # Color based on confidence
+            color = self._confidence_to_color(kp.confidence)
+            
+            # Draw keypoint
+            cv2.circle(frame, pt, 4, color, -1)
+            cv2.circle(frame, pt, 5, (255, 255, 255), 1)  # White border
+    
+    def _draw_direction_arrow(self, frame: np.ndarray, pose: PoseResult,
+                             metrics: MovementMetrics):
+        """Draw arrow indicating movement direction."""
+        if metrics.direction == Direction.STATIONARY:
+            return
+        
+        h, w = frame.shape[:2]
+        
+        # Get body center
+        center_x = np.mean([kp.x for kp in pose.keypoints if kp.confidence > 0.3])
+        center_y = np.mean([kp.y for kp in pose.keypoints if kp.confidence > 0.3])
+        
+        # Convert to pixel coordinates
+        center = (int(center_x * w), int(center_y * h))
+        
+        # Calculate arrow endpoint based on direction
+        arrow_length = 50
+        direction_vectors = {
+            Direction.UP: (0, -1),
+            Direction.DOWN: (0, 1),
+            Direction.LEFT: (-1, 0),
+            Direction.RIGHT: (1, 0),
+        }
+        
+        if metrics.direction in direction_vectors:
+            dx, dy = direction_vectors[metrics.direction]
+            end_point = (
+                center[0] + int(dx * arrow_length),
+                center[1] + int(dy * arrow_length)
+            )
+            
+            # Color based on speed
+            color = self._get_color_for_metrics(metrics)
+            
+            # Draw arrow
+            cv2.arrowedLine(frame, center, end_point, color, thickness=3, tipLength=0.3)
+    
+    def _draw_metrics_overlay(self, frame: np.ndarray, metrics: MovementMetrics):
+        """Draw text overlay with movement metrics."""
+        # Define text properties
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        font_scale = 0.6
+        thickness = 2
+        
+        # Create text lines
+        lines = [
+            f"Direction: {metrics.direction.value}",
+            f"Speed: {metrics.speed.value} ({metrics.velocity:.2f})",
+            f"Intensity: {metrics.intensity.value}",
+            f"Fluidity: {metrics.fluidity:.2f}",
+            f"Expansion: {metrics.expansion:.2f}"
+        ]
+        
+        # Draw background rectangle
+        y_offset = 30
+        max_width = max([cv2.getTextSize(line, font, font_scale, thickness)[0][0] 
+                        for line in lines])
+        bg_height = len(lines) * 25 + 10
+        
+        cv2.rectangle(frame, (10, 10), (20 + max_width, 10 + bg_height),
+                     (0, 0, 0), -1)
+        cv2.rectangle(frame, (10, 10), (20 + max_width, 10 + bg_height),
+                     (255, 255, 255), 1)
+        
+        # Draw text
+        for i, line in enumerate(lines):
+            color = (255, 255, 255)
+            if i == 2:  # Intensity line
+                color = self.intensity_colors.get(metrics.intensity, (255, 255, 255))
+            
+            cv2.putText(frame, line, (15, y_offset + i * 25),
+                       font, font_scale, color, thickness)
+    
+    def _get_color_for_metrics(self, metrics: Optional[MovementMetrics]) -> Tuple[int, int, int]:
+        """Get color based on movement metrics."""
+        if metrics is None:
+            return (255, 255, 255)  # White default
+        
+        return self.intensity_colors.get(metrics.intensity, (255, 255, 255))
+    
+    def _confidence_to_color(self, confidence: float) -> Tuple[int, int, int]:
+        """Convert confidence score to color (green=high, red=low)."""
+        # Use HSV color space for smooth gradient
+        hue = confidence * 120  # 0=red, 120=green
+        rgb = colorsys.hsv_to_rgb(hue / 360, 1.0, 1.0)
+        return tuple(int(c * 255) for c in reversed(rgb))  # BGR for OpenCV
+    
+    def _get_skeleton_for_model(self, keypoints: List[Keypoint]) -> List[Tuple[int, int]]:
+        """Determine which skeleton definition to use based on keypoints."""
+        # Simple heuristic: if we have more than 20 keypoints, use MediaPipe skeleton
+        if len(keypoints) > 20:
+            return self.MEDIAPIPE_SKELETON
+        return self.COCO_SKELETON
+    
+    def _get_keypoint_names_for_model(self, keypoints: List[Keypoint]) -> List[str]:
+        """Get ordered list of keypoint names for the model."""
+        # If keypoints have names, use them
+        if keypoints and keypoints[0].name:
+            return [kp.name for kp in keypoints]
+        
+        # Otherwise, use default COCO names
+        from .pose_estimation import MoveNetPoseEstimator
+        return MoveNetPoseEstimator.KEYPOINT_NAMES
+
+
+def create_visualization(
+    video_path: str,
+    pose_results: List[List[PoseResult]],
+    movement_metrics: List[MovementMetrics],
+    output_path: str,
+    show_trails: bool = True,
+    show_metrics: bool = True
+) -> str:
+    """
+    Convenience function to create a visualization from a video file.
+    
+    Args:
+        video_path: Path to input video
+        pose_results: Pose detection results
+        movement_metrics: Movement analysis results
+        output_path: Path for output video
+        show_trails: Whether to show motion trails
+        show_metrics: Whether to show metrics overlay
+        
+    Returns:
+        Path to created video
+    """
+    from . import video_utils
+    
+    # Extract frames
+    frames = list(video_utils.extract_frames(video_path))
+    
+    # Get video info
+    _, fps, _ = video_utils.get_video_info(video_path)
+    
+    # Create visualizer
+    visualizer = PoseVisualizer(
+        show_trails=show_trails,
+        show_metrics=show_metrics
+    )
+    
+    # Generate overlay video
+    return visualizer.generate_overlay_video(
+        frames, pose_results, movement_metrics, output_path, fps
+    ) 

backend/gradio_labanmovementanalysis/webrtc_handler.py

@@ -0,0 +1,293 @@
+"""
+Professional WebRTC handler for real-time video streaming and movement analysis
+Using FastRTC (the current WebRTC standard, replaces deprecated gradio-webrtc)
+Based on: https://fastrtc.org and https://www.gradio.app/guides/object-detection-from-webcam-with-webrtc
+"""
+
+import cv2
+import numpy as np
+from typing import Optional, Dict, Any, Tuple
+from collections import deque
+import time
+import logging
+import os
+
+from .pose_estimation import get_pose_estimator
+from .notation_engine import MovementAnalyzer
+from .visualizer import PoseVisualizer
+
+logger = logging.getLogger(__name__)
+
+# Official Gradio WebRTC approach (compatible with NumPy 1.x)
+try:
+    from gradio_webrtc import WebRTC
+    HAS_WEBRTC_COMPONENT = True
+except ImportError:
+    HAS_WEBRTC_COMPONENT = False
+
+
+class RealtimeMovementAnalyzer:
+    """Real-time movement analyzer for WebRTC streams following Gradio 5 best practices"""
+    
+    # Gradio component compatibility
+    events = {}
+    
+    def __init__(self, model: str = "mediapipe-lite", buffer_size: int = 30):
+        """
+        Initialize real-time movement analyzer.
+        
+        Args:
+            model: Pose estimation model optimized for real-time processing
+            buffer_size: Number of frames to buffer for analysis
+        """
+        self.model = model
+        self.pose_estimator = get_pose_estimator(model)
+        self.movement_analyzer = MovementAnalyzer(fps=30.0)
+        self.visualizer = PoseVisualizer(
+            trail_length=10,
+            show_skeleton=True,
+            show_trails=True,
+            show_direction_arrows=True,
+            show_metrics=True
+        )
+        
+        # Real-time buffers
+        self.pose_buffer = deque(maxlen=buffer_size)
+        self.metrics_buffer = deque(maxlen=buffer_size)
+        
+        # Performance tracking
+        self.frame_count = 0
+        self.last_fps_update = time.time()
+        self.current_fps = 0.0
+        
+        # Current metrics for display
+        self.current_metrics = {
+            "direction": "stationary",
+            "intensity": "low",
+            "fluidity": 0.0,
+            "expansion": 0.5,
+            "fps": 0.0
+        }
+    
+    def process_frame(self, image: np.ndarray, conf_threshold: float = 0.5) -> np.ndarray:
+        """
+        Process a single frame from WebRTC stream for real-time movement analysis.
+        
+        Args:
+            image: Input frame from webcam as numpy array (RGB format from WebRTC)
+            conf_threshold: Confidence threshold for pose detection
+            
+        Returns:
+            Processed frame with pose overlay and movement metrics
+        """
+        if image is None:
+            return None
+        
+        # Convert RGB to BGR for OpenCV processing
+        frame_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        
+        # Update frame count and FPS
+        self.frame_count += 1
+        current_time = time.time()
+        if current_time - self.last_fps_update >= 1.0:
+            self.current_fps = self.frame_count / (current_time - self.last_fps_update)
+            self.frame_count = 0
+            self.last_fps_update = current_time
+            self.current_metrics["fps"] = self.current_fps
+        
+        # Pose detection
+        pose_results = self.pose_estimator.detect(frame_bgr)
+        
+        # Store pose data
+        self.pose_buffer.append(pose_results)
+        
+        # Calculate movement metrics if we have enough frames
+        if len(self.pose_buffer) >= 2:
+            recent_poses = list(self.pose_buffer)[-10:]  # Last 10 frames for analysis
+            
+            try:
+                # Analyze movement from recent poses
+                movement_metrics = self.movement_analyzer.analyze_movement(recent_poses)
+                
+                if movement_metrics:
+                    latest_metrics = movement_metrics[-1]
+                    self.current_metrics.update({
+                        "direction": latest_metrics.direction.value if latest_metrics.direction else "stationary",
+                        "intensity": latest_metrics.intensity.value if latest_metrics.intensity else "low", 
+                        "fluidity": latest_metrics.fluidity if latest_metrics.fluidity is not None else 0.0,
+                        "expansion": latest_metrics.expansion if latest_metrics.expansion is not None else 0.5
+                    })
+                    
+                    self.metrics_buffer.append(self.current_metrics.copy())
+                    
+            except Exception as e:
+                logger.warning(f"Movement analysis error: {e}")
+        
+        # Apply visualization overlays
+        output_frame = self._apply_visualization(frame_bgr, pose_results, self.current_metrics)
+        
+        # Convert back to RGB for WebRTC output
+        output_rgb = cv2.cvtColor(output_frame, cv2.COLOR_BGR2RGB)
+        
+        return output_rgb
+    
+    def _apply_visualization(self, frame: np.ndarray, pose_results: list, metrics: dict) -> np.ndarray:
+        """Apply pose and movement visualization overlays"""
+        output_frame = frame.copy()
+        
+        # Draw pose skeleton if detected
+        if pose_results:
+            for pose_result in pose_results:
+                # Draw skeleton
+                if hasattr(self.visualizer, 'draw_skeleton'):
+                    output_frame = self.visualizer.draw_skeleton(output_frame, pose_result.keypoints)
+                
+                # Draw keypoints
+                for keypoint in pose_result.keypoints:
+                    if keypoint.confidence > 0.5:
+                        x = int(keypoint.x * frame.shape[1])
+                        y = int(keypoint.y * frame.shape[0])
+                        cv2.circle(output_frame, (x, y), 5, (0, 255, 0), -1)
+        
+        # Draw real-time metrics overlay
+        self._draw_metrics_overlay(output_frame, metrics)
+        
+        return output_frame
+    
+    def _draw_metrics_overlay(self, frame: np.ndarray, metrics: dict):
+        """Draw real-time metrics overlay following professional UI standards"""
+        h, w = frame.shape[:2]
+        
+        # Semi-transparent background
+        overlay = frame.copy()
+        cv2.rectangle(overlay, (10, 10), (320, 160), (0, 0, 0), -1)
+        cv2.addWeighted(overlay, 0.3, frame, 0.7, 0, frame)
+        
+        # Header
+        cv2.putText(frame, "Real-time Movement Analysis", (20, 35), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+        
+        # Metrics
+        y_offset = 60
+        spacing = 22
+        
+        cv2.putText(frame, f"Direction: {metrics['direction']}", 
+                   (20, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+        y_offset += spacing
+        
+        cv2.putText(frame, f"Intensity: {metrics['intensity']}", 
+                   (20, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+        y_offset += spacing
+        
+        cv2.putText(frame, f"Fluidity: {metrics['fluidity']:.2f}", 
+                   (20, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
+        y_offset += spacing
+        
+        cv2.putText(frame, f"FPS: {metrics['fps']:.1f}", 
+                   (20, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0), 1)
+    
+    def get_current_metrics(self) -> dict:
+        """Get current movement metrics for external display"""
+        return self.current_metrics.copy()
+
+
+def get_rtc_configuration():
+    """
+    Get RTC configuration for WebRTC.
+    Uses Twilio TURN servers if credentials are available, otherwise uses default.
+    """
+    # For local development, no TURN servers needed
+    # For cloud deployment, set TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN
+    
+    twilio_account_sid = os.getenv("TWILIO_ACCOUNT_SID")
+    twilio_auth_token = os.getenv("TWILIO_AUTH_TOKEN")
+    
+    if twilio_account_sid and twilio_auth_token:
+        # Use Twilio TURN servers for cloud deployment
+        return {
+            "iceServers": [
+                {"urls": ["stun:global.stun.twilio.com:3478"]},
+                {
+                    "urls": ["turn:global.turn.twilio.com:3478?transport=udp"],
+                    "username": twilio_account_sid,
+                    "credential": twilio_auth_token,
+                },
+                {
+                    "urls": ["turn:global.turn.twilio.com:3478?transport=tcp"],
+                    "username": twilio_account_sid, 
+                    "credential": twilio_auth_token,
+                },
+            ]
+        }
+    else:
+        # Default configuration for local development
+        return {
+            "iceServers": [
+                {"urls": ["stun:stun.l.google.com:19302"]}
+            ]
+        }
+
+
+# Global analyzer instance for demo
+_analyzer = None
+
+def get_analyzer(model: str = "mediapipe-lite") -> RealtimeMovementAnalyzer:
+    """Get or create analyzer instance"""
+    global _analyzer
+    if _analyzer is None or _analyzer.model != model:
+        _analyzer = RealtimeMovementAnalyzer(model)
+    return _analyzer
+
+
+def webrtc_detection(image: np.ndarray, model: str, conf_threshold: float = 0.5) -> np.ndarray:
+    """
+    Main detection function for WebRTC streaming.
+    Compatible with Gradio 5 WebRTC streaming API.
+    
+    Args:
+        image: Input frame from webcam (RGB format)
+        model: Pose estimation model name
+        conf_threshold: Confidence threshold for pose detection
+        
+    Returns:
+        Processed frame with pose overlay and metrics
+    """
+    analyzer = get_analyzer(model)
+    return analyzer.process_frame(image, conf_threshold)
+
+
+def get_webrtc_interface():
+    """
+    Create streaming interface using built-in Gradio components.
+    Avoids NumPy 2.x dependency conflicts with FastRTC.
+    
+    Returns:
+        Tuple of (streaming_config, rtc_configuration)
+    """
+    rtc_config = get_rtc_configuration()
+    
+    # Use built-in Gradio streaming capabilities
+    streaming_config = {
+        "sources": ["webcam"],
+        "streaming": True,
+        "mirror_webcam": False
+    }
+    
+    return streaming_config, rtc_config
+
+
+# Compatibility exports with Gradio component attributes
+class WebRTCMovementAnalyzer(RealtimeMovementAnalyzer):
+    """Real-time movement analyzer for WebRTC streams following Gradio 5 best practices"""
+    events = {}  # Gradio component compatibility
+
+
+class WebRTCGradioInterface:
+    """Create streaming interface using built-in Gradio components.
+    Avoids NumPy 2.x dependency conflicts with FastRTC."""
+    
+    events = {}  # Gradio component compatibility
+    
+    @staticmethod
+    def get_config():
+        return get_webrtc_interface() 

backend/mcp_server.py

@@ -0,0 +1,413 @@
+"""
+MCP (Model Context Protocol) Server for Laban Movement Analysis
+Provides tools for video movement analysis accessible to AI agents
+"""
+
+import asyncio
+import json
+import os
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import urlparse
+import aiofiles
+import httpx
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import (
+    Tool,
+    TextContent,
+    ImageContent,
+    EmbeddedResource,
+    ToolParameterType,
+    ToolResponse,
+    ToolResult,
+    ToolError
+)
+
+# Add parent directory to path for imports
+import sys
+sys.path.insert(0, str(Path(__file__).parent))
+
+from gradio_labanmovementanalysis import LabanMovementAnalysis
+
+
+class LabanMCPServer:
+    """MCP Server for Laban Movement Analysis"""
+    
+    def __init__(self):
+        self.server = Server("laban-movement-analysis")
+        self.analyzer = LabanMovementAnalysis()
+        self.analysis_cache = {}
+        self.temp_dir = tempfile.mkdtemp(prefix="laban_mcp_")
+        
+        # Register tools
+        self._register_tools()
+        
+    def _register_tools(self):
+        """Register all available tools"""
+        
+        @self.server.tool()
+        async def analyze_video(
+            video_path: str,
+            model: str = "mediapipe",
+            enable_visualization: bool = False,
+            include_keypoints: bool = False
+        ) -> ToolResult:
+            """
+            Analyze movement in a video file using Laban Movement Analysis.
+            
+            Args:
+                video_path: Path or URL to video file
+                model: Pose estimation model ('mediapipe', 'movenet', 'yolo')
+                enable_visualization: Generate annotated video output
+                include_keypoints: Include raw keypoint data in JSON
+                
+            Returns:
+                Movement analysis results and optional visualization
+            """
+            try:
+                # Handle URL vs local path
+                if video_path.startswith(('http://', 'https://')):
+                    video_path = await self._download_video(video_path)
+                
+                # Process video
+                json_output, viz_video = await asyncio.to_thread(
+                    self.analyzer.process_video,
+                    video_path,
+                    model=model,
+                    enable_visualization=enable_visualization,
+                    include_keypoints=include_keypoints
+                )
+                
+                # Store in cache
+                analysis_id = f"{Path(video_path).stem}_{datetime.now().isoformat()}"
+                self.analysis_cache[analysis_id] = {
+                    "json_output": json_output,
+                    "viz_video": viz_video,
+                    "timestamp": datetime.now().isoformat()
+                }
+                
+                # Format response
+                response_data = {
+                    "analysis_id": analysis_id,
+                    "analysis": json_output,
+                    "visualization_path": viz_video if viz_video else None
+                }
+                
+                return ToolResult(
+                    success=True,
+                    content=[TextContent(text=json.dumps(response_data, indent=2))]
+                )
+                
+            except Exception as e:
+                return ToolResult(
+                    success=False,
+                    error=ToolError(message=f"Analysis failed: {str(e)}")
+                )
+        
+        @self.server.tool()
+        async def get_analysis_summary(
+            analysis_id: str
+        ) -> ToolResult:
+            """
+            Get a human-readable summary of a previous analysis.
+            
+            Args:
+                analysis_id: ID of the analysis to summarize
+                
+            Returns:
+                Summary of movement analysis
+            """
+            try:
+                if analysis_id not in self.analysis_cache:
+                    return ToolResult(
+                        success=False,
+                        error=ToolError(message=f"Analysis ID '{analysis_id}' not found")
+                    )
+                
+                analysis_data = self.analysis_cache[analysis_id]["json_output"]
+                
+                # Extract key information
+                summary = self._generate_summary(analysis_data)
+                
+                return ToolResult(
+                    success=True,
+                    content=[TextContent(text=summary)]
+                )
+                
+            except Exception as e:
+                return ToolResult(
+                    success=False,
+                    error=ToolError(message=f"Summary generation failed: {str(e)}")
+                )
+        
+        @self.server.tool()
+        async def list_available_models() -> ToolResult:
+            """
+            List available pose estimation models with their characteristics.
+            
+            Returns:
+                Information about available models
+            """
+            models_info = {
+                "mediapipe": {
+                    "name": "MediaPipe Pose",
+                    "keypoints": 33,
+                    "dimensions": "3D",
+                    "optimization": "CPU",
+                    "best_for": "Single person, detailed analysis",
+                    "speed": "Fast"
+                },
+                "movenet": {
+                    "name": "MoveNet",
+                    "keypoints": 17,
+                    "dimensions": "2D",
+                    "optimization": "Mobile/Edge",
+                    "best_for": "Real-time applications, mobile devices",
+                    "speed": "Very Fast"
+                },
+                "yolo": {
+                    "name": "YOLO Pose",
+                    "keypoints": 17,
+                    "dimensions": "2D", 
+                    "optimization": "GPU",
+                    "best_for": "Multi-person detection",
+                    "speed": "Fast (with GPU)"
+                }
+            }
+            
+            return ToolResult(
+                success=True,
+                content=[TextContent(text=json.dumps(models_info, indent=2))]
+            )
+        
+        @self.server.tool()
+        async def batch_analyze(
+            video_paths: List[str],
+            model: str = "mediapipe",
+            parallel: bool = True
+        ) -> ToolResult:
+            """
+            Analyze multiple videos in batch.
+            
+            Args:
+                video_paths: List of video paths or URLs
+                model: Pose estimation model to use
+                parallel: Process videos in parallel
+                
+            Returns:
+                Batch analysis results
+            """
+            try:
+                results = {}
+                
+                if parallel:
+                    # Process in parallel
+                    tasks = []
+                    for path in video_paths:
+                        task = self._analyze_single_video(path, model)
+                        tasks.append(task)
+                    
+                    analyses = await asyncio.gather(*tasks)
+                    
+                    for path, analysis in zip(video_paths, analyses):
+                        results[path] = analysis
+                else:
+                    # Process sequentially
+                    for path in video_paths:
+                        results[path] = await self._analyze_single_video(path, model)
+                
+                return ToolResult(
+                    success=True,
+                    content=[TextContent(text=json.dumps(results, indent=2))]
+                )
+                
+            except Exception as e:
+                return ToolResult(
+                    success=False,
+                    error=ToolError(message=f"Batch analysis failed: {str(e)}")
+                )
+        
+        @self.server.tool()
+        async def compare_movements(
+            analysis_id1: str,
+            analysis_id2: str
+        ) -> ToolResult:
+            """
+            Compare movement patterns between two analyzed videos.
+            
+            Args:
+                analysis_id1: First analysis ID
+                analysis_id2: Second analysis ID
+                
+            Returns:
+                Comparison of movement metrics
+            """
+            try:
+                if analysis_id1 not in self.analysis_cache:
+                    return ToolResult(
+                        success=False,
+                        error=ToolError(message=f"Analysis ID '{analysis_id1}' not found")
+                    )
+                    
+                if analysis_id2 not in self.analysis_cache:
+                    return ToolResult(
+                        success=False,
+                        error=ToolError(message=f"Analysis ID '{analysis_id2}' not found")
+                    )
+                
+                # Get analyses
+                analysis1 = self.analysis_cache[analysis_id1]["json_output"]
+                analysis2 = self.analysis_cache[analysis_id2]["json_output"]
+                
+                # Compare metrics
+                comparison = self._compare_analyses(analysis1, analysis2)
+                
+                return ToolResult(
+                    success=True,
+                    content=[TextContent(text=json.dumps(comparison, indent=2))]
+                )
+                
+            except Exception as e:
+                return ToolResult(
+                    success=False,
+                    error=ToolError(message=f"Comparison failed: {str(e)}")
+                )
+    
+    async def _download_video(self, url: str) -> str:
+        """Download video from URL to temporary file"""
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            
+            # Save to temp file
+            filename = Path(urlparse(url).path).name or "video.mp4"
+            temp_path = os.path.join(self.temp_dir, filename)
+            
+            async with aiofiles.open(temp_path, 'wb') as f:
+                await f.write(response.content)
+            
+            return temp_path
+    
+    async def _analyze_single_video(self, path: str, model: str) -> Dict[str, Any]:
+        """Analyze a single video"""
+        try:
+            if path.startswith(('http://', 'https://')):
+                path = await self._download_video(path)
+                
+            json_output, _ = await asyncio.to_thread(
+                self.analyzer.process_video,
+                path,
+                model=model,
+                enable_visualization=False
+            )
+            
+            return {
+                "status": "success",
+                "analysis": json_output
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e)
+            }
+    
+    def _generate_summary(self, analysis_data: Dict[str, Any]) -> str:
+        """Generate human-readable summary from analysis data"""
+        summary_parts = []
+        
+        # Video info
+        video_info = analysis_data.get("video_info", {})
+        summary_parts.append(f"Video Analysis Summary")
+        summary_parts.append(f"Duration: {video_info.get('duration_seconds', 0):.1f} seconds")
+        summary_parts.append(f"Resolution: {video_info.get('width', 0)}x{video_info.get('height', 0)}")
+        summary_parts.append("")
+        
+        # Movement summary
+        movement_summary = analysis_data.get("movement_analysis", {}).get("summary", {})
+        
+        # Direction analysis
+        direction_data = movement_summary.get("direction", {})
+        dominant_direction = direction_data.get("dominant", "unknown")
+        summary_parts.append(f"Dominant Movement Direction: {dominant_direction}")
+        
+        # Intensity analysis
+        intensity_data = movement_summary.get("intensity", {})
+        dominant_intensity = intensity_data.get("dominant", "unknown")
+        summary_parts.append(f"Movement Intensity: {dominant_intensity}")
+        
+        # Speed analysis
+        speed_data = movement_summary.get("speed", {})
+        dominant_speed = speed_data.get("dominant", "unknown")
+        summary_parts.append(f"Movement Speed: {dominant_speed}")
+        
+        # Segments
+        segments = movement_summary.get("movement_segments", [])
+        if segments:
+            summary_parts.append(f"\nMovement Segments: {len(segments)}")
+            for i, segment in enumerate(segments[:3]):  # Show first 3
+                start_time = segment.get("start_time", 0)
+                end_time = segment.get("end_time", 0)
+                movement_type = segment.get("movement_type", "unknown")
+                summary_parts.append(f"  Segment {i+1}: {movement_type} ({start_time:.1f}s - {end_time:.1f}s)")
+        
+        return "\n".join(summary_parts)
+    
+    def _compare_analyses(self, analysis1: Dict, analysis2: Dict) -> Dict[str, Any]:
+        """Compare two movement analyses"""
+        comparison = {
+            "video1_info": analysis1.get("video_info", {}),
+            "video2_info": analysis2.get("video_info", {}),
+            "metric_comparison": {}
+        }
+        
+        # Compare summaries
+        summary1 = analysis1.get("movement_analysis", {}).get("summary", {})
+        summary2 = analysis2.get("movement_analysis", {}).get("summary", {})
+        
+        # Compare directions
+        dir1 = summary1.get("direction", {})
+        dir2 = summary2.get("direction", {})
+        comparison["metric_comparison"]["direction"] = {
+            "video1_dominant": dir1.get("dominant", "unknown"),
+            "video2_dominant": dir2.get("dominant", "unknown"),
+            "match": dir1.get("dominant") == dir2.get("dominant")
+        }
+        
+        # Compare intensity
+        int1 = summary1.get("intensity", {})
+        int2 = summary2.get("intensity", {})
+        comparison["metric_comparison"]["intensity"] = {
+            "video1_dominant": int1.get("dominant", "unknown"),
+            "video2_dominant": int2.get("dominant", "unknown"),
+            "match": int1.get("dominant") == int2.get("dominant")
+        }
+        
+        # Compare speed
+        speed1 = summary1.get("speed", {})
+        speed2 = summary2.get("speed", {})
+        comparison["metric_comparison"]["speed"] = {
+            "video1_dominant": speed1.get("dominant", "unknown"),
+            "video2_dominant": speed2.get("dominant", "unknown"),
+            "match": speed1.get("dominant") == speed2.get("dominant")
+        }
+        
+        return comparison
+    
+    async def run(self):
+        """Run the MCP server"""
+        async with stdio_server() as (read_stream, write_stream):
+            await self.server.run(read_stream, write_stream)
+
+
+async def main():
+    """Main entry point"""
+    server = LabanMCPServer()
+    await server.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

backend/requirements-mcp.txt

@@ -0,0 +1,27 @@
+# MCP Server Dependencies
+mcp>=1.0.0
+aiofiles>=23.0.0
+httpx>=0.24.0
+
+# Core dependencies (include from main requirements)
+gradio>=5.0,<6.0
+opencv-python>=4.8.0
+numpy>=1.24.0,<2.0.0  # Pin to 1.x for compatibility with MediaPipe/pandas
+mediapipe>=0.10.0
+tensorflow>=2.13.0  # For MoveNet
+tensorflow-hub>=0.14.0  # For MoveNet models
+ultralytics>=8.0.0  # For YOLO v8/v11
+torch>=2.0.0
+torchvision>=0.15.0
+
+# Video platform support
+yt-dlp>=2023.7.6  # YouTube/Vimeo downloads
+requests>=2.31.0  # Direct video downloads
+
+# Enhanced model support  
+transformers>=4.35.0
+accelerate>=0.24.0  # For model optimization
+
+# WebRTC support (Official Gradio approach)
+gradio-webrtc  # Official WebRTC component for Gradio
+twilio>=8.2.0  # TURN servers for cloud deployment (optional) 

backend/requirements.txt

@@ -0,0 +1,20 @@
+# Core dependencies
+gradio>=5.0.0
+numpy>=1.20.0
+opencv-python>=4.5.0
+
+# Pose estimation model dependencies (install based on your choice)
+# For MediaPipe:
+mediapipe>=0.10.21
+
+# For MoveNet (TensorFlow):
+ tensorflow>=2.8.0
+ tensorflow-hub>=0.12.0
+
+# For YOLO:
+ ultralytics>=8.0.0
+
+# Optional dependencies for development
+# pytest>=7.0.0
+# black>=22.0.0
+# flake8>=4.0.0 

demo/app.py

@@ -0,0 +1,866 @@
+"""
+Unified Laban Movement Analysis Demo
+Comprehensive interface combining all features: 
+- Standard LMA analysis
+- Enhanced features (WebRTC, YouTube/Vimeo)
+- Agent API (batch processing, filtering)
+- Real-time analysis
+- Model comparison
+
+Created by: Csaba Bolyós (BladeSzaSza)
+Contact: [email protected]
+GitHub: https://github.com/bladeszasza
+LinkedIn: https://www.linkedin.com/in/csaba-bolyós-00a11767/
+Hugging Face: https://huggingface.co/BladeSzaSza
+
+Heavy Beta Version - Under Active Development
+"""
+
+import gradio as gr
+import sys
+from pathlib import Path
+from typing import Dict, Any, List, Tuple
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent / "backend"))
+
+from gradio_labanmovementanalysis import LabanMovementAnalysis
+
+# Import agent API if available
+try:
+    from gradio_labanmovementanalysis.agent_api import (
+        LabanAgentAPI,
+        PoseModel,
+        MovementDirection,
+        MovementIntensity
+    )
+    HAS_AGENT_API = True
+except ImportError:
+    HAS_AGENT_API = False
+
+# Import WebRTC components if available
+try:
+    from gradio_webrtc import WebRTC
+    from gradio_labanmovementanalysis.webrtc_handler import (
+        webrtc_detection,
+        get_rtc_configuration
+    )
+    HAS_WEBRTC = True
+except ImportError as e:
+    print(f"WebRTC import failed: {e}")
+    HAS_WEBRTC = False
+
+# Initialize components
+try:
+    # Initialize with WebRTC support
+    analyzer = LabanMovementAnalysis(
+        enable_webrtc=True,
+        enable_visualization=True
+    )
+    print("✅ Core features initialized successfully")
+except Exception as e:
+    print(f"Warning: Some features may not be available: {e}")
+    analyzer = LabanMovementAnalysis(enable_webrtc=False)
+
+# Initialize agent API if available
+agent_api = None
+if HAS_AGENT_API:
+    try:
+        agent_api = LabanAgentAPI()
+    except Exception as e:
+        print(f"Warning: Agent API not available: {e}")
+        agent_api = None
+
+
+def process_video_standard(video, model, enable_viz, include_keypoints):
+    """Standard video processing function."""
+    if video is None:
+        return None, None
+    
+    try:
+        json_output, video_output = analyzer.process_video(
+            video,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_output, video_output
+    except Exception as e:
+        return {"error": str(e)}, None
+
+
+def process_video_enhanced(video_input, model, enable_viz, include_keypoints):
+    """Enhanced video processing with all new features."""
+    if not video_input:
+        return {"error": "No video provided"}, None
+    
+    try:
+        # Handle both file upload and URL input
+        video_path = video_input.name if hasattr(video_input, 'name') else video_input
+        
+        json_result, viz_result = analyzer.process_video(
+            video_path,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_result, viz_result
+    except Exception as e:
+        error_result = {"error": str(e)}
+        return error_result, None
+
+
+def process_video_for_agent(video, model, output_format="summary"):
+    """Process video with agent-friendly output format."""
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not video:
+        return {"error": "No video provided"}
+    
+    try:
+        model_enum = PoseModel(model)
+        result = agent_api.analyze(video, model=model_enum, generate_visualization=False)
+        
+        if output_format == "summary":
+            return {"summary": agent_api.get_movement_summary(result)}
+        elif output_format == "structured":
+            return {
+                "success": result.success,
+                "direction": result.dominant_direction.value,
+                "intensity": result.dominant_intensity.value,
+                "speed": result.dominant_speed,
+                "fluidity": result.fluidity_score,
+                "expansion": result.expansion_score,
+                "segments": len(result.movement_segments)
+            }
+        else:  # json
+            return result.raw_data
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def batch_process_videos(files, model):
+    """Process multiple videos in batch."""
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not files:
+        return {"error": "No videos provided"}
+    
+    try:
+        video_paths = [f.name for f in files]
+        results = agent_api.batch_analyze(video_paths, model=PoseModel(model), parallel=True)
+        
+        output = {
+            "total_videos": len(results),
+            "successful": sum(1 for r in results if r.success),
+            "failed": sum(1 for r in results if not r.success),
+            "results": []
+        }
+        
+        for result in results:
+            output["results"].append({
+                "video": Path(result.video_path).name,
+                "success": result.success,
+                "summary": agent_api.get_movement_summary(result) if result.success else result.error
+            })
+        
+        return output
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def filter_videos_by_movement(files, direction, intensity, min_fluidity, min_expansion):
+    """Filter videos based on movement characteristics."""
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not files:
+        return {"error": "No videos provided"}
+    
+    try:
+        video_paths = [f.name for f in files]
+        
+        dir_filter = MovementDirection(direction) if direction != "any" else None
+        int_filter = MovementIntensity(intensity) if intensity != "any" else None
+        
+        filtered = agent_api.filter_by_movement(
+            video_paths,
+            direction=dir_filter,
+            intensity=int_filter,
+            min_fluidity=min_fluidity if min_fluidity > 0 else None,
+            min_expansion=min_expansion if min_expansion > 0 else None
+        )
+        
+        return {
+            "total_analyzed": len(video_paths),
+            "matching_videos": len(filtered),
+            "matches": [
+                {
+                    "video": Path(r.video_path).name,
+                    "direction": r.dominant_direction.value,
+                    "intensity": r.dominant_intensity.value,
+                    "fluidity": r.fluidity_score,
+                    "expansion": r.expansion_score
+                }
+                for r in filtered
+            ]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def compare_models(video, model1, model2):
+    """Compare two different pose models on the same video."""
+    if not video:
+        return "No video provided"
+    
+    try:
+        # Analyze with both models
+        result1, _ = analyzer.process_video(video, model=model1, enable_visualization=False)
+        result2, _ = analyzer.process_video(video, model=model2, enable_visualization=False)
+        
+        # Extract key metrics for comparison
+        def extract_metrics(result):
+            summary = result.get("movement_analysis", {}).get("summary", {})
+            return {
+                "direction": summary.get("direction", {}).get("dominant", "unknown"),
+                "intensity": summary.get("intensity", {}).get("dominant", "unknown"), 
+                "speed": summary.get("speed", {}).get("dominant", "unknown"),
+                "frame_count": result.get("video_info", {}).get("frame_count", 0)
+            }
+        
+        metrics1 = extract_metrics(result1)
+        metrics2 = extract_metrics(result2)
+        
+        # Create comparison table data
+        comparison_data = [
+            ["Direction", metrics1["direction"], metrics2["direction"], 
+             "✓" if metrics1["direction"] == metrics2["direction"] else "✗"],
+            ["Intensity", metrics1["intensity"], metrics2["intensity"],
+             "✓" if metrics1["intensity"] == metrics2["intensity"] else "✗"],
+            ["Speed", metrics1["speed"], metrics2["speed"],
+             "✓" if metrics1["speed"] == metrics2["speed"] else "✗"],
+            ["Frames Processed", str(metrics1["frame_count"]), str(metrics2["frame_count"]),
+             "✓" if metrics1["frame_count"] == metrics2["frame_count"] else "✗"]
+        ]
+        
+        return comparison_data
+        
+    except Exception as e:
+        return [["Error", str(e), "", ""]]
+
+
+def start_webrtc_stream(model):
+    """Start WebRTC real-time analysis."""
+    try:
+        success = analyzer.start_webrtc_stream(model)
+        if success:
+            return "🟢 Stream Active", {"status": "streaming", "model": model}
+        else:
+            return "🔴 Failed to start", {"status": "error"}
+    except Exception as e:
+        return f"🔴 Error: {str(e)}", {"status": "error"}
+
+
+def stop_webrtc_stream():
+    """Stop WebRTC real-time analysis."""
+    try:
+        success = analyzer.stop_webrtc_stream()
+        if success:
+            return "🟡 Stream Stopped", {"status": "stopped"}
+        else:
+            return "🔴 Failed to stop", {"status": "error"}
+    except Exception as e:
+        return f"🔴 Error: {str(e)}", {"status": "error"}
+
+
+def create_unified_demo():
+    """Create the unified comprehensive demo."""
+    
+    with gr.Blocks(
+        title="Laban Movement Analysis - Complete Suite by Csaba Bolyós",
+        theme=gr.themes.Soft(),
+        css="""
+        .main-header {
+            background: linear-gradient(135deg, #40826D 0%, #2E5E4A 50%, #1B3A2F 100%);
+            color: white;
+            padding: 30px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+            text-align: center;
+        }
+        .feature-card {
+            border: 1px solid #e1e5e9;
+            border-radius: 8px;
+            padding: 16px;
+            margin: 8px 0;
+            background: #f8f9fa;
+        }
+        .json-output {
+            max-height: 600px;
+            overflow-y: auto;
+            font-family: monospace;
+            font-size: 12px;
+        }
+        .author-info {
+            background: linear-gradient(135deg, #40826D 0%, #2E5E4A 100%);
+            color: white;
+            padding: 15px;
+            border-radius: 8px;
+            margin: 10px 0;
+            text-align: center;
+        }
+        """
+    ) as demo:
+        
+        # Main Header
+        gr.HTML("""
+        <div class="main-header">
+            <h1>🎭 Laban Movement Analysis - Complete Suite</h1>
+            <p style="font-size: 18px; margin: 10px 0;">
+                Professional movement analysis with pose estimation, AI action recognition, 
+                real-time processing, and agent automation
+            </p>
+            <p style="font-size: 14px; opacity: 0.9;">
+                Supports YouTube/Vimeo URLs • WebRTC Streaming • 20+ Pose Models • MCP Integration
+            </p>
+            <p style="font-size: 12px; margin-top: 15px; opacity: 0.8;">
+                <strong>Version 0.01-beta</strong> - Heavy Beta Under Active Development
+            </p>
+        </div>
+        """)
+     
+        with gr.Tabs():
+            # Tab 1: Standard Analysis
+            with gr.Tab("🎬 Standard Analysis"):
+                gr.Markdown("""
+                ### Classic Laban Movement Analysis
+                Upload a video file to analyze movement using traditional LMA metrics with pose estimation.
+                """)
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        video_input_std = gr.Video(
+                            label="Upload Video",
+                            sources=["upload"],
+                            format="mp4"
+                        )
+                        
+                        model_dropdown_std = gr.Dropdown(
+                            choices=["mediapipe", "movenet", "yolo"],
+                            value="mediapipe",
+                            label="Pose Estimation Model"
+                        )
+                        
+                        with gr.Row():
+                            enable_viz_std = gr.Checkbox(
+                                value=True,
+                                label="Generate Visualization"
+                            )
+                            
+                            include_keypoints_std = gr.Checkbox(
+                                value=False,
+                                label="Include Keypoints"
+                            )
+                        
+                        process_btn_std = gr.Button("Analyze Movement", variant="primary")
+                        
+                        gr.Examples(
+                            examples=[
+                                ["examples/balette.mov"],
+                                ["examples/balette.mp4"],
+                            ],
+                            inputs=video_input_std,
+                            label="Example Videos"
+                        )
+                    
+                    with gr.Column(scale=2):
+                        with gr.Tab("Analysis Results"):
+                            json_output_std = gr.JSON(
+                                label="Movement Analysis (JSON)",
+                                elem_classes=["json-output"]
+                            )
+                        
+                        with gr.Tab("Visualization"):
+                            video_output_std = gr.Video(
+                                label="Annotated Video",
+                                format="mp4"
+                            )
+                            
+                            gr.Markdown("""
+                            **Visualization Guide:**
+                            - 🦴 **Skeleton**: Pose keypoints and connections
+                            - 🌊 **Trails**: Motion history (fading lines)
+                            - ➡️ **Arrows**: Movement direction indicators
+                            - 🎨 **Colors**: Green (low) → Orange (medium) → Red (high) intensity
+                            """)
+                
+                process_btn_std.click(
+                    fn=process_video_standard,
+                    inputs=[video_input_std, model_dropdown_std, enable_viz_std, include_keypoints_std],
+                    outputs=[json_output_std, video_output_std],
+                    api_name="analyze_standard"
+                )
+            
+            # Tab 2: Enhanced Analysis
+            with gr.Tab("🚀 Enhanced Analysis"):
+                gr.Markdown("""
+                ### Advanced Analysis with AI and URL Support
+                Analyze videos from URLs (YouTube/Vimeo), use advanced pose models, and get AI-powered insights.
+                """)
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.HTML('<div class="feature-card">')
+                        gr.Markdown("**Video Input**")
+                        
+                        # Changed from textbox to file upload as requested
+                        video_input_enh = gr.File(
+                            label="Upload Video or Drop File",
+                            file_types=["video"],
+                            type="filepath"
+                        )
+                        
+                        # URL input option
+                        url_input_enh = gr.Textbox(
+                            label="Or Enter Video URL",
+                            placeholder="YouTube URL, Vimeo URL, or direct video URL",
+                            info="Leave file upload empty to use URL"
+                        )
+                        
+                        gr.Examples(
+                            examples=[
+                                ["examples/balette.mov"],
+                                ["https://www.youtube.com/shorts/RX9kH2l3L8U"],
+                                ["https://vimeo.com/815392738"]
+                            ],
+                            inputs=url_input_enh,
+                            label="Example URLs"
+                        )
+                        
+                        gr.Markdown("**Model Selection**")
+                        
+                        model_select_enh = gr.Dropdown(
+                            choices=[
+                                # MediaPipe variants
+                                "mediapipe-lite", "mediapipe-full", "mediapipe-heavy",
+                                # MoveNet variants  
+                                "movenet-lightning", "movenet-thunder",
+                                # YOLO variants (added X models)
+                                "yolo-v8-n", "yolo-v8-s", "yolo-v8-m", "yolo-v8-l", "yolo-v8-x",
+                                # YOLO v11 variants
+                                "yolo-v11-n", "yolo-v11-s", "yolo-v11-m", "yolo-v11-l", "yolo-v11-x"
+                            ],
+                            value="mediapipe-full",
+                            label="Advanced Pose Models",
+                            info="17+ model variants available"
+                        )
+                        
+                        gr.Markdown("**Analysis Options**")
+                        
+                        with gr.Row():
+                            enable_viz_enh = gr.Checkbox(value=True, label="Visualization")
+                        
+                        with gr.Row():
+                            include_keypoints_enh = gr.Checkbox(value=False, label="Raw Keypoints")
+                        
+                        analyze_btn_enh = gr.Button("🚀 Enhanced Analysis", variant="primary", size="lg")
+                        gr.HTML('</div>')
+                    
+                    with gr.Column(scale=2):
+                        with gr.Tab("📊 Analysis"):
+                            analysis_output_enh = gr.JSON(label="Enhanced Analysis Results")
+                        
+                        with gr.Tab("🎥 Visualization"):
+                            viz_output_enh = gr.Video(label="Annotated Video")
+                
+                def process_enhanced_input(file_input, url_input, model, enable_viz, include_keypoints):
+                    """Process either file upload or URL input."""
+                    video_source = file_input if file_input else url_input
+                    return process_video_enhanced(video_source, model, enable_viz, include_keypoints)
+                
+                analyze_btn_enh.click(
+                    fn=process_enhanced_input,
+                    inputs=[video_input_enh, url_input_enh, model_select_enh, enable_viz_enh, include_keypoints_enh],
+                    outputs=[analysis_output_enh, viz_output_enh],
+                    api_name="analyze_enhanced"
+                )
+            
+            # Tab 3: Agent API
+            with gr.Tab("🤖 Agent API"):
+                gr.Markdown("""
+                ### AI Agent & Automation Features
+                Batch processing, filtering, and structured outputs designed for AI agents and automation.
+                """)
+                
+                with gr.Tabs():
+                    with gr.Tab("Single Analysis"):
+                        with gr.Row():
+                            with gr.Column():
+                                video_input_agent = gr.Video(label="Upload Video", sources=["upload"])
+                                model_select_agent = gr.Dropdown(
+                                    choices=["mediapipe", "movenet", "yolo"],
+                                    value="mediapipe",
+                                    label="Model"
+                                )
+                                output_format_agent = gr.Radio(
+                                    choices=["summary", "structured", "json"],
+                                    value="summary",
+                                    label="Output Format"
+                                )
+                                analyze_btn_agent = gr.Button("Analyze", variant="primary")
+                            
+                            with gr.Column():
+                                output_display_agent = gr.JSON(label="Agent Output")
+                        
+                        analyze_btn_agent.click(
+                            fn=process_video_for_agent,
+                            inputs=[video_input_agent, model_select_agent, output_format_agent],
+                            outputs=output_display_agent,
+                            api_name="analyze_agent"
+                        )
+                    
+                    with gr.Tab("Batch Processing"):
+                        with gr.Row():
+                            with gr.Column():
+                                batch_files = gr.File(
+                                    label="Upload Multiple Videos",
+                                    file_count="multiple",
+                                    file_types=["video"]
+                                )
+                                batch_model = gr.Dropdown(
+                                    choices=["mediapipe", "movenet", "yolo"],
+                                    value="mediapipe",
+                                    label="Model"
+                                )
+                                batch_btn = gr.Button("Process Batch", variant="primary")
+                            
+                            with gr.Column():
+                                batch_output = gr.JSON(label="Batch Results")
+                        
+                        batch_btn.click(
+                            fn=batch_process_videos,
+                            inputs=[batch_files, batch_model],
+                            outputs=batch_output,
+                            api_name="batch_analyze"
+                        )
+                    
+                    with gr.Tab("Movement Filter"):
+                        with gr.Row():
+                            with gr.Column():
+                                filter_files = gr.File(
+                                    label="Videos to Filter",
+                                    file_count="multiple",
+                                    file_types=["video"]
+                                )
+                                
+                                with gr.Group():
+                                    direction_filter = gr.Dropdown(
+                                        choices=["any", "up", "down", "left", "right", "stationary"],
+                                        value="any",
+                                        label="Direction Filter"
+                                    )
+                                    intensity_filter = gr.Dropdown(
+                                        choices=["any", "low", "medium", "high"],
+                                        value="any",
+                                        label="Intensity Filter"
+                                    )
+                                    fluidity_threshold = gr.Slider(0.0, 1.0, 0.0, label="Min Fluidity")
+                                    expansion_threshold = gr.Slider(0.0, 1.0, 0.0, label="Min Expansion")
+                                
+                                filter_btn = gr.Button("Apply Filters", variant="primary")
+                            
+                            with gr.Column():
+                                filter_output = gr.JSON(label="Filtered Results")
+                        
+                        filter_btn.click(
+                            fn=filter_videos_by_movement,
+                            inputs=[filter_files, direction_filter, intensity_filter,
+                                   fluidity_threshold, expansion_threshold],
+                            outputs=filter_output,
+                            api_name="filter_videos"
+                        )
+            
+            # Tab 4: Real-time WebRTC
+            with gr.Tab("📹 Real-time Analysis"):
+                gr.Markdown("""
+                ### Live Camera Movement Analysis
+                Real-time pose detection and movement analysis from your webcam using WebRTC.
+                **Grant camera permissions when prompted for best experience.**
+                """)
+                
+                # Official Gradio WebRTC approach (compatible with NumPy 1.x)
+                if HAS_WEBRTC:
+                    
+                    # Get RTC configuration
+                    rtc_config = get_rtc_configuration()
+                    
+                    # Custom CSS following official guide
+                    css_webrtc = """
+                    .my-group {max-width: 480px !important; max-height: 480px !important;}
+                    .my-column {display: flex !important; justify-content: center !important; align-items: center !important;}
+                    """
+                    
+                    with gr.Column(elem_classes=["my-column"]):
+                        with gr.Group(elem_classes=["my-group"]):
+                            # Official WebRTC Component
+                            webrtc_stream = WebRTC(
+                                label="🎥 Live Camera Stream", 
+                                rtc_configuration=rtc_config
+                            )
+                        
+                            webrtc_model = gr.Dropdown(
+                                choices=["mediapipe-lite", "movenet-lightning", "yolo-v11-n"],
+                                value="mediapipe-lite",
+                                label="Pose Model",
+                                info="Optimized for real-time processing"
+                            )
+                            
+                            confidence_slider = gr.Slider(
+                                label="Detection Confidence",
+                                minimum=0.0,
+                                maximum=1.0,
+                                step=0.05,
+                                value=0.5,
+                                info="Higher = fewer false positives"
+                            )
+                    
+                    # Official WebRTC streaming setup following Gradio guide
+                    webrtc_stream.stream(
+                        fn=webrtc_detection,
+                        inputs=[webrtc_stream, webrtc_model, confidence_slider],
+                        outputs=[webrtc_stream],
+                        time_limit=10  # Following official guide: 10 seconds per user
+                    )
+                    
+                    # Info display
+                    gr.HTML("""
+                    <div style="background: #e8f4fd; padding: 15px; border-radius: 8px; margin-top: 10px;">
+                        <h4>📹 WebRTC Pose Analysis</h4>
+                        <p style="margin: 5px 0;">Real-time movement analysis using your webcam</p>
+                        
+                        <h4>🔒 Privacy</h4>
+                        <p style="margin: 5px 0;">Processing happens locally - no video data stored</p>
+                        
+                        <h4>💡 Usage</h4>
+                        <ul style="margin: 5px 0; padding-left: 20px;">
+                            <li>Grant camera permission when prompted</li>
+                            <li>Move in front of camera to see pose detection</li>
+                            <li>Adjust confidence threshold as needed</li>
+                        </ul>
+                    </div>
+                                         """)
+                    
+                else:
+                    # Fallback if WebRTC component not available  
+                    gr.HTML("""
+                    <div style="text-align: center; padding: 50px; border: 2px dashed #ff6b6b; border-radius: 8px; background: #ffe0e0;">
+                        <h3>📦 WebRTC Component Required</h3>
+                        <p><strong>To enable real-time camera analysis, install:</strong></p>
+                        <code style="background: #f0f0f0; padding: 10px; border-radius: 4px; display: block; margin: 10px 0;">
+                            pip install gradio-webrtc twilio
+                        </code>
+                        <p style="margin-top: 15px;"><em>Use Enhanced Analysis tab for video files meanwhile</em></p>
+                    </div>
+                    """)
+            
+            # Tab 5: Model Comparison
+            with gr.Tab("⚖️ Model Comparison"):
+                gr.Markdown("""
+                ### Compare Pose Estimation Models
+                Analyze the same video with different models to compare accuracy and results.
+                """)
+                
+                with gr.Column():
+                    comparison_video = gr.Video(
+                        label="Video for Comparison",
+                        sources=["upload"]
+                    )
+                    
+                    with gr.Row():
+                        model1_comp = gr.Dropdown(
+                            choices=["mediapipe-full", "movenet-thunder", "yolo-v11-s"],
+                            value="mediapipe-full",
+                            label="Model 1"
+                        )
+                        
+                        model2_comp = gr.Dropdown(
+                            choices=["mediapipe-full", "movenet-thunder", "yolo-v11-s"],
+                            value="yolo-v11-s",
+                            label="Model 2"
+                        )
+                    
+                    compare_btn = gr.Button("🔄 Compare Models", variant="primary")
+                    
+                    comparison_results = gr.DataFrame(
+                        headers=["Metric", "Model 1", "Model 2", "Match"],
+                        label="Comparison Results"
+                    )
+                
+                compare_btn.click(
+                    fn=compare_models,
+                    inputs=[comparison_video, model1_comp, model2_comp],
+                    outputs=comparison_results,
+                    api_name="compare_models"
+                )
+            
+            # Tab 6: Documentation
+            with gr.Tab("📚 Documentation"):
+                gr.Markdown("""
+                # Complete Feature Documentation
+                
+                ## 🎥 Video Input Support
+                - **Local Files**: MP4, AVI, MOV, WebM formats
+                - **YouTube**: Automatic download from YouTube URLs
+                - **Vimeo**: Automatic download from Vimeo URLs
+                - **Direct URLs**: Any direct video file URL
+                
+                ## 🤖 Pose Estimation Models
+                
+                ### MediaPipe (Google) - 33 3D Landmarks
+                - **Lite**: Fastest CPU performance
+                - **Full**: Balanced accuracy/speed (recommended)
+                - **Heavy**: Highest accuracy
+                
+                ### MoveNet (Google) - 17 COCO Keypoints  
+                - **Lightning**: Mobile-optimized, very fast
+                - **Thunder**: Higher accuracy variant
+                
+                ### YOLO (Ultralytics) - 17 COCO Keypoints
+                - **v8 variants**: n/s/m/l/x sizes (nano to extra-large)
+                - **v11 variants**: Latest with improved accuracy (n/s/m/l/x)
+                - **Multi-person**: Supports multiple people in frame
+                
+                ## 📹 Real-time WebRTC
+                
+                - **Live Camera**: Direct webcam access via WebRTC
+                - **Low Latency**: Sub-100ms processing
+                - **Adaptive Quality**: Automatic performance optimization
+                - **Live Overlay**: Real-time pose and metrics display
+                
+                ## 🤖 Agent & MCP Integration
+                
+                ### API Endpoints
+                - `/analyze_standard` - Basic LMA analysis
+                - `/analyze_enhanced` - Advanced analysis with all features
+                - `/analyze_agent` - Agent-optimized output
+                - `/batch_analyze` - Multiple video processing
+                - `/filter_videos` - Movement-based filtering
+                - `/compare_models` - Model comparison
+                
+                ### MCP Server
+                ```bash
+                # Start MCP server for AI assistants
+                python -m backend.mcp_server
+                ```
+                
+                ### Python API
+                ```python
+                from gradio_labanmovementanalysis import LabanMovementAnalysis
+                
+                # Initialize with all features
+                analyzer = LabanMovementAnalysis(
+                    enable_webrtc=True
+                )
+                
+                # Analyze YouTube video
+                result, viz = analyzer.process_video(
+                    "https://youtube.com/watch?v=...",
+                    model="yolo-v11-s"
+                )
+                ```
+                
+                ## 📊 Output Formats
+                
+                ### Summary Format
+                Human-readable movement analysis summary.
+                
+                ### Structured Format  
+                ```json
+                {
+                    "success": true,
+                    "direction": "up", 
+                    "intensity": "medium",
+                    "fluidity": 0.85,
+                    "expansion": 0.72
+                }
+                ```
+                
+                ### Full JSON Format
+                Complete frame-by-frame analysis with all metrics.
+                
+                ## 🎯 Applications
+                
+                - **Sports**: Technique analysis and performance tracking
+                - **Dance**: Choreography analysis and movement quality
+                - **Healthcare**: Physical therapy and rehabilitation
+                - **Research**: Large-scale movement pattern studies
+                - **Entertainment**: Interactive applications and games
+                - **Education**: Movement teaching and body awareness
+                
+                ## 🔗 Integration Examples
+                
+                ### Gradio Client
+                ```python
+                from gradio_client import Client
+                
+                client = Client("http://localhost:7860")
+                result = client.predict(
+                    video="path/to/video.mp4",
+                    model="mediapipe-full",
+                    api_name="/analyze_enhanced"
+                )
+                ```
+                
+                ### Batch Processing
+                ```python
+                results = client.predict(
+                    files=["video1.mp4", "video2.mp4"],
+                    model="yolo-v11-s", 
+                    api_name="/batch_analyze"
+                )
+                ```
+                """)
+                gr.HTML("""
+                        <div class="author-info">
+                            <p><strong>Created by:</strong> Csaba Bolyós (BladeSzaSza)</p>
+                            <p style="margin: 5px 0;">
+                                <a href="https://github.com/bladeszasza" style="color: #a8e6cf; text-decoration: none;">🔗 GitHub</a> • 
+                                <a href="https://huggingface.co/BladeSzaSza" style="color: #a8e6cf; text-decoration: none;">🤗 Hugging Face</a> • 
+                                <a href="https://www.linkedin.com/in/csaba-bolyós-00a11767/" style="color: #a8e6cf; text-decoration: none;">💼 LinkedIn</a>
+                            </p>
+                            <p style="font-size: 12px; opacity: 0.9;">Contact: [email protected]</p>
+                        </div>
+                        """)
+                        
+                        # Footer with proper attribution
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; margin-top: 30px; border-top: 1px solid #eee;">
+            <p style="color: #666; margin-bottom: 10px;">
+                🎭 Laban Movement Analysis - Complete Suite | Heavy Beta Version
+            </p>
+            <p style="color: #666; font-size: 12px;">
+                Created by <strong>Csaba Bolyós</strong> | Powered by MediaPipe, MoveNet & YOLO
+            </p>
+            <p style="color: #666; font-size: 10px; margin-top: 10px;">
+                <a href="https://github.com/bladeszasza" style="color: #40826D;">GitHub</a> • 
+                <a href="https://huggingface.co/BladeSzaSza" style="color: #40826D;">Hugging Face</a> • 
+                <a href="https://www.linkedin.com/in/csaba-bolyós-00a11767/" style="color: #40826D;">LinkedIn</a>
+            </p>
+        </div>
+        """)
+    
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_unified_demo()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        favicon_path=None
+    )

demo/css.css

@@ -0,0 +1,157 @@
+html {
+	font-family: Inter;
+	font-size: 16px;
+	font-weight: 400;
+	line-height: 1.5;
+	-webkit-text-size-adjust: 100%;
+	background: #fff;
+	color: #323232;
+	-webkit-font-smoothing: antialiased;
+	-moz-osx-font-smoothing: grayscale;
+	text-rendering: optimizeLegibility;
+}
+
+:root {
+	--space: 1;
+	--vspace: calc(var(--space) * 1rem);
+	--vspace-0: calc(3 * var(--space) * 1rem);
+	--vspace-1: calc(2 * var(--space) * 1rem);
+	--vspace-2: calc(1.5 * var(--space) * 1rem);
+	--vspace-3: calc(0.5 * var(--space) * 1rem);
+}
+
+.app {
+	max-width: 748px !important;
+}
+
+.prose p {
+	margin: var(--vspace) 0;
+	line-height: var(--vspace * 2);
+	font-size: 1rem;
+}
+
+code {
+	font-family: "Inconsolata", sans-serif;
+	font-size: 16px;
+}
+
+h1,
+h1 code {
+	font-weight: 400;
+	line-height: calc(2.5 / var(--space) * var(--vspace));
+}
+
+h1 code {
+	background: none;
+	border: none;
+	letter-spacing: 0.05em;
+	padding-bottom: 5px;
+	position: relative;
+	padding: 0;
+}
+
+h2 {
+	margin: var(--vspace-1) 0 var(--vspace-2) 0;
+	line-height: 1em;
+}
+
+h3,
+h3 code {
+	margin: var(--vspace-1) 0 var(--vspace-2) 0;
+	line-height: 1em;
+}
+
+h4,
+h5,
+h6 {
+	margin: var(--vspace-3) 0 var(--vspace-3) 0;
+	line-height: var(--vspace);
+}
+
+.bigtitle,
+h1,
+h1 code {
+	font-size: calc(8px * 4.5);
+	word-break: break-word;
+}
+
+.title,
+h2,
+h2 code {
+	font-size: calc(8px * 3.375);
+	font-weight: lighter;
+	word-break: break-word;
+	border: none;
+	background: none;
+}
+
+.subheading1,
+h3,
+h3 code {
+	font-size: calc(8px * 1.8);
+	font-weight: 600;
+	border: none;
+	background: none;
+	letter-spacing: 0.1em;
+	text-transform: uppercase;
+}
+
+h2 code {
+	padding: 0;
+	position: relative;
+	letter-spacing: 0.05em;
+}
+
+blockquote {
+	font-size: calc(8px * 1.1667);
+	font-style: italic;
+	line-height: calc(1.1667 * var(--vspace));
+	margin: var(--vspace-2) var(--vspace-2);
+}
+
+.subheading2,
+h4 {
+	font-size: calc(8px * 1.4292);
+	text-transform: uppercase;
+	font-weight: 600;
+}
+
+.subheading3,
+h5 {
+	font-size: calc(8px * 1.2917);
+	line-height: calc(1.2917 * var(--vspace));
+
+	font-weight: lighter;
+	text-transform: uppercase;
+	letter-spacing: 0.15em;
+}
+
+h6 {
+	font-size: calc(8px * 1.1667);
+	font-size: 1.1667em;
+	font-weight: normal;
+	font-style: italic;
+	font-family: "le-monde-livre-classic-byol", serif !important;
+	letter-spacing: 0px !important;
+}
+
+#start .md > *:first-child {
+	margin-top: 0;
+}
+
+h2 + h3 {
+	margin-top: 0;
+}
+
+.md hr {
+	border: none;
+	border-top: 1px solid var(--block-border-color);
+	margin: var(--vspace-2) 0 var(--vspace-2) 0;
+}
+.prose ul {
+	margin: var(--vspace-2) 0 var(--vspace-1) 0;
+}
+
+.gap {
+	gap: 0;
+}

demo/requirements.txt

@@ -0,0 +1 @@
+gradio_labanmovementanalysis

demo/space.py

@@ -0,0 +1,983 @@
+
+import gradio as gr
+from app import demo as app
+import os
+
+_docs = {'LabanMovementAnalysis': {'description': 'Gradio component for video-based pose analysis with Laban Movement Analysis metrics.', 'members': {'__init__': {'default_model': {'type': 'str', 'default': '"mediapipe"', 'description': 'Default pose estimation model ("mediapipe", "movenet", "yolo")'}, 'enable_visualization': {'type': 'bool', 'default': 'True', 'description': 'Whether to generate visualization video by default'}, 'include_keypoints': {'type': 'bool', 'default': 'False', 'description': 'Whether to include raw keypoints in JSON output'}, 'enable_webrtc': {'type': 'bool', 'default': 'False', 'description': 'Whether to enable WebRTC real-time analysis'}, 'label': {'type': 'typing.Optional[str][str, None]', 'default': 'None', 'description': 'Component label'}, 'every': {'type': 'typing.Optional[float][float, None]', 'default': 'None', 'description': None}, 'show_label': {'type': 'typing.Optional[bool][bool, None]', 'default': 'None', 'description': None}, 'container': {'type': 'bool', 'default': 'True', 'description': None}, 'scale': {'type': 'typing.Optional[int][int, None]', 'default': 'None', 'description': None}, 'min_width': {'type': 'int', 'default': '160', 'description': None}, 'interactive': {'type': 'typing.Optional[bool][bool, None]', 'default': 'None', 'description': None}, 'visible': {'type': 'bool', 'default': 'True', 'description': None}, 'elem_id': {'type': 'typing.Optional[str][str, None]', 'default': 'None', 'description': None}, 'elem_classes': {'type': 'typing.Optional[typing.List[str]][\n    typing.List[str][str], None\n]', 'default': 'None', 'description': None}, 'render': {'type': 'bool', 'default': 'True', 'description': None}}, 'postprocess': {'value': {'type': 'typing.Any', 'description': 'Analysis results'}}, 'preprocess': {'return': {'type': 'typing.Dict[str, typing.Any][str, typing.Any]', 'description': 'Processed data for analysis'}, 'value': None}}, 'events': {}}, '__meta__': {'additional_interfaces': {}, 'user_fn_refs': {'LabanMovementAnalysis': []}}}
+
+abs_path = os.path.join(os.path.dirname(__file__), "css.css")
+
+with gr.Blocks(
+    css=abs_path,
+    theme=gr.themes.Default(
+        font_mono=[
+            gr.themes.GoogleFont("Inconsolata"),
+            "monospace",
+        ],
+    ),
+) as demo:
+    gr.Markdown(
+"""
+# `gradio_labanmovementanalysis`
+
+<div style="display: flex; gap: 7px;">
+<a href="https://pypi.org/project/gradio_labanmovementanalysis/" target="_blank"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/gradio_labanmovementanalysis"></a>  
+</div>
+
+A Gradio 5 component for video movement analysis using Laban Movement Analysis (LMA) with MCP support for AI agents
+""", elem_classes=["md-custom"], header_links=True)
+    app.render()
+    gr.Markdown(
+"""
+## Installation
+
+```bash
+pip install gradio_labanmovementanalysis
+```
+
+## Usage
+
+```python
+\"\"\"
+Unified Laban Movement Analysis Demo
+Comprehensive interface combining all features: 
+- Standard LMA analysis
+- Enhanced features (WebRTC, YouTube/Vimeo)
+- Agent API (batch processing, filtering)
+- Real-time analysis
+- Model comparison
+
+Created by: Csaba Bolyós (BladeSzaSza)
+Contact: [email protected]
+GitHub: https://github.com/bladeszasza
+LinkedIn: https://www.linkedin.com/in/csaba-bolyós-00a11767/
+Hugging Face: https://huggingface.co/BladeSzaSza
+
+Heavy Beta Version - Under Active Development
+\"\"\"
+
+import gradio as gr
+import sys
+from pathlib import Path
+from typing import Dict, Any, List, Tuple
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent / "backend"))
+
+from gradio_labanmovementanalysis import LabanMovementAnalysis
+
+# Import agent API if available
+try:
+    from gradio_labanmovementanalysis.agent_api import (
+        LabanAgentAPI,
+        PoseModel,
+        MovementDirection,
+        MovementIntensity
+    )
+    HAS_AGENT_API = True
+except ImportError:
+    HAS_AGENT_API = False
+
+# Import WebRTC components if available
+try:
+    from gradio_webrtc import WebRTC
+    from gradio_labanmovementanalysis.webrtc_handler import (
+        webrtc_detection,
+        get_rtc_configuration
+    )
+    HAS_WEBRTC = True
+except ImportError as e:
+    print(f"WebRTC import failed: {e}")
+    HAS_WEBRTC = False
+
+# Initialize components
+try:
+    # Initialize with WebRTC support
+    analyzer = LabanMovementAnalysis(
+        enable_webrtc=True,
+        enable_visualization=True
+    )
+    print("✅ Core features initialized successfully")
+except Exception as e:
+    print(f"Warning: Some features may not be available: {e}")
+    analyzer = LabanMovementAnalysis(enable_webrtc=False)
+
+# Initialize agent API if available
+agent_api = None
+if HAS_AGENT_API:
+    try:
+        agent_api = LabanAgentAPI()
+    except Exception as e:
+        print(f"Warning: Agent API not available: {e}")
+        agent_api = None
+
+
+def process_video_standard(video, model, enable_viz, include_keypoints):
+    \"\"\"Standard video processing function.\"\"\"
+    if video is None:
+        return None, None
+    
+    try:
+        json_output, video_output = analyzer.process_video(
+            video,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_output, video_output
+    except Exception as e:
+        return {"error": str(e)}, None
+
+
+def process_video_enhanced(video_input, model, enable_viz, include_keypoints):
+    \"\"\"Enhanced video processing with all new features.\"\"\"
+    if not video_input:
+        return {"error": "No video provided"}, None
+    
+    try:
+        # Handle both file upload and URL input
+        video_path = video_input.name if hasattr(video_input, 'name') else video_input
+        
+        json_result, viz_result = analyzer.process_video(
+            video_path,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_result, viz_result
+    except Exception as e:
+        error_result = {"error": str(e)}
+        return error_result, None
+
+
+def process_video_for_agent(video, model, output_format="summary"):
+    \"\"\"Process video with agent-friendly output format.\"\"\"
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not video:
+        return {"error": "No video provided"}
+    
+    try:
+        model_enum = PoseModel(model)
+        result = agent_api.analyze(video, model=model_enum, generate_visualization=False)
+        
+        if output_format == "summary":
+            return {"summary": agent_api.get_movement_summary(result)}
+        elif output_format == "structured":
+            return {
+                "success": result.success,
+                "direction": result.dominant_direction.value,
+                "intensity": result.dominant_intensity.value,
+                "speed": result.dominant_speed,
+                "fluidity": result.fluidity_score,
+                "expansion": result.expansion_score,
+                "segments": len(result.movement_segments)
+            }
+        else:  # json
+            return result.raw_data
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def batch_process_videos(files, model):
+    \"\"\"Process multiple videos in batch.\"\"\"
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not files:
+        return {"error": "No videos provided"}
+    
+    try:
+        video_paths = [f.name for f in files]
+        results = agent_api.batch_analyze(video_paths, model=PoseModel(model), parallel=True)
+        
+        output = {
+            "total_videos": len(results),
+            "successful": sum(1 for r in results if r.success),
+            "failed": sum(1 for r in results if not r.success),
+            "results": []
+        }
+        
+        for result in results:
+            output["results"].append({
+                "video": Path(result.video_path).name,
+                "success": result.success,
+                "summary": agent_api.get_movement_summary(result) if result.success else result.error
+            })
+        
+        return output
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def filter_videos_by_movement(files, direction, intensity, min_fluidity, min_expansion):
+    \"\"\"Filter videos based on movement characteristics.\"\"\"
+    if not HAS_AGENT_API or agent_api is None:
+        return {"error": "Agent API not available"}
+    
+    if not files:
+        return {"error": "No videos provided"}
+    
+    try:
+        video_paths = [f.name for f in files]
+        
+        dir_filter = MovementDirection(direction) if direction != "any" else None
+        int_filter = MovementIntensity(intensity) if intensity != "any" else None
+        
+        filtered = agent_api.filter_by_movement(
+            video_paths,
+            direction=dir_filter,
+            intensity=int_filter,
+            min_fluidity=min_fluidity if min_fluidity > 0 else None,
+            min_expansion=min_expansion if min_expansion > 0 else None
+        )
+        
+        return {
+            "total_analyzed": len(video_paths),
+            "matching_videos": len(filtered),
+            "matches": [
+                {
+                    "video": Path(r.video_path).name,
+                    "direction": r.dominant_direction.value,
+                    "intensity": r.dominant_intensity.value,
+                    "fluidity": r.fluidity_score,
+                    "expansion": r.expansion_score
+                }
+                for r in filtered
+            ]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def compare_models(video, model1, model2):
+    \"\"\"Compare two different pose models on the same video.\"\"\"
+    if not video:
+        return "No video provided"
+    
+    try:
+        # Analyze with both models
+        result1, _ = analyzer.process_video(video, model=model1, enable_visualization=False)
+        result2, _ = analyzer.process_video(video, model=model2, enable_visualization=False)
+        
+        # Extract key metrics for comparison
+        def extract_metrics(result):
+            summary = result.get("movement_analysis", {}).get("summary", {})
+            return {
+                "direction": summary.get("direction", {}).get("dominant", "unknown"),
+                "intensity": summary.get("intensity", {}).get("dominant", "unknown"), 
+                "speed": summary.get("speed", {}).get("dominant", "unknown"),
+                "frame_count": result.get("video_info", {}).get("frame_count", 0)
+            }
+        
+        metrics1 = extract_metrics(result1)
+        metrics2 = extract_metrics(result2)
+        
+        # Create comparison table data
+        comparison_data = [
+            ["Direction", metrics1["direction"], metrics2["direction"], 
+             "✓" if metrics1["direction"] == metrics2["direction"] else "✗"],
+            ["Intensity", metrics1["intensity"], metrics2["intensity"],
+             "✓" if metrics1["intensity"] == metrics2["intensity"] else "✗"],
+            ["Speed", metrics1["speed"], metrics2["speed"],
+             "✓" if metrics1["speed"] == metrics2["speed"] else "✗"],
+            ["Frames Processed", str(metrics1["frame_count"]), str(metrics2["frame_count"]),
+             "✓" if metrics1["frame_count"] == metrics2["frame_count"] else "✗"]
+        ]
+        
+        return comparison_data
+        
+    except Exception as e:
+        return [["Error", str(e), "", ""]]
+
+
+def start_webrtc_stream(model):
+    \"\"\"Start WebRTC real-time analysis.\"\"\"
+    try:
+        success = analyzer.start_webrtc_stream(model)
+        if success:
+            return "🟢 Stream Active", {"status": "streaming", "model": model}
+        else:
+            return "🔴 Failed to start", {"status": "error"}
+    except Exception as e:
+        return f"🔴 Error: {str(e)}", {"status": "error"}
+
+
+def stop_webrtc_stream():
+    \"\"\"Stop WebRTC real-time analysis.\"\"\"
+    try:
+        success = analyzer.stop_webrtc_stream()
+        if success:
+            return "🟡 Stream Stopped", {"status": "stopped"}
+        else:
+            return "🔴 Failed to stop", {"status": "error"}
+    except Exception as e:
+        return f"🔴 Error: {str(e)}", {"status": "error"}
+
+
+def create_unified_demo():
+    \"\"\"Create the unified comprehensive demo.\"\"\"
+    
+    with gr.Blocks(
+        title="Laban Movement Analysis - Complete Suite by Csaba Bolyós",
+        theme=gr.themes.Soft(),
+        css=\"\"\"
+        .main-header {
+            background: linear-gradient(135deg, #40826D 0%, #2E5E4A 50%, #1B3A2F 100%);
+            color: white;
+            padding: 30px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+            text-align: center;
+        }
+        .feature-card {
+            border: 1px solid #e1e5e9;
+            border-radius: 8px;
+            padding: 16px;
+            margin: 8px 0;
+            background: #f8f9fa;
+        }
+        .json-output {
+            max-height: 600px;
+            overflow-y: auto;
+            font-family: monospace;
+            font-size: 12px;
+        }
+        .author-info {
+            background: linear-gradient(135deg, #40826D 0%, #2E5E4A 100%);
+            color: white;
+            padding: 15px;
+            border-radius: 8px;
+            margin: 10px 0;
+            text-align: center;
+        }
+        \"\"\"
+    ) as demo:
+        
+        # Main Header
+        gr.HTML(\"\"\"
+        <div class="main-header">
+            <h1>🎭 Laban Movement Analysis - Complete Suite</h1>
+            <p style="font-size: 18px; margin: 10px 0;">
+                Professional movement analysis with pose estimation, AI action recognition, 
+                real-time processing, and agent automation
+            </p>
+            <p style="font-size: 14px; opacity: 0.9;">
+                Supports YouTube/Vimeo URLs • WebRTC Streaming • 20+ Pose Models • MCP Integration
+            </p>
+            <p style="font-size: 12px; margin-top: 15px; opacity: 0.8;">
+                <strong>Version 0.01-beta</strong> - Heavy Beta Under Active Development
+            </p>
+        </div>
+        \"\"\")
+     
+        with gr.Tabs():
+            # Tab 1: Standard Analysis
+            with gr.Tab("🎬 Standard Analysis"):
+                gr.Markdown(\"\"\"
+                ### Classic Laban Movement Analysis
+                Upload a video file to analyze movement using traditional LMA metrics with pose estimation.
+                \"\"\")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        video_input_std = gr.Video(
+                            label="Upload Video",
+                            sources=["upload"],
+                            format="mp4"
+                        )
+                        
+                        model_dropdown_std = gr.Dropdown(
+                            choices=["mediapipe", "movenet", "yolo"],
+                            value="mediapipe",
+                            label="Pose Estimation Model"
+                        )
+                        
+                        with gr.Row():
+                            enable_viz_std = gr.Checkbox(
+                                value=True,
+                                label="Generate Visualization"
+                            )
+                            
+                            include_keypoints_std = gr.Checkbox(
+                                value=False,
+                                label="Include Keypoints"
+                            )
+                        
+                        process_btn_std = gr.Button("Analyze Movement", variant="primary")
+                        
+                        gr.Examples(
+                            examples=[
+                                ["examples/balette.mp4"],
+                            ],
+                            inputs=video_input_std,
+                            label="Example Videos"
+                        )
+                    
+                    with gr.Column(scale=2):
+                        with gr.Tab("Analysis Results"):
+                            json_output_std = gr.JSON(
+                                label="Movement Analysis (JSON)",
+                                elem_classes=["json-output"]
+                            )
+                        
+                        with gr.Tab("Visualization"):
+                            video_output_std = gr.Video(
+                                label="Annotated Video",
+                                format="mp4"
+                            )
+                            
+                            gr.Markdown(\"\"\"
+                            **Visualization Guide:**
+                            - 🦴 **Skeleton**: Pose keypoints and connections
+                            - 🌊 **Trails**: Motion history (fading lines)
+                            - ➡️ **Arrows**: Movement direction indicators
+                            - 🎨 **Colors**: Green (low) → Orange (medium) → Red (high) intensity
+                            \"\"\")
+                
+                process_btn_std.click(
+                    fn=process_video_standard,
+                    inputs=[video_input_std, model_dropdown_std, enable_viz_std, include_keypoints_std],
+                    outputs=[json_output_std, video_output_std],
+                    api_name="analyze_standard"
+                )
+            
+            # Tab 2: Enhanced Analysis
+            with gr.Tab("🚀 Enhanced Analysis"):
+                gr.Markdown(\"\"\"
+                ### Advanced Analysis with AI and URL Support
+                Analyze videos from URLs (YouTube/Vimeo), use advanced pose models, and get AI-powered insights.
+                \"\"\")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.HTML('<div class="feature-card">')
+                        gr.Markdown("**Video Input**")
+                        
+                        # Changed from textbox to file upload as requested
+                        video_input_enh = gr.File(
+                            label="Upload Video or Drop File",
+                            file_types=["video"],
+                            type="filepath"
+                        )
+                        
+                        # URL input option
+                        url_input_enh = gr.Textbox(
+                            label="Or Enter Video URL",
+                            placeholder="YouTube URL, Vimeo URL, or direct video URL",
+                            info="Leave file upload empty to use URL"
+                        )
+                        
+                        gr.Examples(
+                            examples=[
+                                ["examples/balette.mp4"],
+                                ["https://www.youtube.com/shorts/RX9kH2l3L8U"],
+                                ["https://vimeo.com/815392738"]
+                            ],
+                            inputs=url_input_enh,
+                            label="Example URLs"
+                        )
+                        
+                        gr.Markdown("**Model Selection**")
+                        
+                        model_select_enh = gr.Dropdown(
+                            choices=[
+                                # MediaPipe variants
+                                "mediapipe-lite", "mediapipe-full", "mediapipe-heavy",
+                                # MoveNet variants  
+                                "movenet-lightning", "movenet-thunder",
+                                # YOLO variants (added X models)
+                                "yolo-v8-n", "yolo-v8-s", "yolo-v8-m", "yolo-v8-l", "yolo-v8-x",
+                                # YOLO v11 variants
+                                "yolo-v11-n", "yolo-v11-s", "yolo-v11-m", "yolo-v11-l", "yolo-v11-x"
+                            ],
+                            value="mediapipe-full",
+                            label="Advanced Pose Models",
+                            info="17+ model variants available"
+                        )
+                        
+                        gr.Markdown("**Analysis Options**")
+                        
+                        with gr.Row():
+                            enable_viz_enh = gr.Checkbox(value=True, label="Visualization")
+                        
+                        with gr.Row():
+                            include_keypoints_enh = gr.Checkbox(value=False, label="Raw Keypoints")
+                        
+                        analyze_btn_enh = gr.Button("🚀 Enhanced Analysis", variant="primary", size="lg")
+                        gr.HTML('</div>')
+                    
+                    with gr.Column(scale=2):
+                        with gr.Tab("📊 Analysis"):
+                            analysis_output_enh = gr.JSON(label="Enhanced Analysis Results")
+                        
+                        with gr.Tab("🎥 Visualization"):
+                            viz_output_enh = gr.Video(label="Annotated Video")
+                
+                def process_enhanced_input(file_input, url_input, model, enable_viz, include_keypoints):
+                    \"\"\"Process either file upload or URL input.\"\"\"
+                    video_source = file_input if file_input else url_input
+                    return process_video_enhanced(video_source, model, enable_viz, include_keypoints)
+                
+                analyze_btn_enh.click(
+                    fn=process_enhanced_input,
+                    inputs=[video_input_enh, url_input_enh, model_select_enh, enable_viz_enh, include_keypoints_enh],
+                    outputs=[analysis_output_enh, viz_output_enh],
+                    api_name="analyze_enhanced"
+                )
+            
+            # Tab 3: Agent API
+            with gr.Tab("🤖 Agent API"):
+                gr.Markdown(\"\"\"
+                ### AI Agent & Automation Features
+                Batch processing, filtering, and structured outputs designed for AI agents and automation.
+                \"\"\")
+                
+                with gr.Tabs():
+                    with gr.Tab("Single Analysis"):
+                        with gr.Row():
+                            with gr.Column():
+                                video_input_agent = gr.Video(label="Upload Video", sources=["upload"])
+                                model_select_agent = gr.Dropdown(
+                                    choices=["mediapipe", "movenet", "yolo"],
+                                    value="mediapipe",
+                                    label="Model"
+                                )
+                                output_format_agent = gr.Radio(
+                                    choices=["summary", "structured", "json"],
+                                    value="summary",
+                                    label="Output Format"
+                                )
+                                analyze_btn_agent = gr.Button("Analyze", variant="primary")
+                            
+                            with gr.Column():
+                                output_display_agent = gr.JSON(label="Agent Output")
+                        
+                        analyze_btn_agent.click(
+                            fn=process_video_for_agent,
+                            inputs=[video_input_agent, model_select_agent, output_format_agent],
+                            outputs=output_display_agent,
+                            api_name="analyze_agent"
+                        )
+                    
+                    with gr.Tab("Batch Processing"):
+                        with gr.Row():
+                            with gr.Column():
+                                batch_files = gr.File(
+                                    label="Upload Multiple Videos",
+                                    file_count="multiple",
+                                    file_types=["video"]
+                                )
+                                batch_model = gr.Dropdown(
+                                    choices=["mediapipe", "movenet", "yolo"],
+                                    value="mediapipe",
+                                    label="Model"
+                                )
+                                batch_btn = gr.Button("Process Batch", variant="primary")
+                            
+                            with gr.Column():
+                                batch_output = gr.JSON(label="Batch Results")
+                        
+                        batch_btn.click(
+                            fn=batch_process_videos,
+                            inputs=[batch_files, batch_model],
+                            outputs=batch_output,
+                            api_name="batch_analyze"
+                        )
+                    
+                    with gr.Tab("Movement Filter"):
+                        with gr.Row():
+                            with gr.Column():
+                                filter_files = gr.File(
+                                    label="Videos to Filter",
+                                    file_count="multiple",
+                                    file_types=["video"]
+                                )
+                                
+                                with gr.Group():
+                                    direction_filter = gr.Dropdown(
+                                        choices=["any", "up", "down", "left", "right", "stationary"],
+                                        value="any",
+                                        label="Direction Filter"
+                                    )
+                                    intensity_filter = gr.Dropdown(
+                                        choices=["any", "low", "medium", "high"],
+                                        value="any",
+                                        label="Intensity Filter"
+                                    )
+                                    fluidity_threshold = gr.Slider(0.0, 1.0, 0.0, label="Min Fluidity")
+                                    expansion_threshold = gr.Slider(0.0, 1.0, 0.0, label="Min Expansion")
+                                
+                                filter_btn = gr.Button("Apply Filters", variant="primary")
+                            
+                            with gr.Column():
+                                filter_output = gr.JSON(label="Filtered Results")
+                        
+                        filter_btn.click(
+                            fn=filter_videos_by_movement,
+                            inputs=[filter_files, direction_filter, intensity_filter,
+                                   fluidity_threshold, expansion_threshold],
+                            outputs=filter_output,
+                            api_name="filter_videos"
+                        )
+            
+            # Tab 4: Real-time WebRTC
+            with gr.Tab("📹 Real-time Analysis"):
+                gr.Markdown(\"\"\"
+                ### Live Camera Movement Analysis
+                Real-time pose detection and movement analysis from your webcam using WebRTC.
+                **Grant camera permissions when prompted for best experience.**
+                \"\"\")
+                
+                # Official Gradio WebRTC approach (compatible with NumPy 1.x)
+                if HAS_WEBRTC:
+                    
+                    # Get RTC configuration
+                    rtc_config = get_rtc_configuration()
+                    
+                    # Custom CSS following official guide
+                    css_webrtc = \"\"\"
+                    .my-group {max-width: 480px !important; max-height: 480px !important;}
+                    .my-column {display: flex !important; justify-content: center !important; align-items: center !important;}
+                    \"\"\"
+                    
+                    with gr.Column(elem_classes=["my-column"]):
+                        with gr.Group(elem_classes=["my-group"]):
+                            # Official WebRTC Component
+                            webrtc_stream = WebRTC(
+                                label="🎥 Live Camera Stream", 
+                                rtc_configuration=rtc_config
+                            )
+                        
+                            webrtc_model = gr.Dropdown(
+                                choices=["mediapipe-lite", "movenet-lightning", "yolo-v11-n"],
+                                value="mediapipe-lite",
+                                label="Pose Model",
+                                info="Optimized for real-time processing"
+                            )
+                            
+                            confidence_slider = gr.Slider(
+                                label="Detection Confidence",
+                                minimum=0.0,
+                                maximum=1.0,
+                                step=0.05,
+                                value=0.5,
+                                info="Higher = fewer false positives"
+                            )
+                    
+                    # Official WebRTC streaming setup following Gradio guide
+                    webrtc_stream.stream(
+                        fn=webrtc_detection,
+                        inputs=[webrtc_stream, webrtc_model, confidence_slider],
+                        outputs=[webrtc_stream],
+                        time_limit=10  # Following official guide: 10 seconds per user
+                    )
+                    
+                    # Info display
+                    gr.HTML(\"\"\"
+                    <div style="background: #e8f4fd; padding: 15px; border-radius: 8px; margin-top: 10px;">
+                        <h4>📹 WebRTC Pose Analysis</h4>
+                        <p style="margin: 5px 0;">Real-time movement analysis using your webcam</p>
+                        
+                        <h4>🔒 Privacy</h4>
+                        <p style="margin: 5px 0;">Processing happens locally - no video data stored</p>
+                        
+                        <h4>💡 Usage</h4>
+                        <ul style="margin: 5px 0; padding-left: 20px;">
+                            <li>Grant camera permission when prompted</li>
+                            <li>Move in front of camera to see pose detection</li>
+                            <li>Adjust confidence threshold as needed</li>
+                        </ul>
+                    </div>
+                                         \"\"\")
+                    
+                else:
+                    # Fallback if WebRTC component not available  
+                    gr.HTML(\"\"\"
+                    <div style="text-align: center; padding: 50px; border: 2px dashed #ff6b6b; border-radius: 8px; background: #ffe0e0;">
+                        <h3>📦 WebRTC Component Required</h3>
+                        <p><strong>To enable real-time camera analysis, install:</strong></p>
+                        <code style="background: #f0f0f0; padding: 10px; border-radius: 4px; display: block; margin: 10px 0;">
+                            pip install gradio-webrtc twilio
+                        </code>
+                        <p style="margin-top: 15px;"><em>Use Enhanced Analysis tab for video files meanwhile</em></p>
+                    </div>
+                    \"\"\")
+            
+            # Tab 5: Model Comparison
+            with gr.Tab("⚖️ Model Comparison"):
+                gr.Markdown(\"\"\"
+                ### Compare Pose Estimation Models
+                Analyze the same video with different models to compare accuracy and results.
+                \"\"\")
+                
+                with gr.Column():
+                    comparison_video = gr.Video(
+                        label="Video for Comparison",
+                        sources=["upload"]
+                    )
+                    
+                    with gr.Row():
+                        model1_comp = gr.Dropdown(
+                            choices=["mediapipe-full", "movenet-thunder", "yolo-v11-s"],
+                            value="mediapipe-full",
+                            label="Model 1"
+                        )
+                        
+                        model2_comp = gr.Dropdown(
+                            choices=["mediapipe-full", "movenet-thunder", "yolo-v11-s"],
+                            value="yolo-v11-s",
+                            label="Model 2"
+                        )
+                    
+                    compare_btn = gr.Button("🔄 Compare Models", variant="primary")
+                    
+                    comparison_results = gr.DataFrame(
+                        headers=["Metric", "Model 1", "Model 2", "Match"],
+                        label="Comparison Results"
+                    )
+                
+                compare_btn.click(
+                    fn=compare_models,
+                    inputs=[comparison_video, model1_comp, model2_comp],
+                    outputs=comparison_results,
+                    api_name="compare_models"
+                )
+            
+            # Tab 6: Documentation
+            with gr.Tab("📚 Documentation"):
+                gr.Markdown(\"\"\"
+                # Complete Feature Documentation
+                
+                ## 🎥 Video Input Support
+                - **Local Files**: MP4, AVI, MOV, WebM formats
+                - **YouTube**: Automatic download from YouTube URLs
+                - **Vimeo**: Automatic download from Vimeo URLs
+                - **Direct URLs**: Any direct video file URL
+                
+                ## 🤖 Pose Estimation Models
+                
+                ### MediaPipe (Google) - 33 3D Landmarks
+                - **Lite**: Fastest CPU performance
+                - **Full**: Balanced accuracy/speed (recommended)
+                - **Heavy**: Highest accuracy
+                
+                ### MoveNet (Google) - 17 COCO Keypoints  
+                - **Lightning**: Mobile-optimized, very fast
+                - **Thunder**: Higher accuracy variant
+                
+                ### YOLO (Ultralytics) - 17 COCO Keypoints
+                - **v8 variants**: n/s/m/l/x sizes (nano to extra-large)
+                - **v11 variants**: Latest with improved accuracy (n/s/m/l/x)
+                - **Multi-person**: Supports multiple people in frame
+                
+                ## 📹 Real-time WebRTC
+                
+                - **Live Camera**: Direct webcam access via WebRTC
+                - **Low Latency**: Sub-100ms processing
+                - **Adaptive Quality**: Automatic performance optimization
+                - **Live Overlay**: Real-time pose and metrics display
+                
+                ## 🤖 Agent & MCP Integration
+                
+                ### API Endpoints
+                - `/analyze_standard` - Basic LMA analysis
+                - `/analyze_enhanced` - Advanced analysis with all features
+                - `/analyze_agent` - Agent-optimized output
+                - `/batch_analyze` - Multiple video processing
+                - `/filter_videos` - Movement-based filtering
+                - `/compare_models` - Model comparison
+                
+                ### MCP Server
+                ```bash
+                # Start MCP server for AI assistants
+                python -m backend.mcp_server
+                ```
+                
+                ### Python API
+                ```python
+                from gradio_labanmovementanalysis import LabanMovementAnalysis
+                
+                # Initialize with all features
+                analyzer = LabanMovementAnalysis(
+                    enable_webrtc=True
+                )
+                
+                # Analyze YouTube video
+                result, viz = analyzer.process_video(
+                    "https://youtube.com/watch?v=...",
+                    model="yolo-v11-s"
+                )
+                ```
+                
+                ## 📊 Output Formats
+                
+                ### Summary Format
+                Human-readable movement analysis summary.
+                
+                ### Structured Format  
+                ```json
+                {
+                    "success": true,
+                    "direction": "up", 
+                    "intensity": "medium",
+                    "fluidity": 0.85,
+                    "expansion": 0.72
+                }
+                ```
+                
+                ### Full JSON Format
+                Complete frame-by-frame analysis with all metrics.
+                
+                ## 🎯 Applications
+                
+                - **Sports**: Technique analysis and performance tracking
+                - **Dance**: Choreography analysis and movement quality
+                - **Healthcare**: Physical therapy and rehabilitation
+                - **Research**: Large-scale movement pattern studies
+                - **Entertainment**: Interactive applications and games
+                - **Education**: Movement teaching and body awareness
+                
+                ## 🔗 Integration Examples
+                
+                ### Gradio Client
+                ```python
+                from gradio_client import Client
+                
+                client = Client("http://localhost:7860")
+                result = client.predict(
+                    video="path/to/video.mp4",
+                    model="mediapipe-full",
+                    api_name="/analyze_enhanced"
+                )
+                ```
+                
+                ### Batch Processing
+                ```python
+                results = client.predict(
+                    files=["video1.mp4", "video2.mp4"],
+                    model="yolo-v11-s", 
+                    api_name="/batch_analyze"
+                )
+                ```
+                \"\"\")
+                gr.HTML(\"\"\"
+                        <div class="author-info">
+                            <p><strong>Created by:</strong> Csaba Bolyós (BladeSzaSza)</p>
+                            <p style="margin: 5px 0;">
+                                <a href="https://github.com/bladeszasza" style="color: #a8e6cf; text-decoration: none;">🔗 GitHub</a> • 
+                                <a href="https://huggingface.co/BladeSzaSza" style="color: #a8e6cf; text-decoration: none;">🤗 Hugging Face</a> • 
+                                <a href="https://www.linkedin.com/in/csaba-bolyós-00a11767/" style="color: #a8e6cf; text-decoration: none;">💼 LinkedIn</a>
+                            </p>
+                            <p style="font-size: 12px; opacity: 0.9;">Contact: [email protected]</p>
+                        </div>
+                        \"\"\")
+                        
+                        # Footer with proper attribution
+        gr.HTML(\"\"\"
+        <div style="text-align: center; padding: 20px; margin-top: 30px; border-top: 1px solid #eee;">
+            <p style="color: #666; margin-bottom: 10px;">
+                🎭 Laban Movement Analysis - Complete Suite | Heavy Beta Version
+            </p>
+            <p style="color: #666; font-size: 12px;">
+                Created by <strong>Csaba Bolyós</strong> | Powered by MediaPipe, MoveNet & YOLO
+            </p>
+            <p style="color: #666; font-size: 10px; margin-top: 10px;">
+                <a href="https://github.com/bladeszasza" style="color: #40826D;">GitHub</a> • 
+                <a href="https://huggingface.co/BladeSzaSza" style="color: #40826D;">Hugging Face</a> • 
+                <a href="https://www.linkedin.com/in/csaba-bolyós-00a11767/" style="color: #40826D;">LinkedIn</a>
+            </p>
+        </div>
+        \"\"\")
+    
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_unified_demo()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        favicon_path=None
+    )
+
+```
+""", elem_classes=["md-custom"], header_links=True)
+
+
+    gr.Markdown("""
+## `LabanMovementAnalysis`
+
+### Initialization
+""", elem_classes=["md-custom"], header_links=True)
+
+    gr.ParamViewer(value=_docs["LabanMovementAnalysis"]["members"]["__init__"], linkify=[])
+
+
+
+
+    gr.Markdown("""
+
+### User function
+
+The impact on the users predict function varies depending on whether the component is used as an input or output for an event (or both).
+
+- When used as an Input, the component only impacts the input signature of the user function.
+- When used as an output, the component only impacts the return signature of the user function.
+
+The code snippet below is accurate in cases where the component is used as both an input and an output.
+
+- **As input:** Is passed, processed data for analysis.
+- **As output:** Should return, analysis results.
+
+ ```python
+def predict(
+    value: typing.Dict[str, typing.Any][str, typing.Any]
+) -> typing.Any:
+    return value
+```
+""", elem_classes=["md-custom", "LabanMovementAnalysis-user-fn"], header_links=True)
+
+
+
+
+    demo.load(None, js=r"""function() {
+    const refs = {};
+    const user_fn_refs = {
+          LabanMovementAnalysis: [], };
+    requestAnimationFrame(() => {
+
+        Object.entries(user_fn_refs).forEach(([key, refs]) => {
+            if (refs.length > 0) {
+                const el = document.querySelector(`.${key}-user-fn`);
+                if (!el) return;
+                refs.forEach(ref => {
+                    el.innerHTML = el.innerHTML.replace(
+                        new RegExp("\\b"+ref+"\\b", "g"),
+                        `<a href="#h-${ref.toLowerCase()}">${ref}</a>`
+                    );
+                })
+            }
+        })
+
+        Object.entries(refs).forEach(([key, refs]) => {
+            if (refs.length > 0) {
+                const el = document.querySelector(`.${key}`);
+                if (!el) return;
+                refs.forEach(ref => {
+                    el.innerHTML = el.innerHTML.replace(
+                        new RegExp("\\b"+ref+"\\b", "g"),
+                        `<a href="#h-${ref.toLowerCase()}">${ref}</a>`
+                    );
+                })
+            }
+        })
+    })
+}
+
+""")
+
+demo.launch()

demo/test_component.py

@@ -0,0 +1,69 @@
+"""
+Test script to verify the Laban Movement Analysis component structure.
+"""
+
+import sys
+from pathlib import Path
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent / "backend"))
+
+# Test imports
+try:
+    from gradio_labanmovementanalysis import LabanMovementAnalysis
+    print("✓ LabanMovementAnalysis component imported successfully")
+    
+    from gradio_labanmovementanalysis import video_utils
+    print("✓ video_utils module imported successfully")
+    
+    from gradio_labanmovementanalysis import pose_estimation
+    print("✓ pose_estimation module imported successfully")
+    
+    from gradio_labanmovementanalysis import notation_engine
+    print("✓ notation_engine module imported successfully")
+    
+    from gradio_labanmovementanalysis import json_generator
+    print("✓ json_generator module imported successfully")
+    
+    from gradio_labanmovementanalysis import visualizer
+    print("✓ visualizer module imported successfully")
+    
+except ImportError as e:
+    print(f"✗ Import error: {e}")
+    sys.exit(1)
+
+# Test component instantiation
+try:
+    component = LabanMovementAnalysis()
+    print("\n✓ Component instantiated successfully")
+    
+    # Test component methods
+    example_payload = component.example_payload()
+    print(f"✓ Example payload: {example_payload}")
+    
+    example_value = component.example_value()
+    print(f"✓ Example value keys: {list(example_value.keys())}")
+    
+    api_info = component.api_info()
+    print(f"✓ API info type: {api_info['type']}")
+    
+except Exception as e:
+    print(f"✗ Component error: {e}")
+    sys.exit(1)
+
+# Test data structures
+try:
+    from gradio_labanmovementanalysis.pose_estimation import Keypoint, PoseResult
+    kp = Keypoint(x=0.5, y=0.5, confidence=0.9, name="nose")
+    print(f"\n✓ Keypoint created: {kp}")
+    
+    from gradio_labanmovementanalysis.notation_engine import Direction, Speed, Intensity
+    print(f"✓ Direction values: {[d.value for d in Direction]}")
+    print(f"✓ Speed values: {[s.value for s in Speed]}")
+    print(f"✓ Intensity values: {[i.value for i in Intensity]}")
+    
+except Exception as e:
+    print(f"✗ Data structure error: {e}")
+    sys.exit(1)
+
+print("\n✅ All tests passed! The component is properly structured.") 

dist/gradio_labanmovementanalysis-0.0.1.tar.gz

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

dist/gradio_labanmovementanalysis-0.0.2.tar.gz

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

examples/agent_example.py

@@ -0,0 +1,142 @@
+"""
+Example script demonstrating agent-friendly API usage
+for Laban Movement Analysis
+"""
+
+import sys
+from pathlib import Path
+
+# Add parent to path
+sys.path.insert(0, str(Path(__file__).parent.parent / "backend"))
+
+from gradio_labanmovementanalysis import (
+    LabanAgentAPI, 
+    PoseModel,
+    MovementDirection,
+    MovementIntensity,
+    quick_analyze,
+    analyze_and_summarize
+)
+
+
+def main():
+    """Demonstrate various agent API features"""
+    
+    print("🎭 Laban Movement Analysis - Agent API Examples\n")
+    
+    # Example video paths (replace with your own)
+    video_path = "examples/dance.mp4"
+    
+    # 1. Quick analysis with summary
+    print("1. Quick Analysis with Summary")
+    print("-" * 40)
+    summary = analyze_and_summarize(video_path)
+    print(summary)
+    print()
+    
+    # 2. Detailed analysis with structured output
+    print("2. Detailed Analysis")
+    print("-" * 40)
+    api = LabanAgentAPI()
+    result = api.analyze(video_path, generate_visualization=True)
+    
+    if result.success:
+        print(f"✓ Analysis successful!")
+        print(f"  Direction: {result.dominant_direction.value}")
+        print(f"  Intensity: {result.dominant_intensity.value}")
+        print(f"  Speed: {result.dominant_speed}")
+        print(f"  Fluidity: {result.fluidity_score:.2f}")
+        print(f"  Expansion: {result.expansion_score:.2f}")
+        print(f"  Segments: {len(result.movement_segments)}")
+        if result.visualization_path:
+            print(f"  Visualization saved to: {result.visualization_path}")
+    else:
+        print(f"✗ Analysis failed: {result.error}")
+    print()
+    
+    # 3. Batch processing example
+    print("3. Batch Processing")
+    print("-" * 40)
+    video_paths = [
+        "examples/dance.mp4",
+        "examples/exercise.mp4",
+        "examples/walking.mp4"
+    ]
+    
+    # Filter out non-existent files
+    existing_paths = [p for p in video_paths if Path(p).exists()]
+    
+    if existing_paths:
+        results = api.batch_analyze(existing_paths, parallel=True)
+        for i, result in enumerate(results):
+            print(f"Video {i+1}: {Path(result.video_path).name}")
+            if result.success:
+                print(f"  ✓ {result.dominant_direction.value} movement, "
+                      f"{result.dominant_intensity.value} intensity")
+            else:
+                print(f"  ✗ Failed: {result.error}")
+    else:
+        print("  No example videos found")
+    print()
+    
+    # 4. Movement filtering example
+    print("4. Movement Filtering")
+    print("-" * 40)
+    if existing_paths and len(existing_paths) > 1:
+        # Find high-intensity movements
+        high_intensity = api.filter_by_movement(
+            existing_paths,
+            intensity=MovementIntensity.HIGH,
+            min_fluidity=0.5
+        )
+        
+        print(f"Found {len(high_intensity)} high-intensity videos:")
+        for result in high_intensity:
+            print(f"  - {Path(result.video_path).name}: "
+                  f"fluidity={result.fluidity_score:.2f}")
+    print()
+    
+    # 5. Video comparison example
+    print("5. Video Comparison")
+    print("-" * 40)
+    if len(existing_paths) >= 2:
+        comparison = api.compare_videos(existing_paths[0], existing_paths[1])
+        print(f"Comparing: {comparison['video1']} vs {comparison['video2']}")
+        print(f"  Direction match: {comparison['metrics']['direction_match']}")
+        print(f"  Intensity match: {comparison['metrics']['intensity_match']}")
+        print(f"  Fluidity difference: {comparison['metrics']['fluidity_difference']:.2f}")
+    print()
+    
+    # 6. Model comparison
+    print("6. Model Comparison")
+    print("-" * 40)
+    if existing_paths:
+        test_video = existing_paths[0]
+        models = [PoseModel.MEDIAPIPE, PoseModel.MOVENET]
+        
+        for model in models:
+            result = api.analyze(test_video, model=model)
+            if result.success:
+                print(f"{model.value}: {result.dominant_direction.value} "
+                      f"({result.dominant_intensity.value})")
+
+
+def async_example():
+    """Example of async usage"""
+    import asyncio
+    
+    async def analyze_async():
+        api = LabanAgentAPI()
+        result = await api.analyze_async("examples/dance.mp4")
+        return api.get_movement_summary(result)
+    
+    # Run async example
+    summary = asyncio.run(analyze_async())
+    print("Async Analysis:", summary)
+
+
+if __name__ == "__main__":
+    main()
+    
+    # Uncomment to run async example
+    # async_example() 

frontend/Example.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+	export let value: string;
+	export let type: "gallery" | "table";
+	export let selected = false;
+</script>
+
+<div
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	{value}
+</div>
+
+<style>
+	.gallery {
+		padding: var(--size-1) var(--size-2);
+	}
+</style>

frontend/Index.svelte

@@ -0,0 +1,37 @@
+<script lang="ts">
+	import { JsonView } from "@zerodevx/svelte-json-view";
+
+	import type { Gradio } from "@gradio/utils";
+	import { Block, Info } from "@gradio/atoms";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+	import type { SelectData } from "@gradio/utils";
+
+	export let elem_id = "";
+	export let elem_classes: string[] = [];
+	export let visible = true;
+	export let value = false;
+	export let container = true;
+	export let scale: number | null = null;
+	export let min_width: number | undefined = undefined;
+	export let loading_status: LoadingStatus;
+	export let gradio: Gradio<{
+		change: never;
+		select: SelectData;
+		input: never;
+		clear_status: LoadingStatus;
+	}>;
+</script>
+
+<Block {visible} {elem_id} {elem_classes} {container} {scale} {min_width}>
+	{#if loading_status}
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
+			i18n={gradio.i18n}
+			{...loading_status}
+			on:clear_status={() => gradio.dispatch("clear_status", loading_status)}
+		/>
+	{/if}
+
+	<JsonView json={value} />
+</Block>

frontend/gradio.config.js

@@ -0,0 +1,9 @@
+export default {
+  plugins: [],
+  svelte: {
+    preprocess: [],
+  },
+  build: {
+    target: "modules",
+  },
+};

frontend/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "gradio_labanmovementanalysis",
+  "version": "0.4.22",
+  "description": "Gradio UI packages",
+  "type": "module",
+  "author": "",
+  "license": "ISC",
+  "private": false,
+  "main_changeset": true,
+  "exports": {
+    ".": {
+      "gradio": "./Index.svelte",
+      "svelte": "./dist/Index.svelte",
+      "types": "./dist/Index.svelte.d.ts"
+    },
+    "./example": {
+      "gradio": "./Example.svelte",
+      "svelte": "./dist/Example.svelte",
+      "types": "./dist/Example.svelte.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@gradio/atoms": "0.16.1",
+    "@gradio/statustracker": "0.10.12",
+    "@gradio/utils": "0.10.2",
+    "@zerodevx/svelte-json-view": "^1.0.7"
+  },
+  "devDependencies": {
+    "@gradio/preview": "0.13.0"
+  },
+  "peerDependencies": {
+    "svelte": "^4.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gradio-app/gradio.git",
+    "directory": "js/fallback"
+  }
+}

mcp.json

@@ -0,0 +1,57 @@
+{
+  "mcpServers": {
+    "laban-movement-analysis": {
+      "command": "python",
+      "args": ["-m", "backend.mcp_server"],
+      "env": {
+        "PYTHONPATH": "."
+      },
+      "schema": {
+        "name": "Laban Movement Analysis",
+        "description": "Analyze human movement in videos using pose estimation and Laban Movement Analysis metrics",
+        "version": "1.0.0",
+        "tools": [
+          {
+            "name": "analyze_video",
+            "description": "Analyze movement in a video file",
+            "parameters": {
+              "video_path": "string",
+              "model": "string (optional)",
+              "enable_visualization": "boolean (optional)",
+              "include_keypoints": "boolean (optional)"
+            }
+          },
+          {
+            "name": "get_analysis_summary", 
+            "description": "Get human-readable summary of analysis",
+            "parameters": {
+              "analysis_id": "string"
+            }
+          },
+          {
+            "name": "list_available_models",
+            "description": "List available pose estimation models",
+            "parameters": {}
+          },
+          {
+            "name": "batch_analyze",
+            "description": "Analyze multiple videos in batch",
+            "parameters": {
+              "video_paths": "array of strings",
+              "model": "string (optional)",
+              "parallel": "boolean (optional)"
+            }
+          },
+          {
+            "name": "compare_movements",
+            "description": "Compare movement patterns between videos",
+            "parameters": {
+              "analysis_id1": "string",
+              "analysis_id2": "string"
+            }
+          }
+        ]
+      }
+    }
+  }
+} 

pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = [
+  "hatchling",
+  "hatch-requirements-txt",
+  "hatch-fancy-pypi-readme>=22.5.0",
+]
+build-backend = "hatchling.build"
+
+[project]
+name = "gradio_labanmovementanalysis"
+version = "0.0.2"
+description = "A Gradio 5 component for video movement analysis using Laban Movement Analysis (LMA) with MCP support for AI agents"
+readme = "README.md"
+license = "apache-2.0"
+requires-python = ">=3.10"
+authors = [{ name = "Csaba Bolyós", email = "[email protected]" }]
+keywords = ["gradio-custom-component", "gradio-5", "laban-movement-analysis", "LMA", "pose-estimation", "movement-analysis", "mcp", "ai-agents", "webrtc"]
+# Core dependencies
+dependencies = [
+    "gradio>=5.0.0",
+    "opencv-python>=4.8.0",
+    "numpy>=1.24.0",
+    "mediapipe>=0.10.21",
+    "tensorflow>=2.13.0",
+    "ultralytics>=8.0.0",
+    "torch>=2.0.0",
+    "torchvision>=0.15.0"
+]
+classifiers = [
+  'Development Status :: 4 - Beta',
+  'Operating System :: OS Independent',
+  'Programming Language :: Python :: 3',
+  'Programming Language :: Python :: 3 :: Only',
+  'Programming Language :: Python :: 3.10',
+  'Programming Language :: Python :: 3.11',
+  'Programming Language :: Python :: 3.12',
+  'Topic :: Scientific/Engineering',
+  'Topic :: Scientific/Engineering :: Artificial Intelligence',
+  'Topic :: Scientific/Engineering :: Visualization',
+]
+
+# The repository and space URLs are optional, but recommended.
+# Adding a repository URL will create a badge in the auto-generated README that links to the repository.
+# Adding a space URL will create a badge in the auto-generated README that links to the space.
+# This will make it easy for people to find your deployed demo or source code when they
+# encounter your project in the wild.
+
+# [project.urls]
+# repository = "your github repository"
+# space = "your space url"
+
+[project.optional-dependencies]
+dev = ["build", "twine"]
+mcp = ["mcp>=1.0.0", "aiofiles>=23.0.0", "httpx>=0.24.0"]
+agent = ["gradio-client>=1.0.0"]
+all = ["gradio_labanmovementanalysis[mcp,agent]"]
+
+[tool.hatch.build]
+artifacts = ["/backend/gradio_labanmovementanalysis/templates", "*.pyi"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["/backend/gradio_labanmovementanalysis"]

requirements.txt

@@ -0,0 +1,49 @@
+# Laban Movement Analysis - Complete Suite
+# Created by: Csaba Bolyós (BladeSzaSza)
+# Heavy Beta Version
+
+# Core Gradio and UI
+gradio>=5.0.0
+gradio-webrtc>=0.0.31
+
+# Computer Vision and Pose Estimation
+opencv-python>=4.8.0
+mediapipe>=0.10.21
+ultralytics>=8.0.0
+
+# Scientific Computing
+numpy>=1.21.0,<2.0.0
+scipy>=1.7.0
+pandas>=1.3.0
+
+# Image and Video Processing
+Pillow>=8.3.0
+imageio>=2.19.0
+imageio-ffmpeg>=0.4.7
+moviepy>=1.0.3
+
+# Machine Learning
+torch>=2.0.0
+torchvision>=0.15.0
+tensorflow>=2.10.0
+
+# WebRTC and Streaming
+twilio>=8.2.0
+aiortc>=1.4.0
+av>=10.0.0
+
+# Utilities
+requests>=2.28.0
+yt-dlp>=2023.1.6
+tqdm>=4.64.0
+matplotlib>=3.5.0
+seaborn>=0.11.0
+
+# Development and Deployment
+python-multipart>=0.0.5
+uvicorn>=0.18.0
+fastapi>=0.95.0
+
+# Optional WebRTC dependencies
+aiohttp>=3.8.0
+websockets>=10.0