simplified front end

README.md

@@ -13,7 +13,6 @@ tags:
   - pose-estimation
   - movement-analysis
   - video-analysis
-  - webrtc
   - youtube
   - vimeo
   - mcp
@@ -39,907 +38,81 @@ pip install gradio_labanmovementanalysis
 ## Usage
 
 ```python
+# app.py  ─────────────────────────────────────────────────────────
 """
-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
+Laban Movement Analysis – modernised Gradio Space
+Author: Csaba (BladeSzaSza)
 """
 
 import gradio as gr
-import sys
-from pathlib import Path
-from typing import Dict, Any, List, Tuple, Union, Optional
-
-# 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: Optional[str], model: str, enable_viz: int, include_keypoints: int) -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
-    """Standard video processing function with proper type annotations."""
-    if video is None:
-        return None, None
-    
-    try:
-        # Convert int to bool
-        enable_viz_bool = bool(enable_viz)
-        include_keypoints_bool = bool(include_keypoints)
-        
-        json_output, video_output = analyzer.process_video(
-            video,
-            model=model,
-            enable_visualization=enable_viz_bool,
-            include_keypoints=include_keypoints_bool
-        )
-        return json_output, video_output
-    except Exception as e:
-        return {"error": str(e)}, None
 
 
-def process_video_enhanced(video_input: Optional[str], model: str, enable_viz: int, include_keypoints: int) -> Tuple[Dict[str, Any], Optional[str]]:
-    """Enhanced video processing with all new features."""
-    if not video_input:
-        return {"error": "No video provided"}, None
-    
-    try:
-        # Convert int to bool
-        enable_viz_bool = bool(enable_viz)
-        include_keypoints_bool = bool(include_keypoints)
-        
-        # 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_bool,
-            include_keypoints=include_keypoints_bool
-        )
-        return json_result, viz_result
-    except Exception as e:
-        error_result = {"error": str(e)}
-        return error_result, None
+# ── 3.  Dummy backend for local dev (replace with real fn) ───────
+def process_video_standard(video, model, viz, kp):
+    """Return empty JSON + passthrough video placeholder."""
+    return {}, video
 
+# ── 4.  Build UI ─────────────────────────────────────────────────
+def create_demo() -> gr.Blocks:
+    with gr.Blocks(
+        title="Laban Movement Analysis – Complete Suite",
+        theme='gstaff/sketch',
+        fill_width=True,
+    ) as demo:
 
-def process_video_for_agent(video: Optional[str], model: str, output_format: str = "summary") -> Dict[str, Any]:
-    """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: Optional[List], model: str) -> Dict[str, Any]:
-    """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)}
+        # ── Hero banner ──
+        gr.HTML(
+            """
+            <div class="main-header">
+              <h1>🎭 Laban Movement Analysis – Complete Suite</h1>
+              <p>Pose estimation • AI action recognition • Real-time agents</p>
+              <p style="font-size:.85rem;opacity:.85">v0.01-beta • 20+ pose models • MCP</p>
+            </div>
+            """
+        )
 
+        # ── Workspace ──
+        with gr.Row(equal_height=True):
+            # Input column
+            with gr.Column(scale=1, min_width=260):
+                video_in = gr.Video(label="Upload Video", sources=["upload"], format="mp4")
+                model_sel = gr.Dropdown(
+                    ["mediapipe", "movenet", "yolo"], value="mediapipe", label="Pose Model"
+                )
+                with gr.Accordion("Options", open=False):
+                    enable_viz = gr.Radio([("Yes", 1), ("No", 0)], value=1, label="Visualization")
+                    include_kp = gr.Radio([("Yes", 1), ("No", 0)], value=0, label="Raw Keypoints")
+                analyze_btn = gr.Button("Analyze Movement", variant="primary")
+
+            # Output column
+            with gr.Column(scale=2, min_width=320):
+                viz_out = gr.Video(label="Annotated Video")
+                with gr.Accordion("Raw JSON", open=False):
+                    json_out = gr.JSON(label="Movement Analysis", elem_classes=["json-output"])
+
+        # Wiring
+        analyze_btn.click(
+            fn=process_video_standard,
+            inputs=[video_in, model_sel, enable_viz, include_kp],
+            outputs=[json_out, viz_out],
+        )
 
-def filter_videos_by_movement(files: Optional[List], direction: str, intensity: str, min_fluidity: float, min_expansion: float) -> Dict[str, Any]:
-    """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
+        # Footer
+        gr.HTML(
+            """
+            <div class="author-info">
+              Built by Csaba Bolyós •
+              <a href="https://github.com/bladeszasza" target="_blank">GitHub</a> •
+              <a href="https://huggingface.co/BladeSzaSza" target="_blank">HF</a>
+            </div>
+            """
         )
-        
-        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: Optional[str], model1: str, model2: str) -> List[List[str]]:
-    """Compare two different pose models on the same video."""
-    if not video:
-        return [["Error", "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: str) -> Tuple[str, Dict[str, Any]]:
-    """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() -> Tuple[str, Dict[str, Any]]:
-    """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."""
-    
-    # Custom theme - simplified to avoid JSON schema issues
-    custom_theme = gr.themes.Soft(
-        primary_hue=gr.themes.colors.emerald,   # Viridian green
-        secondary_hue=gr.themes.colors.blue,    # Cobalt blue
-        neutral_hue=gr.themes.colors.gray,
-    )
-    
-    with gr.Blocks(
-        title="Laban Movement Analysis - Complete Suite by Csaba Bolyós",
-        theme=custom_theme,
-        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 #40826D;
-            border-radius: 8px;
-            padding: 16px;
-            margin: 8px 0;
-            background: linear-gradient(135deg, #F5F5DC 0%, #F0F8E8 100%);
-        }
-        .json-output {
-            max-height: 600px;
-            overflow-y: auto;
-            font-family: monospace;
-            font-size: 12px;
-            background: #F8F9FA;
-            border: 1px solid #40826D;
-        }
-        .author-info {
-            background: linear-gradient(135deg, #40826D 0%, #2E5E4A 100%);
-            color: white;
-            padding: 15px;
-            border-radius: 8px;
-            margin: 10px 0;
-            text-align: center;
-        }
-        /* Dark mode support */
-        .dark .feature-card {
-            background: linear-gradient(135deg, #1e3a32 0%, #2d4a3d 100%);
-            border-color: #40826D;
-        }
-        .dark .json-output {
-            background: #2d3748;
-            color: #e2e8f0;
-        }
-        """
-    ) 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.Radio(
-                                choices=[("Yes", 1), ("No", 0)],
-                                value=1,
-                                label="Generate Visualization"
-                            )
-                            
-                            include_keypoints_std = gr.Radio(
-                                choices=[("Yes", 1), ("No", 0)],
-                                value=0,
-                                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):
-                        with gr.Group(elem_classes=["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=[
-                                    ["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.Radio(
-                                    choices=[("Yes", 1), ("No", 0)],
-                                    value=1,
-                                    label="Visualization"
-                                )
-                            
-                            with gr.Row():
-                                include_keypoints_enh = gr.Radio(
-                                    choices=[("Yes", 1), ("No", 0)],
-                                    value=0,
-                                    label="Raw Keypoints"
-                                )
-                            
-                            analyze_btn_enh = gr.Button("🚀 Enhanced Analysis", variant="primary", size="lg")
-                    
-                    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: Optional[str], url_input: str, model: str, enable_viz: int, include_keypoints: int) -> Tuple[Dict[str, Any], Optional[str]]:
-                    """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: linear-gradient(135deg, #F0F8E8 0%, #E8F4FD 100%); padding: 15px; border-radius: 8px; margin-top: 10px; border: 1px solid #40826D;">
-                        <h4 style="color: #2E5E4A;">📹 WebRTC Pose Analysis</h4>
-                        <p style="margin: 5px 0; color: #1B3A2F;">Real-time movement analysis using your webcam</p>
-                        
-                        <h4 style="color: #2E5E4A;">🔒 Privacy</h4>
-                        <p style="margin: 5px 0; color: #1B3A2F;">Processing happens locally - no video data stored</p>
-                        
-                        <h4 style="color: #2E5E4A;">💡 Usage</h4>
-                        <ul style="margin: 5px 0; padding-left: 20px; color: #1B3A2F;">
-                            <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"
-                )
-                ```
-                """)
-                
-                # Author info with proper styling
-                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 #40826D;">
-            <p style="color: #2E5E4A; margin-bottom: 10px;">
-                🎭 Laban Movement Analysis - Complete Suite | Heavy Beta Version
-            </p>
-            <p style="color: #2E5E4A; font-size: 12px;">
-                Created by <strong>Csaba Bolyós</strong> | Powered by MediaPipe, MoveNet & YOLO
-            </p>
-            <p style="color: #2E5E4A; 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
-    )
+        print("🚀 Starting Laban Movement Analysis...")
+        demo = create_demo()
+        
 
 ```
 
@@ -996,18 +169,8 @@ bool
 <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>

backend/gradio_labanmovementanalysis/__init__.py

@@ -33,19 +33,3 @@ try:
     __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/labanmovementanalysis.py

@@ -19,11 +19,6 @@ 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
@@ -43,7 +38,7 @@ class LabanMovementAnalysis(Component):
                  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,
@@ -63,7 +58,7 @@ class LabanMovementAnalysis(Component):
             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)
         """
@@ -85,8 +80,6 @@ class LabanMovementAnalysis(Component):
         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 = {}
         
@@ -94,14 +87,6 @@ class LabanMovementAnalysis(Component):
         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]:
         """
@@ -293,61 +278,7 @@ class LabanMovementAnalysis(Component):
         """
         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() 
@@ -358,10 +289,6 @@ class LabanMovementAnalysis(Component):
         # 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."""

backend/gradio_labanmovementanalysis/labanmovementanalysis.pyi

@@ -1,448 +0,0 @@
-"""
-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": "integer", "description": "Generate visualization video (1=yes, 0=no)"},
-                "include_keypoints": {"type": "integer", "description": "Include keypoints in JSON (1=yes, 0=no)"}
-            },
-            "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/webrtc_handler.py

@@ -1,293 +0,0 @@
-"""
-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() 

demo/app.py

@@ -21,13 +21,12 @@ def create_demo() -> gr.Blocks:
     ) as demo:
 
         # ── Hero banner ──
-        gr.HTML(
+        gr.Markdown(
             """
-            <div class="main-header">
-              <h1>🎭 Laban Movement Analysis – Complete Suite</h1>
-              <p>Pose estimation • AI action recognition • Real-time agents</p>
-              <p style="font-size:.85rem;opacity:.85">v0.01-beta • 20+ pose models • MCP</p>
-            </div>
+            # 🎭 Laban Movement Analysis – Complete Suite
+            
+            Pose estimation • AI action recognition • Real-time agents  
+            **v0.01-beta • 20+ pose models • MCP**
             """
         )
 
@@ -58,14 +57,16 @@ def create_demo() -> gr.Blocks:
         )
 
         # Footer
-        gr.HTML(
-            """
-            <div class="author-info">
-              Built by Csaba Bolyós •
-              <a href="https://github.com/bladeszasza" target="_blank">GitHub</a> •
-              <a href="https://huggingface.co/BladeSzaSza" target="_blank">HF</a>
-            </div>
-            """
-        )
+        with gr.Row():
+            gr.Markdown(
+                """
+                **Built by Csaba Bolyós**  
+                [GitHub](https://github.com/bladeszasza) • [HF](https://huggingface.co/BladeSzaSza)
+                """
+            )
     return demo
-
+    
+if __name__ == "__main__":
+        print("🚀 Starting Laban Movement Analysis...")
+        demo = create_demo()
+        

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/space.py

@@ -0,0 +1,183 @@
+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(
+    theme='gstaff/sketch',
+) 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
+# app.py  ─────────────────────────────────────────────────────────
+\"\"\"
+Laban Movement Analysis – modernised Gradio Space
+Author: Csaba (BladeSzaSza)
+\"\"\"
+
+import gradio as gr
+
+
+# ── 3.  Dummy backend for local dev (replace with real fn) ───────
+def process_video_standard(video, model, viz, kp):
+    \"\"\"Return empty JSON + passthrough video placeholder.\"\"\"
+    return {}, video
+
+# ── 4.  Build UI ─────────────────────────────────────────────────
+def create_demo() -> gr.Blocks:
+    with gr.Blocks(
+        title="Laban Movement Analysis – Complete Suite",
+        theme='gstaff/sketch',
+        fill_width=True,
+    ) as demo:
+
+        # ── Hero banner ──
+        gr.Markdown(
+            """
+            # 🎭 Laban Movement Analysis – Complete Suite
+            
+            Pose estimation • AI action recognition • Real-time agents  
+            **v0.01-beta • 20+ pose models • MCP**
+            """
+        )
+
+        # ── Workspace ──
+        with gr.Row(equal_height=True):
+            # Input column
+            with gr.Column(scale=1, min_width=260):
+                video_in = gr.Video(label="Upload Video", sources=["upload"], format="mp4")
+                model_sel = gr.Dropdown(
+                    ["mediapipe", "movenet", "yolo"], value="mediapipe", label="Pose Model"
+                )
+                with gr.Accordion("Options", open=False):
+                    enable_viz = gr.Radio([("Yes", 1), ("No", 0)], value=1, label="Visualization")
+                    include_kp = gr.Radio([("Yes", 1), ("No", 0)], value=0, label="Raw Keypoints")
+                analyze_btn = gr.Button("Analyze Movement", variant="primary")
+
+            # Output column
+            with gr.Column(scale=2, min_width=320):
+                viz_out = gr.Video(label="Annotated Video")
+                with gr.Accordion("Raw JSON", open=False):
+                    json_out = gr.JSON(label="Movement Analysis", elem_classes=["json-output"])
+
+        # Wiring
+        analyze_btn.click(
+            fn=process_video_standard,
+            inputs=[video_in, model_sel, enable_viz, include_kp],
+            outputs=[json_out, viz_out],
+        )
+
+        # Footer
+        with gr.Row():
+            gr.Markdown(
+                """
+                **Built by Csaba Bolyós**  
+                [GitHub](https://github.com/bladeszasza) • [HF](https://huggingface.co/BladeSzaSza)
+                """
+            )
+    return demo
+    
+if __name__ == "__main__":
+        print("🚀 Starting Laban Movement Analysis...")
+        demo = create_demo()
+        
+
+```
+""", 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()