Remove art_reels module completely - not working properly

modules/art_reels/__init__.py

@@ -1,40 +0,0 @@
-"""
-Art Reels Module - Animated Art Content Generator
-Pure Python implementation using Pillow and MoviePy
-"""
-import logging
-from config import NCAkitConfig
-
-logger = logging.getLogger(__name__)
-
-# Module-level app reference for accessing shared services
-_app = None
-
-
-def get_app():
-    """Get FastAPI app instance"""
-    return _app
-
-
-def register(app, config: NCAkitConfig):
-    """Register art_reels module with the app"""
-    global _app
-    
-    try:
-        from .router import router, set_app_reference
-        
-        # Store app reference for accessing TTS/Whisper from app.state
-        _app = app
-        set_app_reference(app)
-        
-        # Include router
-        app.include_router(router, prefix="/api/art", tags=["Art Reels"])
-        
-        logger.info("Art Reels module registered successfully")
-        return True
-        
-    except Exception as e:
-        logger.error(f"Failed to register art_reels module: {e}")
-        import traceback
-        logger.error(traceback.format_exc())
-        return False

modules/art_reels/router.py

@@ -1,536 +0,0 @@
-"""
-Art Reels Module Router
-API endpoints for art content generation
-"""
-import logging
-import uuid
-import asyncio
-import os
-import shutil
-from typing import Dict
-from fastapi import APIRouter, HTTPException, BackgroundTasks
-from fastapi.responses import FileResponse
-
-from .schemas import (
-    MinecraftRequest,
-    DrawingRequest,
-    StickFigureRequest,
-    JobResponse,
-    JobStatus
-)
-from .services.block_art import BlockArt
-from .services.drawing_animator import DrawingAnimator
-from .services.ai_drawing_animator import AIDrawingAnimator
-from .services.stick_figure import StickFigure
-from .services.video_composer import VideoComposer
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter()
-
-# App reference for accessing shared services (TTS, Whisper)
-_app = None
-
-
-def set_app_reference(app):
-    """Set FastAPI app reference for accessing shared services"""
-    global _app
-    _app = app
-    logger.info("App reference set for art_reels module")
-
-
-# In-memory job storage
-jobs: Dict[str, Dict] = {}
-
-# Initialize services
-block_art = BlockArt()
-drawing_animator = DrawingAnimator()
-stick_figure = StickFigure()
-video_composer = VideoComposer(output_dir="videos/art_reels")
-
-
-def update_job(job_id: str, status: str, progress: int = 0, 
-               video_url: str = None, error: str = None):
-    """Update job status"""
-    if job_id in jobs:
-        jobs[job_id].update({
-            "status": status,
-            "progress": progress,
-            "video_url": video_url,
-            "error": error
-        })
-
-
-async def generate_minecraft_video(job_id: str, description: str, blocks: int, speed: float):
-    """Background task to generate Minecraft block art video"""
-    temp_dir = f"temp/art_{job_id}"
-    
-    try:
-        update_job(job_id, "processing", 10)
-        
-        # Generate frames
-        logger.info(f"Generating Minecraft frames for job {job_id}")
-        frames_per_block = max(1, int(3 / speed))
-        frame_paths = block_art.generate_build_animation(
-            description=description,
-            output_dir=temp_dir,
-            blocks_per_frame=frames_per_block
-        )
-        
-        update_job(job_id, "processing", 60)
-        
-        # Compose video
-        logger.info(f"Composing video for job {job_id}")
-        video_path = video_composer.compose_video(
-            frame_paths=frame_paths,
-            output_name=f"minecraft_{job_id}.mp4",
-            fps=30
-        )
-        
-        update_job(job_id, "processing", 90)
-        
-        # Cleanup frames
-        video_composer.cleanup_frames(frame_paths)
-        if os.path.exists(temp_dir):
-            shutil.rmtree(temp_dir)
-        
-        update_job(job_id, "ready", 100, video_url=f"/api/art/video/{job_id}")
-        logger.info(f"Minecraft video ready: {job_id}")
-        
-    except Exception as e:
-        logger.error(f"Error generating Minecraft video: {e}")
-        update_job(job_id, "failed", error=str(e))
-
-
-async def generate_drawing_video(job_id: str, subject: str, style: str, colors: bool):
-    """Background task to generate AI-powered drawing animation video"""
-    temp_dir = f"temp/art_{job_id}"
-    
-    try:
-        update_job(job_id, "processing", 10)
-        
-        # Create AI Drawing Animator
-        ai_drawer = AIDrawingAnimator()
-        
-        # Generate frames using AI paths
-        logger.info(f"Generating AI drawing frames for job {job_id}: '{subject}'")
-        frame_paths = ai_drawer.generate_animation(
-            prompt=subject,
-            output_dir=temp_dir,
-            frames_per_path=12,
-            fps=30
-        )
-        
-        update_job(job_id, "processing", 60)
-        
-        # Compose video
-        logger.info(f"Composing video for job {job_id}")
-        video_path = video_composer.compose_video(
-            frame_paths=frame_paths,
-            output_name=f"drawing_{job_id}.mp4",
-            fps=30
-        )
-        
-        update_job(job_id, "processing", 85)
-        
-        # Upload to HF Hub (if enabled)
-        from pathlib import Path
-        from modules.shared.services.hf_storage import get_hf_storage
-        
-        hf_storage = get_hf_storage()
-        cloud_url = None
-        
-        if hf_storage and hf_storage.enabled:
-            logger.info(f"Uploading to HF Hub for job {job_id}")
-            cloud_url = hf_storage.upload_video(
-                local_path=Path(video_path),
-                video_id=job_id,
-                folder="art_reels"
-            )
-            if cloud_url:
-                logger.info(f"Uploaded to cloud: {cloud_url}")
-        
-        # Cleanup
-        video_composer.cleanup_frames(frame_paths)
-        if os.path.exists(temp_dir):
-            shutil.rmtree(temp_dir)
-        
-        video_url = cloud_url or f"/api/art/video/{job_id}"
-        update_job(job_id, "ready", 100, video_url=video_url)
-        logger.info(f"AI Drawing video ready: {job_id}")
-        
-    except Exception as e:
-        logger.error(f"Error generating drawing video: {e}")
-        import traceback
-        logger.error(traceback.format_exc())
-        update_job(job_id, "failed", error=str(e))
-
-
-async def generate_stick_figure_video(job_id: str, script: str, voice: str):
-    """Background task to generate stick figure motivation video with TTS"""
-    temp_dir = f"temp/art_{job_id}"
-    os.makedirs(temp_dir, exist_ok=True)
-    
-    try:
-        update_job(job_id, "processing", 5)
-        logger.info(f"Starting stick figure video with TTS for job {job_id}")
-        
-        # Import TTS, Whisper, and Professional Stick Figure
-        from ..story_reels.services.srt_parser import SRTParser
-        from .services.professional_stick_figure import ProfessionalStickFigure
-        
-        # Get TTS and Whisper clients from app.state (already initialized by story_reels)
-        if not _app or not hasattr(_app, 'state'):
-            raise Exception("App reference not available")
-        
-        tts_client = getattr(_app.state, 'tts_client', None)
-        whisper_client = getattr(_app.state, 'whisper_client', None)
-        
-        if not tts_client:
-            raise Exception("TTS client not available - check if story_reels module is loaded")
-        
-        if not whisper_client:
-            raise Exception("Whisper client not available - check if story_reels module is loaded")
-        
-        logger.info("Using TTS and Whisper clients from app.state")
-        
-        update_job(job_id, "processing", 10)
-        
-        # Step 1: Generate TTS audio from script
-        logger.info(f"Generating TTS audio for job {job_id}")
-        audio_path = os.path.join(temp_dir, "voice.wav")
-        
-        # TTS generate is async and returns (audio_bytes, duration)
-        audio_bytes, audio_duration = await tts_client.generate(text=script, voice=voice)
-        
-        # Save audio to file
-        with open(audio_path, "wb") as f:
-            f.write(audio_bytes)
-        
-        logger.info(f"TTS audio saved: {audio_path}, duration: {audio_duration:.2f}s")
-        
-        if not os.path.exists(audio_path):
-            raise Exception("TTS audio generation failed")
-        
-        update_job(job_id, "processing", 30)
-        
-        # Step 2: Generate captions with Whisper (exact story_reels workflow)
-        logger.info(f"Generating captions with Whisper for job {job_id}")
-        
-        # WhisperClient.create_captions returns List[Caption]
-        captions = await asyncio.to_thread(whisper_client.create_captions, audio_path)
-        
-        # Convert to dict format
-        captions_dict = [c.dict() for c in captions]
-        
-        # Generate .srt content (for video subtitles)
-        srt_content = SRTParser.generate_srt_content(captions_dict)
-        srt_path = os.path.join(temp_dir, "voice.srt")
-        with open(srt_path, "w", encoding="utf-8") as f:
-            f.write(srt_content)
-        logger.info(f"Generated .srt with {len(captions)} captions")
-        
-        # Get actual audio duration
-        from modules.video_creator.services.libraries.ffmpeg_utils import FFmpegUtils
-        audio_duration = FFmpegUtils.get_video_duration(audio_path)
-        
-        # Step 3: Create 2-second chunks (for AI scene generation)
-        chunks = SRTParser.create_2s_chunks(captions_dict, audio_duration)
-        logger.info(f"Created {len(chunks)} x 2s chunks for job {job_id}")
-        
-        update_job(job_id, "processing", 45)
-        
-        # Step 4: Generate scenes with AI (Professional)
-        pro_stick = ProfessionalStickFigure()
-        scenes = pro_stick.generate_scenes_with_ai(chunks)
-        
-        # Log scenes for debugging
-        logger.info(f"AI generated {len(scenes)} scenes for {len(chunks)} chunks")
-        for i, s in enumerate(scenes):
-            scene_info = f"Scene {i}: type={s.get('scene_type', 'unknown')}"
-            if s.get('characters'):
-                poses = [c.get('pose', 'unknown') for c in s['characters']]
-                scene_info += f", poses={poses}"
-            logger.info(scene_info)
-        
-        # Log chunks for debugging
-        logger.info(f"Chunks from SRTParser: {len(chunks)}")
-        for i, c in enumerate(chunks):
-            logger.info(f"Chunk {i}: text='{c.get('text', '')[:30]}...', duration={c.get('duration', 2.0)}s")
-        
-        # Calculate durations for each chunk (SRTParser provides 'duration' in seconds)
-        chunk_durations = []
-        for chunk in chunks:
-            # SRTParser.create_2s_chunks returns 'duration' key in seconds
-            duration = chunk.get('duration', 2.0)
-            chunk_durations.append(max(0.5, duration))
-        
-        update_job(job_id, "processing", 60)
-        
-        # Step 5: Generate frames
-        logger.info(f"Generating stick figure frames for job {job_id}")
-        frame_paths = pro_stick.generate_frames_from_scenes(
-            scenes=scenes,
-            chunk_durations=chunk_durations,
-            output_dir=temp_dir,
-            fps=30
-        )
-        
-        update_job(job_id, "processing", 80)
-        
-        # Step 6: Compose video with audio and captions
-        logger.info(f"Composing video with audio for job {job_id}")
-        video_path = video_composer.compose_video(
-            frame_paths=frame_paths,
-            audio_path=audio_path,
-            output_name=f"stick_{job_id}.mp4",
-            fps=30,
-            captions=captions_dict  # Word-by-word captions from Whisper
-        )
-        
-        update_job(job_id, "processing", 95)
-        
-        # Step 7: Upload to HF Hub (if enabled)
-        from pathlib import Path
-        from modules.shared.services.hf_storage import get_hf_storage
-        
-        hf_storage = get_hf_storage()
-        cloud_url = None
-        
-        if hf_storage and hf_storage.enabled:
-            logger.info(f"Uploading to HF Hub for job {job_id}")
-            cloud_url = hf_storage.upload_video(
-                local_path=Path(video_path),
-                video_id=job_id,
-                folder="art_reels"
-            )
-            if cloud_url:
-                logger.info(f"Uploaded to cloud: {cloud_url}")
-        
-        # Cleanup
-        video_composer.cleanup_frames(frame_paths)
-        if os.path.exists(temp_dir):
-            shutil.rmtree(temp_dir)
-        
-        # Set video URL (cloud if available, otherwise local)
-        video_url = cloud_url or f"/api/art/video/{job_id}"
-        update_job(job_id, "ready", 100, video_url=video_url)
-        logger.info(f"Stick figure video with TTS ready: {job_id}")
-        
-    except Exception as e:
-        logger.error(f"Error generating stick figure video: {e}")
-        import traceback
-        logger.error(traceback.format_exc())
-        update_job(job_id, "failed", error=str(e))
-
-
-def parse_script_to_scenes(script: str) -> list:
-    """Parse script text into scenes with poses and keywords"""
-    scenes = []
-    
-    # Split into sentences
-    sentences = [s.strip() for s in script.replace("।", ".").split(".") if s.strip()]
-    
-    # Keyword to pose/prop mapping
-    keyword_mapping = {
-        # Poses
-        "ঘুম": ("sleeping", []),
-        "sleep": ("sleeping", []),
-        "দৌড়": ("running", []),
-        "run": ("running", []),
-        "হাঁট": ("walking", []),
-        "walk": ("walking", []),
-        "বস": ("sitting", []),
-        "sit": ("sitting", []),
-        "ভাব": ("thinking", []),
-        "think": ("thinking", []),
-        # Props
-        "রাজা": ("standing", ["crown"]),
-        "king": ("standing", ["crown"]),
-        "বড়লোক": ("standing", ["money", "suit"]),
-        "rich": ("standing", ["money", "suit"]),
-        "টাকা": ("standing", ["money"]),
-        "money": ("standing", ["money"]),
-    }
-    
-    for sentence in sentences:
-        sentence_lower = sentence.lower()
-        pose = "standing"
-        props = []
-        
-        # Check for keywords
-        for keyword, (detected_pose, detected_props) in keyword_mapping.items():
-            if keyword in sentence_lower:
-                pose = detected_pose
-                props.extend(detected_props)
-                break
-        
-        # Check for text overlay triggers
-        text = None
-        text_triggers = ["get ready", "remember", "important", "key point", "মনে রাখ"]
-        for trigger in text_triggers:
-            if trigger in sentence_lower:
-                text = sentence[:50] + "..." if len(sentence) > 50 else sentence
-        
-        scenes.append({
-            "pose": pose,
-            "props": list(set(props)),
-            "text": text,
-            "duration": max(1.5, len(sentence) / 20)  # ~20 chars per second
-        })
-    
-    return scenes
-
-
-# ===================
-# API Endpoints
-# ===================
-
-@router.post("/minecraft",
-    response_model=JobResponse,
-    summary="Generate Minecraft block art video",
-    description="Create a Minecraft-style block-by-block building animation"
-)
-async def create_minecraft_video(request: MinecraftRequest, background_tasks: BackgroundTasks):
-    """Generate Minecraft block art video"""
-    job_id = uuid.uuid4().hex[:12]
-    
-    jobs[job_id] = {
-        "job_id": job_id,
-        "type": "minecraft",
-        "status": "queued",
-        "progress": 0,
-        "video_url": None,
-        "error": None
-    }
-    
-    background_tasks.add_task(
-        generate_minecraft_video,
-        job_id,
-        request.description,
-        request.blocks,
-        request.speed
-    )
-    
-    return JobResponse(
-        job_id=job_id,
-        status="queued",
-        message="Minecraft video generation started"
-    )
-
-
-@router.post("/drawing",
-    response_model=JobResponse,
-    summary="Generate code drawing animation",
-    description="Create a line-by-line drawing animation video"
-)
-async def create_drawing_video(request: DrawingRequest, background_tasks: BackgroundTasks):
-    """Generate code drawing animation video"""
-    job_id = uuid.uuid4().hex[:12]
-    
-    jobs[job_id] = {
-        "job_id": job_id,
-        "type": "drawing",
-        "status": "queued",
-        "progress": 0,
-        "video_url": None,
-        "error": None
-    }
-    
-    background_tasks.add_task(
-        generate_drawing_video,
-        job_id,
-        request.subject,
-        request.style.value,
-        request.colors
-    )
-    
-    return JobResponse(
-        job_id=job_id,
-        status="queued",
-        message="Drawing video generation started"
-    )
-
-
-@router.post("/stick-figure",
-    response_model=JobResponse,
-    summary="Generate stick figure motivation video",
-    description="Create a stick figure motivation/story video"
-)
-async def create_stick_figure_video(request: StickFigureRequest, background_tasks: BackgroundTasks):
-    """Generate stick figure motivation video"""
-    job_id = uuid.uuid4().hex[:12]
-    
-    jobs[job_id] = {
-        "job_id": job_id,
-        "type": "stick_figure",
-        "status": "queued",
-        "progress": 0,
-        "video_url": None,
-        "error": None
-    }
-    
-    background_tasks.add_task(
-        generate_stick_figure_video,
-        job_id,
-        request.script,
-        request.voice
-    )
-    
-    return JobResponse(
-        job_id=job_id,
-        status="queued",
-        message="Stick figure video generation started"
-    )
-
-
-@router.get("/{job_id}/status",
-    response_model=JobStatus,
-    summary="Get job status",
-    description="Check the status of a video generation job"
-)
-async def get_job_status(job_id: str):
-    """Get video generation job status"""
-    if job_id not in jobs:
-        raise HTTPException(status_code=404, detail="Job not found")
-    
-    job = jobs[job_id]
-    return JobStatus(**job)
-
-
-@router.get("/video/{job_id}",
-    summary="Download video",
-    description="Download the generated video file"
-)
-async def download_video(job_id: str):
-    """Download generated video"""
-    if job_id not in jobs:
-        raise HTTPException(status_code=404, detail="Job not found")
-    
-    job = jobs[job_id]
-    if job["status"] != "ready":
-        raise HTTPException(status_code=400, detail=f"Video not ready. Status: {job['status']}")
-    
-    # Find video file
-    video_dir = "videos/art_reels"
-    for filename in os.listdir(video_dir):
-        if job_id in filename:
-            video_path = os.path.join(video_dir, filename)
-            return FileResponse(
-                video_path,
-                media_type="video/mp4",
-                filename=filename
-            )
-    
-    raise HTTPException(status_code=404, detail="Video file not found")
-
-
-@router.get("/templates",
-    summary="List drawing templates",
-    description="Get available drawing templates"
-)
-async def list_templates():
-    """List available drawing templates"""
-    return {
-        "templates": list(DrawingAnimator.TEMPLATES.keys())
-    }

modules/art_reels/schemas.py

@@ -1,84 +0,0 @@
-"""
-Art Reels Module Schemas
-Request/Response models for art content generation
-"""
-from pydantic import BaseModel, Field
-from typing import Optional, List
-from enum import Enum
-
-
-# ===================
-# Enums
-# ===================
-
-class BlockTypeEnum(str, Enum):
-    """Minecraft block types"""
-    oak_wood = "oak_wood"
-    stone = "stone"
-    cobblestone = "cobblestone"
-    grass = "grass"
-    dirt = "dirt"
-    glass = "glass"
-    brick = "brick"
-
-
-class DrawingStyleEnum(str, Enum):
-    """Drawing animation styles"""
-    outline_first = "outline_first"
-    color_fill = "color_fill"
-    sketch = "sketch"
-
-
-class StickPoseEnum(str, Enum):
-    """Stick figure poses"""
-    standing = "standing"
-    walking = "walking"
-    running = "running"
-    sitting = "sitting"
-    sleeping = "sleeping"
-    waving = "waving"
-    thinking = "thinking"
-
-
-# ===================
-# Request Models
-# ===================
-
-class MinecraftRequest(BaseModel):
-    """Request for Minecraft block art video"""
-    description: str = Field(..., description="What to build, e.g., 'wooden survival house'")
-    blocks: int = Field(50, ge=10, le=200, description="Approximate number of blocks")
-    speed: float = Field(1.0, ge=0.5, le=3.0, description="Animation speed multiplier")
-
-
-class DrawingRequest(BaseModel):
-    """Request for code drawing animation"""
-    subject: str = Field(..., description="What to draw, e.g., 'a house', 'a tree'")
-    style: DrawingStyleEnum = Field(DrawingStyleEnum.outline_first, description="Drawing style")
-    colors: bool = Field(True, description="Add colors after outline")
-
-
-class StickFigureRequest(BaseModel):
-    """Request for stick figure motivation video"""
-    script: str = Field(..., description="Voice script text")
-    voice: str = Field("af_heart", description="Voice ID for TTS")
-
-
-# ===================
-# Response Models
-# ===================
-
-class JobResponse(BaseModel):
-    """Job creation response"""
-    job_id: str
-    status: str
-    message: str
-
-
-class JobStatus(BaseModel):
-    """Job status response"""
-    job_id: str
-    status: str
-    progress: int
-    video_url: Optional[str] = None
-    error: Optional[str] = None

modules/art_reels/services/__init__.py

@@ -1 +0,0 @@
-# Services init

modules/art_reels/services/ai_drawing_animator.py

@@ -1,535 +0,0 @@
-"""
-AI Drawing Animator - Dynamic SVG Path Generation with AI
-Generates complex drawings from any prompt using AI-generated paths
-"""
-import logging
-import os
-import json
-import math
-import re
-from PIL import Image, ImageDraw, ImageFont
-from typing import List, Tuple, Dict, Optional
-from groq import Groq
-
-logger = logging.getLogger(__name__)
-
-
-# AI System Prompt for SVG path generation
-DRAWING_PROMPT = """You are an expert SVG artist. Generate detailed drawing paths for any subject.
-
-OUTPUT FORMAT (JSON):
-{
-  "title": "Drawing Name",
-  "paths": [
-    {
-      "type": "line",
-      "start": [x1, y1],
-      "end": [x2, y2],
-      "color": "#000000",
-      "width": 3,
-      "order": 1
-    },
-    {
-      "type": "circle",
-      "center": [cx, cy],
-      "radius": r,
-      "color": "#FF0000",
-      "fill": true,
-      "order": 2
-    },
-    {
-      "type": "polygon",
-      "points": [[x1,y1], [x2,y2], [x3,y3]...],
-      "color": "#00FF00",
-      "fill": true,
-      "order": 3
-    },
-    {
-      "type": "arc",
-      "center": [cx, cy],
-      "radius": r,
-      "start_angle": 0,
-      "end_angle": 180,
-      "color": "#0000FF",
-      "width": 2,
-      "order": 4
-    },
-    {
-      "type": "bezier",
-      "points": [[x1,y1], [x2,y2], [x3,y3], [x4,y4]],
-      "color": "#000000",
-      "width": 2,
-      "order": 5
-    }
-  ]
-}
-
-CANVAS SIZE: 1080 x 1920 (9:16 portrait)
-CENTER: (540, 960)
-DRAWING AREA: (100, 300) to (980, 1600)
-
-RULES:
-1. Create DETAILED paths - at least 15-30 elements for complex subjects
-2. Use logical drawing order (background → foreground)
-3. Include both outline (lines) and fill (polygons/circles)
-4. Use varied line widths (2-8) for depth
-5. Keep everything within the drawing area
-6. Use colors that make sense for the subject
-7. For complex shapes, break into multiple simple paths
-
-EXAMPLES:
-- "car" → wheels (circles), body (polygon), windows (rectangles), details (lines)
-- "face" → head (circle), eyes (circles), nose (lines), mouth (arc), hair (beziers)
-- "tree" → trunk (rectangle), branches (lines), leaves (many small circles/polygons)
-- "house" → walls (polygons), roof (polygon), windows (rectangles), door (rectangle)
-
-Return ONLY valid JSON, no other text."""
-
-
-class AIDrawingAnimator:
-    """
-    AI-powered drawing animator that generates complex SVG-like paths
-    from any text prompt and animates them line-by-line.
-    """
-    
-    # Canvas dimensions
-    WIDTH = 1080
-    HEIGHT = 1920
-    
-    # Default colors
-    BG_COLOR = (255, 255, 255)
-    LINE_COLOR = (30, 30, 30)
-    
-    def __init__(self, groq_api_key: str = None):
-        self.groq_api_key = groq_api_key or os.environ.get("GROQ_API") or os.environ.get("GROQ_API_KEY")
-        if self.groq_api_key:
-            self.groq = Groq(api_key=self.groq_api_key)
-            logger.info("AI Drawing Animator initialized with Groq")
-        else:
-            self.groq = None
-            logger.warning("Groq API key not found - using fallback templates")
-        
-        self._load_fonts()
-    
-    def _load_fonts(self):
-        """Load fonts with fallbacks"""
-        try:
-            self.font_title = ImageFont.truetype("arial.ttf", 48)
-            self.font_label = ImageFont.truetype("arial.ttf", 32)
-        except:
-            self.font_title = ImageFont.load_default()
-            self.font_label = ImageFont.load_default()
-    
-    def generate_paths_with_ai(self, prompt: str) -> Dict:
-        """Generate drawing paths using AI"""
-        if not self.groq:
-            return self._get_fallback_drawing(prompt)
-        
-        try:
-            user_prompt = f"""Create a detailed drawing of: "{prompt}"
-
-Generate all the paths needed to draw this from scratch, line by line.
-Make it detailed and professional-looking.
-Return ONLY valid JSON."""
-
-            response = self.groq.chat.completions.create(
-                model="llama-3.3-70b-versatile",
-                messages=[
-                    {"role": "system", "content": DRAWING_PROMPT},
-                    {"role": "user", "content": user_prompt}
-                ],
-                temperature=0.7,
-                max_tokens=4000
-            )
-            
-            content = response.choices[0].message.content.strip()
-            
-            # Parse JSON
-            if "```" in content:
-                content = content.split("```")[1]
-                if content.startswith("json"):
-                    content = content[4:]
-                content = content.strip()
-            
-            drawing = json.loads(content)
-            logger.info(f"AI generated {len(drawing.get('paths', []))} paths for '{prompt}'")
-            return drawing
-            
-        except Exception as e:
-            logger.error(f"AI path generation failed: {e}")
-            return self._get_fallback_drawing(prompt)
-    
-    def _get_fallback_drawing(self, prompt: str) -> Dict:
-        """Fallback templates for common subjects"""
-        prompt_lower = prompt.lower()
-        
-        # Detect subject and return appropriate template
-        if any(word in prompt_lower for word in ["car", "vehicle", "auto"]):
-            return self._car_template()
-        elif any(word in prompt_lower for word in ["face", "person", "human", "head"]):
-            return self._face_template()
-        elif any(word in prompt_lower for word in ["tree", "plant", "forest"]):
-            return self._tree_template()
-        elif any(word in prompt_lower for word in ["house", "home", "building"]):
-            return self._house_template()
-        elif any(word in prompt_lower for word in ["flower", "rose", "tulip"]):
-            return self._flower_template()
-        elif any(word in prompt_lower for word in ["star", "stars"]):
-            return self._star_template()
-        elif any(word in prompt_lower for word in ["heart", "love"]):
-            return self._heart_template()
-        elif any(word in prompt_lower for word in ["sun", "sunrise"]):
-            return self._sun_template()
-        else:
-            # Default to a simple abstract pattern
-            return self._abstract_template(prompt)
-    
-    def _car_template(self) -> Dict:
-        """Detailed car template"""
-        return {
-            "title": "Sports Car",
-            "paths": [
-                # Car body
-                {"type": "polygon", "points": [[200, 900], [880, 900], [880, 750], [720, 750], [650, 650], [350, 650], [280, 750], [200, 750]], "color": "#E74C3C", "fill": True, "order": 1},
-                # Windows
-                {"type": "polygon", "points": [[360, 740], [640, 740], [600, 660], [380, 660]], "color": "#AED6F1", "fill": True, "order": 2},
-                # Front wheel
-                {"type": "circle", "center": [300, 900], "radius": 60, "color": "#2C3E50", "fill": True, "order": 3},
-                {"type": "circle", "center": [300, 900], "radius": 35, "color": "#95A5A6", "fill": True, "order": 4},
-                # Back wheel
-                {"type": "circle", "center": [780, 900], "radius": 60, "color": "#2C3E50", "fill": True, "order": 5},
-                {"type": "circle", "center": [780, 900], "radius": 35, "color": "#95A5A6", "fill": True, "order": 6},
-                # Headlight
-                {"type": "circle", "center": [850, 800], "radius": 20, "color": "#F1C40F", "fill": True, "order": 7},
-                # Door line
-                {"type": "line", "start": [500, 750], "end": [500, 900], "color": "#C0392B", "width": 3, "order": 8},
-                # Door handle
-                {"type": "line", "start": [440, 800], "end": [480, 800], "color": "#2C3E50", "width": 4, "order": 9},
-                # Ground
-                {"type": "line", "start": [100, 960], "end": [980, 960], "color": "#7F8C8D", "width": 5, "order": 10},
-            ]
-        }
-    
-    def _face_template(self) -> Dict:
-        """Detailed face template"""
-        cx, cy = 540, 700
-        return {
-            "title": "Human Face",
-            "paths": [
-                # Head outline
-                {"type": "circle", "center": [cx, cy], "radius": 200, "color": "#FDEBD0", "fill": True, "order": 1},
-                {"type": "circle", "center": [cx, cy], "radius": 200, "color": "#2C3E50", "fill": False, "order": 2},
-                # Left eye
-                {"type": "circle", "center": [cx-60, cy-40], "radius": 35, "color": "#FFFFFF", "fill": True, "order": 3},
-                {"type": "circle", "center": [cx-60, cy-40], "radius": 35, "color": "#2C3E50", "fill": False, "order": 4},
-                {"type": "circle", "center": [cx-60, cy-40], "radius": 15, "color": "#2C3E50", "fill": True, "order": 5},
-                # Right eye
-                {"type": "circle", "center": [cx+60, cy-40], "radius": 35, "color": "#FFFFFF", "fill": True, "order": 6},
-                {"type": "circle", "center": [cx+60, cy-40], "radius": 35, "color": "#2C3E50", "fill": False, "order": 7},
-                {"type": "circle", "center": [cx+60, cy-40], "radius": 15, "color": "#2C3E50", "fill": True, "order": 8},
-                # Nose
-                {"type": "line", "start": [cx, cy-20], "end": [cx, cy+40], "color": "#D35400", "width": 3, "order": 9},
-                {"type": "line", "start": [cx, cy+40], "end": [cx-15, cy+50], "color": "#D35400", "width": 3, "order": 10},
-                # Smile
-                {"type": "arc", "center": [cx, cy+60], "radius": 60, "start_angle": 10, "end_angle": 170, "color": "#E74C3C", "width": 5, "order": 11},
-                # Eyebrows
-                {"type": "line", "start": [cx-90, cy-90], "end": [cx-30, cy-85], "color": "#2C3E50", "width": 4, "order": 12},
-                {"type": "line", "start": [cx+30, cy-85], "end": [cx+90, cy-90], "color": "#2C3E50", "width": 4, "order": 13},
-                # Hair
-                {"type": "arc", "center": [cx, cy-100], "radius": 180, "start_angle": 200, "end_angle": 340, "color": "#5D4037", "width": 40, "order": 14},
-            ]
-        }
-    
-    def _tree_template(self) -> Dict:
-        """Detailed tree template"""
-        return {
-            "title": "Tree",
-            "paths": [
-                # Trunk
-                {"type": "polygon", "points": [[500, 1200], [580, 1200], [570, 900], [510, 900]], "color": "#795548", "fill": True, "order": 1},
-                # Main branches
-                {"type": "line", "start": [540, 900], "end": [400, 700], "color": "#5D4037", "width": 15, "order": 2},
-                {"type": "line", "start": [540, 900], "end": [680, 700], "color": "#5D4037", "width": 15, "order": 3},
-                {"type": "line", "start": [540, 850], "end": [540, 600], "color": "#5D4037", "width": 12, "order": 4},
-                # Leaves (circles)
-                {"type": "circle", "center": [400, 650], "radius": 80, "color": "#27AE60", "fill": True, "order": 5},
-                {"type": "circle", "center": [540, 550], "radius": 90, "color": "#2ECC71", "fill": True, "order": 6},
-                {"type": "circle", "center": [680, 650], "radius": 80, "color": "#27AE60", "fill": True, "order": 7},
-                {"type": "circle", "center": [470, 580], "radius": 70, "color": "#1E8449", "fill": True, "order": 8},
-                {"type": "circle", "center": [610, 580], "radius": 70, "color": "#1E8449", "fill": True, "order": 9},
-                {"type": "circle", "center": [540, 450], "radius": 60, "color": "#2ECC71", "fill": True, "order": 10},
-                # Ground
-                {"type": "line", "start": [200, 1200], "end": [880, 1200], "color": "#7F8C8D", "width": 3, "order": 11},
-            ]
-        }
-    
-    def _house_template(self) -> Dict:
-        """Detailed house template"""
-        return {
-            "title": "House",
-            "paths": [
-                # Main wall
-                {"type": "polygon", "points": [[250, 1100], [830, 1100], [830, 650], [250, 650]], "color": "#F5DEB3", "fill": True, "order": 1},
-                # Roof
-                {"type": "polygon", "points": [[200, 650], [540, 400], [880, 650]], "color": "#8B4513", "fill": True, "order": 2},
-                # Door
-                {"type": "polygon", "points": [[480, 1100], [600, 1100], [600, 850], [480, 850]], "color": "#5D4037", "fill": True, "order": 3},
-                # Door handle
-                {"type": "circle", "center": [570, 975], "radius": 10, "color": "#FFD700", "fill": True, "order": 4},
-                # Left window
-                {"type": "polygon", "points": [[300, 750], [420, 750], [420, 880], [300, 880]], "color": "#AED6F1", "fill": True, "order": 5},
-                {"type": "line", "start": [360, 750], "end": [360, 880], "color": "#FFFFFF", "width": 3, "order": 6},
-                {"type": "line", "start": [300, 815], "end": [420, 815], "color": "#FFFFFF", "width": 3, "order": 7},
-                # Right window
-                {"type": "polygon", "points": [[660, 750], [780, 750], [780, 880], [660, 880]], "color": "#AED6F1", "fill": True, "order": 8},
-                {"type": "line", "start": [720, 750], "end": [720, 880], "color": "#FFFFFF", "width": 3, "order": 9},
-                {"type": "line", "start": [660, 815], "end": [780, 815], "color": "#FFFFFF", "width": 3, "order": 10},
-                # Chimney
-                {"type": "polygon", "points": [[700, 550], [760, 550], [760, 430], [700, 430]], "color": "#A0522D", "fill": True, "order": 11},
-                # Ground
-                {"type": "line", "start": [100, 1100], "end": [980, 1100], "color": "#228B22", "width": 8, "order": 12},
-            ]
-        }
-    
-    def _flower_template(self) -> Dict:
-        """Flower template"""
-        cx, cy = 540, 700
-        return {
-            "title": "Flower",
-            "paths": [
-                # Stem
-                {"type": "line", "start": [cx, cy+100], "end": [cx, cy+400], "color": "#27AE60", "width": 8, "order": 1},
-                # Leaves
-                {"type": "polygon", "points": [[cx, cy+250], [cx-80, cy+300], [cx-40, cy+350], [cx, cy+300]], "color": "#2ECC71", "fill": True, "order": 2},
-                {"type": "polygon", "points": [[cx, cy+200], [cx+80, cy+250], [cx+40, cy+300], [cx, cy+250]], "color": "#2ECC71", "fill": True, "order": 3},
-                # Petals
-                {"type": "circle", "center": [cx, cy-80], "radius": 50, "color": "#E74C3C", "fill": True, "order": 4},
-                {"type": "circle", "center": [cx-70, cy-30], "radius": 50, "color": "#E74C3C", "fill": True, "order": 5},
-                {"type": "circle", "center": [cx+70, cy-30], "radius": 50, "color": "#E74C3C", "fill": True, "order": 6},
-                {"type": "circle", "center": [cx-45, cy+50], "radius": 50, "color": "#E74C3C", "fill": True, "order": 7},
-                {"type": "circle", "center": [cx+45, cy+50], "radius": 50, "color": "#E74C3C", "fill": True, "order": 8},
-                # Center
-                {"type": "circle", "center": [cx, cy], "radius": 40, "color": "#F1C40F", "fill": True, "order": 9},
-            ]
-        }
-    
-    def _star_template(self) -> Dict:
-        """5-point star template"""
-        cx, cy = 540, 700
-        # Calculate star points
-        outer_r = 200
-        inner_r = 80
-        points = []
-        for i in range(10):
-            angle = math.pi/2 + i * math.pi/5
-            r = outer_r if i % 2 == 0 else inner_r
-            x = cx + r * math.cos(angle)
-            y = cy - r * math.sin(angle)
-            points.append([int(x), int(y)])
-        
-        return {
-            "title": "Star",
-            "paths": [
-                {"type": "polygon", "points": points, "color": "#F1C40F", "fill": True, "order": 1},
-                {"type": "polygon", "points": points, "color": "#D4AC0D", "fill": False, "order": 2},
-            ]
-        }
-    
-    def _heart_template(self) -> Dict:
-        """Heart shape template"""
-        cx, cy = 540, 750
-        return {
-            "title": "Heart",
-            "paths": [
-                # Left curve
-                {"type": "arc", "center": [cx-80, cy-80], "radius": 100, "start_angle": 180, "end_angle": 360, "color": "#E74C3C", "width": 8, "order": 1},
-                # Right curve  
-                {"type": "arc", "center": [cx+80, cy-80], "radius": 100, "start_angle": 180, "end_angle": 360, "color": "#E74C3C", "width": 8, "order": 2},
-                # Left line
-                {"type": "line", "start": [cx-180, cy-80], "end": [cx, cy+150], "color": "#E74C3C", "width": 8, "order": 3},
-                # Right line
-                {"type": "line", "start": [cx+180, cy-80], "end": [cx, cy+150], "color": "#E74C3C", "width": 8, "order": 4},
-            ]
-        }
-    
-    def _sun_template(self) -> Dict:
-        """Sun with rays"""
-        cx, cy = 540, 600
-        rays = []
-        for i in range(12):
-            angle = i * math.pi / 6
-            x1 = cx + 120 * math.cos(angle)
-            y1 = cy + 120 * math.sin(angle)
-            x2 = cx + 200 * math.cos(angle)
-            y2 = cy + 200 * math.sin(angle)
-            rays.append({
-                "type": "line",
-                "start": [int(x1), int(y1)],
-                "end": [int(x2), int(y2)],
-                "color": "#F39C12",
-                "width": 6,
-                "order": i + 2
-            })
-        
-        return {
-            "title": "Sun",
-            "paths": [
-                {"type": "circle", "center": [cx, cy], "radius": 100, "color": "#F1C40F", "fill": True, "order": 1},
-                *rays,
-            ]
-        }
-    
-    def _abstract_template(self, prompt: str) -> Dict:
-        """Generate abstract pattern based on prompt"""
-        cx, cy = 540, 800
-        return {
-            "title": prompt[:30],
-            "paths": [
-                {"type": "circle", "center": [cx, cy], "radius": 150, "color": "#3498DB", "fill": True, "order": 1},
-                {"type": "circle", "center": [cx, cy], "radius": 100, "color": "#2ECC71", "fill": True, "order": 2},
-                {"type": "circle", "center": [cx, cy], "radius": 50, "color": "#E74C3C", "fill": True, "order": 3},
-                {"type": "line", "start": [cx-200, cy], "end": [cx+200, cy], "color": "#2C3E50", "width": 4, "order": 4},
-                {"type": "line", "start": [cx, cy-200], "end": [cx, cy+200], "color": "#2C3E50", "width": 4, "order": 5},
-            ]
-        }
-    
-    def hex_to_rgb(self, hex_color: str) -> Tuple[int, int, int]:
-        """Convert hex to RGB"""
-        hex_color = hex_color.lstrip('#')
-        return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
-    
-    def draw_path(self, draw: ImageDraw, path: Dict, progress: float = 1.0):
-        """Draw a single path element"""
-        path_type = path.get("type", "line")
-        color = self.hex_to_rgb(path.get("color", "#000000"))
-        width = path.get("width", 3)
-        fill = path.get("fill", False)
-        
-        if path_type == "line":
-            start = path["start"]
-            end = path["end"]
-            # Partial line based on progress
-            actual_end = [
-                int(start[0] + (end[0] - start[0]) * progress),
-                int(start[1] + (end[1] - start[1]) * progress)
-            ]
-            draw.line([tuple(start), tuple(actual_end)], fill=color, width=width)
-        
-        elif path_type == "circle":
-            center = path["center"]
-            radius = int(path["radius"] * progress)
-            bbox = [center[0]-radius, center[1]-radius, center[0]+radius, center[1]+radius]
-            if fill:
-                draw.ellipse(bbox, fill=color)
-            else:
-                draw.ellipse(bbox, outline=color, width=width)
-        
-        elif path_type == "polygon":
-            points = path["points"]
-            # Draw polygon with progress controlling how many points
-            num_points = max(3, int(len(points) * progress))
-            visible_points = [tuple(p) for p in points[:num_points]]
-            if len(visible_points) >= 3:
-                if fill:
-                    draw.polygon(visible_points, fill=color)
-                else:
-                    draw.polygon(visible_points, outline=color, width=width)
-        
-        elif path_type == "arc":
-            center = path["center"]
-            radius = path["radius"]
-            start_angle = path.get("start_angle", 0)
-            end_angle = path.get("end_angle", 360)
-            # Progress affects the arc sweep
-            actual_end = start_angle + (end_angle - start_angle) * progress
-            bbox = [center[0]-radius, center[1]-radius, center[0]+radius, center[1]+radius]
-            draw.arc(bbox, start_angle, actual_end, fill=color, width=width)
-    
-    def create_frame(self, paths: List[Dict], path_progress: Dict[int, float]) -> Image.Image:
-        """Create a single frame with given path progress"""
-        img = Image.new('RGB', (self.WIDTH, self.HEIGHT), self.BG_COLOR)
-        draw = ImageDraw.Draw(img)
-        
-        # Sort paths by order
-        sorted_paths = sorted(paths, key=lambda p: p.get("order", 0))
-        
-        for path in sorted_paths:
-            order = path.get("order", 0)
-            progress = path_progress.get(order, 0.0)
-            if progress > 0:
-                self.draw_path(draw, path, progress)
-        
-        return img
-    
-    def generate_animation(
-        self,
-        prompt: str,
-        output_dir: str = "temp",
-        frames_per_path: int = 10,
-        fps: int = 30
-    ) -> List[str]:
-        """
-        Generate frame-by-frame drawing animation from prompt.
-        
-        Args:
-            prompt: What to draw
-            output_dir: Directory to save frames
-            frames_per_path: Frames for each path element
-            fps: Target frame rate
-            
-        Returns:
-            List of frame file paths
-        """
-        os.makedirs(output_dir, exist_ok=True)
-        
-        # Generate paths with AI
-        logger.info(f"Generating drawing paths for: {prompt}")
-        drawing = self.generate_paths_with_ai(prompt)
-        
-        paths = drawing.get("paths", [])
-        title = drawing.get("title", prompt)
-        
-        logger.info(f"Drawing '{title}' with {len(paths)} paths")
-        
-        # Sort paths by order
-        sorted_paths = sorted(paths, key=lambda p: p.get("order", 0))
-        
-        frame_paths = []
-        frame_num = 0
-        
-        # Animate each path
-        for path_idx, path in enumerate(sorted_paths):
-            order = path.get("order", path_idx)
-            
-            # Previous paths are complete
-            base_progress = {p.get("order", i): 1.0 for i, p in enumerate(sorted_paths[:path_idx])}
-            
-            # Animate current path
-            for f in range(frames_per_path):
-                progress = (f + 1) / frames_per_path
-                base_progress[order] = progress
-                
-                frame = self.create_frame(paths, base_progress.copy())
-                
-                # Add title
-                draw = ImageDraw.Draw(frame)
-                bbox = draw.textbbox((0, 0), title, font=self.font_title)
-                title_width = bbox[2] - bbox[0]
-                draw.text(((self.WIDTH - title_width) // 2, 100), title, 
-                         fill=(50, 50, 50), font=self.font_title)
-                
-                # Save frame
-                frame_path = os.path.join(output_dir, f"frame_{frame_num:05d}.png")
-                frame.save(frame_path)
-                frame_paths.append(frame_path)
-                frame_num += 1
-        
-        # Hold final frame
-        for _ in range(fps):  # 1 second hold
-            frame_path = os.path.join(output_dir, f"frame_{frame_num:05d}.png")
-            frame.save(frame_path)
-            frame_paths.append(frame_path)
-            frame_num += 1
-        
-        logger.info(f"Generated {len(frame_paths)} animation frames")
-        return frame_paths

modules/art_reels/services/ai_stick_figure.py

@@ -1,663 +0,0 @@
-"""
-AI Stick Figure Generator - AI-Powered Stick Figure Animation with TTS
-Uses Groq AI for scene generation, Kokoro TTS for voice, Whisper for timing
-"""
-import logging
-import os
-import json
-import math
-from PIL import Image, ImageDraw, ImageFont
-from typing import List, Tuple, Dict, Optional
-from groq import Groq
-
-logger = logging.getLogger(__name__)
-
-
-# System prompt for AI scene generation
-SCENE_GENERATION_PROMPT = """You are an AI that converts text into stick figure animation scenes.
-
-For each 2-second chunk of narration, generate a scene description.
-
-OUTPUT FORMAT (JSON array):
-[
-  {
-    "chunk_id": 0,
-    "pose": "standing|walking|running|sitting|sleeping|waving|thinking|jumping|celebrating",
-    "props": ["crown", "money", "book", "phone", "laptop", "coffee", "bed"],
-    "text_overlay": null or "important quote here",
-    "emotion": "happy|sad|thinking|excited|tired|angry",
-    "action": "brief action description"
-  }
-]
-
-RULES:
-1. Match the pose and props to the MEANING of the text
-2. Use text_overlay ONLY for important quotes or key phrases
-3. Be creative with emotions and actions
-4. Keep it simple - stick figures should be expressive but minimal
-
-EXAMPLES:
-- "A rich businessman" → pose: "standing", props: ["money", "suit"], emotion: "happy"
-- "He woke up from sleep" → pose: "sleeping", props: ["bed"], emotion: "tired"
-- "Get ready for success" → pose: "celebrating", props: [], text_overlay: "GET READY!"
-- "Walk like a king" → pose: "walking", props: ["crown"], emotion: "happy"
-"""
-
-
-class AIStickFigure:
-    """
-    AI-Powered Stick Figure Animation Generator.
-    
-    Pipeline:
-    1. Text → TTS → Audio
-    2. Audio → Whisper → 2-second chunks
-    3. Chunks → Groq AI → Scene descriptions
-    4. Scenes → Python Drawing → Frames
-    5. Frames + Audio → Video
-    """
-    
-    # Video dimensions (9:16 portrait)
-    WIDTH = 1080
-    HEIGHT = 1920
-    
-    # Stick figure size
-    HEAD_RADIUS = 50
-    BODY_LENGTH = 150
-    ARM_LENGTH = 100
-    LEG_LENGTH = 120
-    LINE_WIDTH = 10
-    
-    # Colors
-    BG_COLOR = (255, 255, 255)  # White
-    FIGURE_COLOR = (30, 30, 30)  # Near black
-    ACCENT_COLOR = (255, 87, 51)  # Orange accent
-    
-    def __init__(self, groq_api_key: str = None):
-        self.groq_api_key = groq_api_key or os.environ.get("GROQ_API_KEY")
-        if self.groq_api_key:
-            self.groq = Groq(api_key=self.groq_api_key)
-        else:
-            self.groq = None
-            logger.warning("Groq API key not found - AI scene generation disabled")
-    
-    def generate_scenes_with_ai(self, chunks: List[Dict]) -> List[Dict]:
-        """
-        Use Groq AI to generate scene descriptions from text chunks.
-        
-        Args:
-            chunks: List of {chunk_id, text} from Whisper
-            
-        Returns:
-            List of scene descriptions with pose, props, etc.
-        """
-        if not self.groq:
-            # Fallback to keyword-based generation
-            return self._generate_scenes_keyword(chunks)
-        
-        try:
-            # Prepare user prompt
-            chunk_texts = "\n".join([
-                f"Chunk {c['chunk_id']}: \"{c['text']}\""
-                for c in chunks
-            ])
-            
-            user_prompt = f"""Generate stick figure scenes for these narration chunks:
-
-{chunk_texts}
-
-Generate exactly {len(chunks)} scenes, one for each chunk.
-Return ONLY valid JSON array, no other text."""
-
-            response = self.groq.chat.completions.create(
-                model="openai/gpt-oss-120b",
-                messages=[
-                    {"role": "system", "content": SCENE_GENERATION_PROMPT},
-                    {"role": "user", "content": user_prompt}
-                ],
-                temperature=0.7,
-                max_tokens=2000
-            )
-            
-            content = response.choices[0].message.content.strip()
-            
-            # Parse JSON
-            if content.startswith("```"):
-                content = content.split("```")[1]
-                if content.startswith("json"):
-                    content = content[4:]
-            
-            scenes = json.loads(content)
-            logger.info(f"AI generated {len(scenes)} scenes")
-            return scenes
-            
-        except Exception as e:
-            logger.error(f"AI scene generation failed: {e}, using keyword fallback")
-            return self._generate_scenes_keyword(chunks)
-    
-    def _generate_scenes_keyword(self, chunks: List[Dict]) -> List[Dict]:
-        """Fallback keyword-based scene generation"""
-        scenes = []
-        
-        keyword_mapping = {
-            # Poses
-            "sleep": ("sleeping", [], "tired"),
-            "wake": ("sleeping", [], "tired"),
-            "run": ("running", [], "excited"),
-            "running": ("running", [], "excited"),
-            "walk": ("walking", [], "happy"),
-            "walking": ("walking", [], "happy"),
-            "sit": ("sitting", [], "thinking"),
-            "sitting": ("sitting", [], "thinking"),
-            "think": ("thinking", [], "thinking"),
-            "thinking": ("thinking", [], "thinking"),
-            "jump": ("jumping", [], "excited"),
-            "celebrate": ("celebrating", [], "happy"),
-            "success": ("celebrating", [], "excited"),
-            # Props
-            "king": ("standing", ["crown"], "happy"),
-            "queen": ("standing", ["crown"], "happy"),
-            "rich": ("standing", ["money"], "happy"),
-            "wealthy": ("standing", ["money"], "happy"),
-            "money": ("standing", ["money"], "happy"),
-            "dollar": ("standing", ["money"], "happy"),
-            "book": ("sitting", ["book"], "thinking"),
-            "read": ("sitting", ["book"], "thinking"),
-            "phone": ("standing", ["phone"], "happy"),
-            "coffee": ("standing", ["coffee"], "happy"),
-        }
-        
-        for chunk in chunks:
-            text = chunk.get("text", "").lower()
-            pose = "standing"
-            props = []
-            emotion = "happy"
-            text_overlay = None
-            
-            for keyword, (p, pr, em) in keyword_mapping.items():
-                if keyword in text:
-                    pose = p
-                    props = pr
-                    emotion = em
-                    break
-            
-            # Check for text overlay triggers
-            triggers = ["get ready", "remember", "important", "key", "ready", "success"]
-            for trigger in triggers:
-                if trigger in text:
-                    text_overlay = text[:30].upper() if len(text) > 30 else text.upper()
-                    break
-            
-            scenes.append({
-                "chunk_id": chunk.get("chunk_id", 0),
-                "pose": pose,
-                "props": props,
-                "emotion": emotion,
-                "text_overlay": text_overlay,
-                "action": f"Scene for: {text[:50]}"
-            })
-        
-        return scenes
-    
-    def draw_stick_figure(
-        self,
-        draw: ImageDraw,
-        x: int,
-        y: int,
-        pose: str = "standing",
-        emotion: str = "happy",
-        props: List[str] = None,
-        scale: float = 1.0
-    ):
-        """Draw an expressive stick figure"""
-        props = props or []
-        
-        # Scale dimensions
-        head_r = int(self.HEAD_RADIUS * scale)
-        body_len = int(self.BODY_LENGTH * scale)
-        arm_len = int(self.ARM_LENGTH * scale)
-        leg_len = int(self.LEG_LENGTH * scale)
-        line_w = max(4, int(self.LINE_WIDTH * scale))
-        
-        # Pose-specific drawing
-        pose_methods = {
-            "standing": self._draw_standing,
-            "walking": self._draw_walking,
-            "running": self._draw_running,
-            "sitting": self._draw_sitting,
-            "sleeping": self._draw_sleeping,
-            "waving": self._draw_waving,
-            "thinking": self._draw_thinking,
-            "jumping": self._draw_jumping,
-            "celebrating": self._draw_celebrating,
-        }
-        
-        draw_method = pose_methods.get(pose, self._draw_standing)
-        draw_method(draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion)
-        
-        # Draw props
-        for prop in props:
-            self._draw_prop(draw, x, y - body_len - head_r, head_r, prop, scale)
-    
-    def _draw_face(self, draw, x, y, head_r, emotion, line_w):
-        """Draw expressive face"""
-        # Eyes
-        eye_y = y - head_r // 4
-        eye_offset = head_r // 3
-        eye_size = head_r // 5
-        
-        if emotion == "happy":
-            # Happy eyes (curved)
-            draw.arc([x - eye_offset - eye_size, eye_y - eye_size, 
-                     x - eye_offset + eye_size, eye_y + eye_size],
-                    0, 180, fill=self.FIGURE_COLOR, width=line_w//2)
-            draw.arc([x + eye_offset - eye_size, eye_y - eye_size, 
-                     x + eye_offset + eye_size, eye_y + eye_size],
-                    0, 180, fill=self.FIGURE_COLOR, width=line_w//2)
-            # Smile
-            draw.arc([x - head_r//2, y - head_r//4, x + head_r//2, y + head_r//2],
-                    0, 180, fill=self.FIGURE_COLOR, width=line_w//2)
-        elif emotion == "sad":
-            # Sad eyes
-            draw.ellipse([x - eye_offset - eye_size, eye_y - eye_size,
-                         x - eye_offset + eye_size, eye_y + eye_size],
-                        fill=self.FIGURE_COLOR)
-            draw.ellipse([x + eye_offset - eye_size, eye_y - eye_size,
-                         x + eye_offset + eye_size, eye_y + eye_size],
-                        fill=self.FIGURE_COLOR)
-            # Frown
-            draw.arc([x - head_r//2, y, x + head_r//2, y + head_r//2],
-                    180, 360, fill=self.FIGURE_COLOR, width=line_w//2)
-        elif emotion == "thinking":
-            # Thinking eyes (looking up)
-            draw.ellipse([x - eye_offset - eye_size, eye_y - eye_size - 5,
-                         x - eye_offset + eye_size, eye_y + eye_size - 5],
-                        fill=self.FIGURE_COLOR)
-            draw.ellipse([x + eye_offset - eye_size, eye_y - eye_size - 5,
-                         x + eye_offset + eye_size, eye_y + eye_size - 5],
-                        fill=self.FIGURE_COLOR)
-            # Neutral mouth
-            draw.line([x - head_r//3, y + head_r//4, x + head_r//3, y + head_r//4],
-                     fill=self.FIGURE_COLOR, width=line_w//2)
-        elif emotion == "excited":
-            # Big excited eyes
-            big_eye = eye_size * 2
-            draw.ellipse([x - eye_offset - big_eye, eye_y - big_eye,
-                         x - eye_offset + big_eye, eye_y + big_eye],
-                        fill=self.FIGURE_COLOR)
-            draw.ellipse([x + eye_offset - big_eye, eye_y - big_eye,
-                         x + eye_offset + big_eye, eye_y + big_eye],
-                        fill=self.FIGURE_COLOR)
-            # Big smile
-            draw.arc([x - head_r//2, y - head_r//3, x + head_r//2, y + head_r//2],
-                    0, 180, fill=self.FIGURE_COLOR, width=line_w)
-        else:
-            # Default neutral
-            draw.ellipse([x - eye_offset - eye_size, eye_y - eye_size,
-                         x - eye_offset + eye_size, eye_y + eye_size],
-                        fill=self.FIGURE_COLOR)
-            draw.ellipse([x + eye_offset - eye_size, eye_y - eye_size,
-                         x + eye_offset + eye_size, eye_y + eye_size],
-                        fill=self.FIGURE_COLOR)
-            draw.line([x - head_r//3, y + head_r//4, x + head_r//3, y + head_r//4],
-                     fill=self.FIGURE_COLOR, width=line_w//2)
-    
-    def _draw_standing(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw standing pose with expression"""
-        head_y = y - body_len - head_r
-        
-        # Head circle
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, emotion, line_w)
-        
-        # Body
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Arms
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y + arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Legs
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_walking(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw walking pose"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, emotion, line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x + 10, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len//2, arm_y + arm_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y - arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x + 10, body_bottom, x - leg_len, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + 10, body_bottom, x + leg_len, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_running(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw running pose"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x + 20 - head_r, head_y - head_r, x + 20 + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x + 20, head_y, head_r, "excited", line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x + 20, body_top, x + 40, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4 + 20
-        draw.line([x + 20, arm_y, x - arm_len, arm_y + arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + 20, arm_y, x + arm_len + 30, arm_y - arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x + 40, body_bottom, x - leg_len - 20, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + 40, body_bottom, x + leg_len + 40, body_bottom + leg_len//3], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_sitting(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw sitting pose"""
-        y_offset = leg_len // 2
-        head_y = y - body_len - head_r + y_offset
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, emotion, line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len // 2
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 6
-        draw.line([x, arm_y, x - arm_len // 2, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len // 2, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Chair/ground
-        draw.line([x - leg_len, body_bottom, x + leg_len, body_bottom], fill=self.FIGURE_COLOR, width=line_w//2)
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_sleeping(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw horizontal sleeping pose"""
-        # Horizontal figure
-        draw.ellipse([x - body_len - head_r, y - head_r, x - body_len + head_r, y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        
-        # Closed eyes (lines)
-        draw.line([x - body_len - head_r//2, y - head_r//4, x - body_len - head_r//4, y - head_r//4],
-                 fill=self.FIGURE_COLOR, width=line_w//2)
-        draw.line([x - body_len + head_r//4, y - head_r//4, x - body_len + head_r//2, y - head_r//4],
-                 fill=self.FIGURE_COLOR, width=line_w//2)
-        
-        # Body
-        draw.line([x - body_len + head_r, y, x, y], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Legs
-        draw.line([x, y, x + leg_len, y + 10], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, y, x + leg_len, y - 10], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Zzz
-        try:
-            font = ImageFont.truetype("arial.ttf", 40)
-        except:
-            font = ImageFont.load_default()
-        draw.text((x - body_len, y - head_r - 50), "Zzz", fill=(100, 100, 100), font=font)
-        
-        # Bed
-        draw.rectangle([x - body_len - head_r - 20, y + head_r, x + leg_len + 20, y + head_r + 20],
-                      fill=(139, 90, 43))
-    
-    def _draw_waving(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw waving pose"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, "happy", line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        # Waving arm up
-        draw.line([x, arm_y, x + arm_len//2, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
-        # Hand wave lines
-        draw.line([x + arm_len//2 - 10, arm_y - arm_len - 30, x + arm_len//2 + 10, arm_y - arm_len - 20],
-                 fill=self.ACCENT_COLOR, width=3)
-        draw.line([x + arm_len//2 + 15, arm_y - arm_len - 25, x + arm_len//2 + 35, arm_y - arm_len - 15],
-                 fill=self.ACCENT_COLOR, width=3)
-        
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_thinking(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw thinking pose with thought bubble"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, "thinking", line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        # Hand on chin
-        draw.line([x, arm_y, x + arm_len//3, arm_y - arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + arm_len//3, arm_y - arm_len//3, x + head_r//2, head_y + head_r],
-                 fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Thought bubble
-        draw.ellipse([x + head_r + 30, head_y - head_r - 100, x + head_r + 150, head_y - head_r - 20],
-                    outline=self.FIGURE_COLOR, width=3)
-        draw.ellipse([x + head_r + 10, head_y - head_r - 20, x + head_r + 30, head_y - head_r],
-                    fill=self.FIGURE_COLOR)
-    
-    def _draw_jumping(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw jumping pose"""
-        y_offset = -80  # Jump up
-        head_y = y - body_len - head_r + y_offset
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, "excited", line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Arms up
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y - arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y - arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Legs spread
-        draw.line([x, body_bottom, x - leg_len, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Jump lines
-        draw.line([x - 30, body_bottom + leg_len + 30, x + 30, body_bottom + leg_len + 30],
-                 fill=(200, 200, 200), width=4)
-    
-    def _draw_celebrating(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw celebrating pose with confetti"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, "excited", line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Both arms up
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Confetti
-        import random
-        colors = [(255, 87, 51), (255, 195, 0), (76, 175, 80), (33, 150, 243)]
-        for _ in range(10):
-            cx = x + random.randint(-150, 150)
-            cy = head_y + random.randint(-150, 50)
-            color = random.choice(colors)
-            draw.ellipse([cx - 5, cy - 5, cx + 5, cy + 5], fill=color)
-    
-    def _draw_prop(self, draw, x, head_y, head_r, prop: str, scale: float):
-        """Draw props on the figure"""
-        if prop == "crown":
-            crown_y = head_y - head_r - 20
-            points = [
-                (x - 40, crown_y),
-                (x - 25, crown_y - 40),
-                (x, crown_y - 20),
-                (x + 25, crown_y - 40),
-                (x + 40, crown_y)
-            ]
-            draw.polygon(points, fill=(255, 215, 0), outline=(200, 170, 0), width=2)
-        elif prop == "money":
-            bag_x = x + 100
-            bag_y = head_y + 150
-            draw.ellipse([bag_x, bag_y, bag_x + 60, bag_y + 70], fill=(34, 139, 34), outline=(20, 100, 20), width=2)
-            try:
-                font = ImageFont.truetype("arial.ttf", 30)
-            except:
-                font = ImageFont.load_default()
-            draw.text((bag_x + 20, bag_y + 20), "$", fill=(255, 255, 255), font=font)
-        elif prop == "book":
-            book_x = x + 80
-            book_y = head_y + 130
-            draw.rectangle([book_x, book_y, book_x + 50, book_y + 70], fill=(139, 69, 19), outline=(100, 50, 10), width=2)
-            draw.line([book_x + 25, book_y, book_x + 25, book_y + 70], fill=(80, 40, 10), width=2)
-        elif prop == "phone":
-            phone_x = x + 90
-            phone_y = head_y + 100
-            draw.rectangle([phone_x, phone_y, phone_x + 30, phone_y + 50], fill=(50, 50, 50), outline=(30, 30, 30), width=2)
-            draw.rectangle([phone_x + 3, phone_y + 5, phone_x + 27, phone_y + 40], fill=(100, 150, 200))
-        elif prop == "coffee":
-            cup_x = x + 100
-            cup_y = head_y + 120
-            draw.rectangle([cup_x, cup_y, cup_x + 40, cup_y + 50], fill=(255, 255, 255), outline=(200, 200, 200), width=2)
-            draw.arc([cup_x + 30, cup_y + 10, cup_x + 50, cup_y + 40], -90, 90, fill=(200, 200, 200), width=3)
-            # Steam
-            draw.arc([cup_x + 10, cup_y - 20, cup_x + 20, cup_y], 0, 180, fill=(200, 200, 200), width=2)
-            draw.arc([cup_x + 20, cup_y - 25, cup_x + 30, cup_y - 5], 180, 360, fill=(200, 200, 200), width=2)
-    
-    def add_text_overlay(
-        self,
-        img: Image.Image,
-        text: str,
-        position: str = "bottom"
-    ) -> Image.Image:
-        """Add stylish text overlay"""
-        draw = ImageDraw.Draw(img)
-        
-        try:
-            font = ImageFont.truetype("arial.ttf", 70)
-        except:
-            font = ImageFont.load_default()
-        
-        bbox = draw.textbbox((0, 0), text, font=font)
-        text_width = bbox[2] - bbox[0]
-        text_height = bbox[3] - bbox[1]
-        
-        if position == "center":
-            pos = ((self.WIDTH - text_width) // 2, (self.HEIGHT - text_height) // 2)
-        elif position == "top":
-            pos = ((self.WIDTH - text_width) // 2, 150)
-        else:  # bottom
-            pos = ((self.WIDTH - text_width) // 2, self.HEIGHT - 200)
-        
-        # Background box
-        padding = 20
-        draw.rectangle([
-            pos[0] - padding, pos[1] - padding,
-            pos[0] + text_width + padding, pos[1] + text_height + padding
-        ], fill=(0, 0, 0, 180))
-        
-        # Text
-        draw.text(pos, text, fill=(255, 255, 255), font=font,
-                 stroke_width=2, stroke_fill=(0, 0, 0))
-        
-        return img
-    
-    def create_scene_frame(self, scene: Dict) -> Image.Image:
-        """Create a single frame from scene description"""
-        img = Image.new('RGB', (self.WIDTH, self.HEIGHT), self.BG_COLOR)
-        draw = ImageDraw.Draw(img)
-        
-        # Draw figure
-        pose = scene.get("pose", "standing")
-        props = scene.get("props", [])
-        emotion = scene.get("emotion", "happy")
-        
-        self.draw_stick_figure(draw, self.WIDTH // 2, self.HEIGHT // 2 + 150,
-                               pose=pose, emotion=emotion, props=props, scale=1.5)
-        
-        # Add text overlay if present
-        text_overlay = scene.get("text_overlay")
-        if text_overlay:
-            self.add_text_overlay(img, text_overlay)
-        
-        return img
-    
-    def generate_frames_from_scenes(
-        self,
-        scenes: List[Dict],
-        chunk_durations: List[float],
-        output_dir: str,
-        fps: int = 30
-    ) -> List[str]:
-        """
-        Generate frames for all scenes with correct timing.
-        
-        Args:
-            scenes: List of scene descriptions
-            chunk_durations: Duration of each chunk in seconds
-            output_dir: Directory to save frames
-            fps: Frames per second
-            
-        Returns:
-            List of frame file paths
-        """
-        os.makedirs(output_dir, exist_ok=True)
-        frame_paths = []
-        frame_num = 0
-        
-        for i, scene in enumerate(scenes):
-            duration = chunk_durations[i] if i < len(chunk_durations) else 2.0
-            num_frames = int(duration * fps)
-            
-            logger.info(f"Generating {num_frames} frames for scene {i}")
-            
-            # Create scene frame
-            frame = self.create_scene_frame(scene)
-            
-            # Save frames for duration
-            for _ in range(num_frames):
-                frame_path = os.path.join(output_dir, f"frame_{frame_num:05d}.png")
-                frame.save(frame_path)
-                frame_paths.append(frame_path)
-                frame_num += 1
-        
-        logger.info(f"Generated {len(frame_paths)} total frames")
-        return frame_paths

modules/art_reels/services/block_art.py

@@ -1,283 +0,0 @@
-"""
-Block Art - Minecraft-style Isometric Block Drawing
-Pure Python implementation using Pillow
-"""
-import logging
-import math
-from PIL import Image, ImageDraw, ImageFont
-from typing import List, Tuple, Dict
-import os
-
-logger = logging.getLogger(__name__)
-
-
-class BlockArt:
-    """
-    Creates Minecraft-style isometric block art.
-    
-    Features:
-    - Isometric 3D blocks
-    - Multiple block types (wood, stone, grass, etc.)
-    - Frame-by-frame build animation
-    """
-    
-    # Video dimensions (9:16 portrait)
-    WIDTH = 1080
-    HEIGHT = 1920
-    
-    # Block size and offset for isometric projection
-    BLOCK_SIZE = 40
-    
-    # Block colors (top, left, right faces)
-    BLOCK_COLORS = {
-        "oak_wood": {
-            "top": "#8B7355",
-            "left": "#6B5344",
-            "right": "#5A4535"
-        },
-        "stone": {
-            "top": "#8C8C8C",
-            "left": "#6E6E6E",
-            "right": "#5A5A5A"
-        },
-        "cobblestone": {
-            "top": "#7A7A7A",
-            "left": "#5C5C5C",
-            "right": "#4A4A4A"
-        },
-        "grass": {
-            "top": "#4CAF50",
-            "left": "#8B7355",
-            "right": "#6B5344"
-        },
-        "dirt": {
-            "top": "#8B6914",
-            "left": "#6B5010",
-            "right": "#5A420D"
-        },
-        "glass": {
-            "top": "#ADD8E6",
-            "left": "#87CEEB",
-            "right": "#7EC8E3"
-        },
-        "brick": {
-            "top": "#CB4154",
-            "left": "#A33545",
-            "right": "#8B2D3A"
-        },
-        "planks": {
-            "top": "#C4A35A",
-            "left": "#A08040",
-            "right": "#8A6B30"
-        },
-        "roof": {
-            "top": "#8B4513",
-            "left": "#6B3410",
-            "right": "#5A2B0D"
-        }
-    }
-    
-    def __init__(self):
-        self.frames = []
-        
-    def hex_to_rgb(self, hex_color: str) -> Tuple[int, int, int]:
-        """Convert hex color to RGB tuple"""
-        hex_color = hex_color.lstrip('#')
-        return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
-    
-    def iso_to_screen(self, x: int, y: int, z: int) -> Tuple[int, int]:
-        """Convert 3D isometric coordinates to 2D screen position"""
-        # Isometric projection
-        screen_x = self.WIDTH // 2 + (x - y) * (self.BLOCK_SIZE // 2)
-        screen_y = self.HEIGHT // 2 + (x + y) * (self.BLOCK_SIZE // 4) - z * (self.BLOCK_SIZE // 2)
-        return (screen_x, screen_y)
-    
-    def draw_block(self, draw: ImageDraw, x: int, y: int, z: int, block_type: str = "oak_wood"):
-        """Draw a single isometric block"""
-        colors = self.BLOCK_COLORS.get(block_type, self.BLOCK_COLORS["oak_wood"])
-        
-        # Calculate screen position
-        sx, sy = self.iso_to_screen(x, y, z)
-        
-        half = self.BLOCK_SIZE // 2
-        quarter = self.BLOCK_SIZE // 4
-        
-        # Top face (diamond shape)
-        top_points = [
-            (sx, sy - half),           # top
-            (sx + half, sy - quarter), # right
-            (sx, sy),                   # bottom
-            (sx - half, sy - quarter)  # left
-        ]
-        draw.polygon(top_points, fill=self.hex_to_rgb(colors["top"]), outline=(0, 0, 0))
-        
-        # Left face
-        left_points = [
-            (sx - half, sy - quarter), # top
-            (sx, sy),                   # right
-            (sx, sy + half),           # bottom
-            (sx - half, sy + quarter)  # left
-        ]
-        draw.polygon(left_points, fill=self.hex_to_rgb(colors["left"]), outline=(0, 0, 0))
-        
-        # Right face
-        right_points = [
-            (sx, sy),                   # left
-            (sx + half, sy - quarter), # top
-            (sx + half, sy + quarter), # right
-            (sx, sy + half)            # bottom
-        ]
-        draw.polygon(right_points, fill=self.hex_to_rgb(colors["right"]), outline=(0, 0, 0))
-    
-    def generate_simple_house(self) -> List[Dict]:
-        """Generate block positions for a simple house"""
-        blocks = []
-        
-        # Ground/Floor (5x5)
-        for x in range(5):
-            for y in range(5):
-                blocks.append({"x": x, "y": y, "z": 0, "type": "grass"})
-        
-        # Floor (3x3 planks)
-        for x in range(1, 4):
-            for y in range(1, 4):
-                blocks.append({"x": x, "y": y, "z": 1, "type": "planks"})
-        
-        # Walls - Layer 1
-        for x in range(1, 4):
-            blocks.append({"x": x, "y": 0, "z": 2, "type": "oak_wood"})
-            blocks.append({"x": x, "y": 4, "z": 2, "type": "oak_wood"})
-        for y in range(1, 4):
-            blocks.append({"x": 0, "y": y, "z": 2, "type": "oak_wood"})
-            blocks.append({"x": 4, "y": y, "z": 2, "type": "oak_wood"})
-        
-        # Walls - Layer 2
-        for x in range(1, 4):
-            blocks.append({"x": x, "y": 0, "z": 3, "type": "oak_wood"})
-            blocks.append({"x": x, "y": 4, "z": 3, "type": "oak_wood"})
-        for y in range(1, 4):
-            blocks.append({"x": 0, "y": y, "z": 3, "type": "oak_wood"})
-            blocks.append({"x": 4, "y": y, "z": 3, "type": "oak_wood"})
-        
-        # Corner posts
-        for z in [2, 3, 4]:
-            blocks.append({"x": 0, "y": 0, "z": z, "type": "oak_wood"})
-            blocks.append({"x": 4, "y": 0, "z": z, "type": "oak_wood"})
-            blocks.append({"x": 0, "y": 4, "z": z, "type": "oak_wood"})
-            blocks.append({"x": 4, "y": 4, "z": z, "type": "oak_wood"})
-        
-        # Window (glass)
-        blocks.append({"x": 2, "y": 0, "z": 3, "type": "glass"})
-        blocks.append({"x": 2, "y": 4, "z": 3, "type": "glass"})
-        
-        # Roof
-        for x in range(5):
-            for y in range(5):
-                blocks.append({"x": x, "y": y, "z": 5, "type": "roof"})
-        
-        return blocks
-    
-    def create_frame(self, blocks_to_draw: List[Dict], bg_color: str = "#87CEEB") -> Image.Image:
-        """Create a single frame with given blocks"""
-        # Create image with sky blue background
-        img = Image.new('RGB', (self.WIDTH, self.HEIGHT), self.hex_to_rgb(bg_color))
-        draw = ImageDraw.Draw(img)
-        
-        # Sort blocks for proper rendering (back to front, bottom to top)
-        sorted_blocks = sorted(blocks_to_draw, key=lambda b: (b["z"], b["x"] + b["y"]))
-        
-        for block in sorted_blocks:
-            self.draw_block(draw, block["x"], block["y"], block["z"], block["type"])
-        
-        return img
-    
-    def generate_build_animation(
-        self,
-        description: str = "wooden survival house",
-        output_dir: str = "temp",
-        blocks_per_frame: int = 2
-    ) -> List[str]:
-        """
-        Generate frame-by-frame build animation.
-        
-        Args:
-            description: What to build (for future AI integration)
-            output_dir: Directory to save frames
-            blocks_per_frame: How many blocks to add per frame
-            
-        Returns:
-            List of frame file paths
-        """
-        os.makedirs(output_dir, exist_ok=True)
-        
-        # Get house blocks
-        all_blocks = self.generate_simple_house()
-        
-        logger.info(f"Generating animation with {len(all_blocks)} blocks")
-        
-        frame_paths = []
-        frame_num = 0
-        
-        # Generate frames progressively
-        for i in range(0, len(all_blocks), blocks_per_frame):
-            current_blocks = all_blocks[:i + blocks_per_frame]
-            
-            # Create frame
-            frame = self.create_frame(current_blocks)
-            
-            # Add "Building..." text
-            draw = ImageDraw.Draw(frame)
-            try:
-                font = ImageFont.truetype("arial.ttf", 48)
-            except:
-                font = ImageFont.load_default()
-            
-            progress = min(100, int((i + blocks_per_frame) / len(all_blocks) * 100))
-            text = f"Building... {progress}%"
-            
-            # Center text at bottom
-            bbox = draw.textbbox((0, 0), text, font=font)
-            text_width = bbox[2] - bbox[0]
-            draw.text(
-                ((self.WIDTH - text_width) // 2, self.HEIGHT - 150),
-                text,
-                fill=(255, 255, 255),
-                font=font,
-                stroke_width=2,
-                stroke_fill=(0, 0, 0)
-            )
-            
-            # Save frame
-            frame_path = os.path.join(output_dir, f"frame_{frame_num:04d}.png")
-            frame.save(frame_path)
-            frame_paths.append(frame_path)
-            frame_num += 1
-        
-        # Hold final frame for a bit
-        final_frame = self.create_frame(all_blocks)
-        draw = ImageDraw.Draw(final_frame)
-        try:
-            font = ImageFont.truetype("arial.ttf", 60)
-        except:
-            font = ImageFont.load_default()
-        
-        text = "Done! Complete!"
-        bbox = draw.textbbox((0, 0), text, font=font)
-        text_width = bbox[2] - bbox[0]
-        draw.text(
-            ((self.WIDTH - text_width) // 2, self.HEIGHT - 150),
-            text,
-            fill=(76, 175, 80),
-            font=font,
-            stroke_width=2,
-            stroke_fill=(0, 0, 0)
-        )
-        
-        for _ in range(30):  # Hold for 1 second at 30fps
-            frame_path = os.path.join(output_dir, f"frame_{frame_num:04d}.png")
-            final_frame.save(frame_path)
-            frame_paths.append(frame_path)
-            frame_num += 1
-        
-        logger.info(f"Generated {len(frame_paths)} frames")
-        return frame_paths

modules/art_reels/services/drawing_animator.py

@@ -1,303 +0,0 @@
-"""
-Drawing Animator - Line-by-line Code Drawing Animation
-Pure Python implementation using Pillow
-"""
-import logging
-import math
-from PIL import Image, ImageDraw, ImageFont
-from typing import List, Tuple, Dict
-import os
-
-logger = logging.getLogger(__name__)
-
-
-class DrawingAnimator:
-    """
-    Creates line-by-line drawing animations.
-    
-    Features:
-    - Outline drawing animation
-    - Color fill animation
-    - Multiple drawing templates
-    """
-    
-    # Video dimensions (9:16 portrait)
-    WIDTH = 1080
-    HEIGHT = 1920
-    
-    # Colors
-    BG_COLOR = (255, 255, 255)  # White
-    OUTLINE_COLOR = (50, 50, 50)  # Dark gray
-    LINE_WIDTH = 4
-    
-    # Drawing templates
-    TEMPLATES = {
-        "house": {
-            "lines": [
-                # Base rectangle
-                {"start": (340, 1200), "end": (740, 1200), "order": 1},  # bottom
-                {"start": (740, 1200), "end": (740, 800), "order": 2},   # right
-                {"start": (740, 800), "end": (340, 800), "order": 3},    # top
-                {"start": (340, 800), "end": (340, 1200), "order": 4},   # left
-                # Roof
-                {"start": (300, 800), "end": (540, 550), "order": 5},    # left roof
-                {"start": (540, 550), "end": (780, 800), "order": 6},    # right roof
-                # Door
-                {"start": (480, 1200), "end": (480, 1000), "order": 7},
-                {"start": (480, 1000), "end": (600, 1000), "order": 8},
-                {"start": (600, 1000), "end": (600, 1200), "order": 9},
-                # Window
-                {"start": (400, 900), "end": (400, 950), "order": 10},
-                {"start": (400, 950), "end": (460, 950), "order": 11},
-                {"start": (460, 950), "end": (460, 900), "order": 12},
-                {"start": (460, 900), "end": (400, 900), "order": 13},
-            ],
-            "fills": [
-                {"points": [(340, 800), (740, 800), (740, 1200), (340, 1200)], "color": (255, 230, 150), "order": 1},
-                {"points": [(300, 800), (540, 550), (780, 800)], "color": (180, 80, 80), "order": 2},
-                {"points": [(480, 1000), (600, 1000), (600, 1200), (480, 1200)], "color": (139, 90, 43), "order": 3},
-            ]
-        },
-        "tree": {
-            "lines": [
-                # Trunk
-                {"start": (500, 1300), "end": (580, 1300), "order": 1},
-                {"start": (580, 1300), "end": (580, 1000), "order": 2},
-                {"start": (580, 1000), "end": (500, 1000), "order": 3},
-                {"start": (500, 1000), "end": (500, 1300), "order": 4},
-                # Leaves (triangle layers)
-                {"start": (400, 1000), "end": (540, 750), "order": 5},
-                {"start": (540, 750), "end": (680, 1000), "order": 6},
-                {"start": (680, 1000), "end": (400, 1000), "order": 7},
-                {"start": (420, 850), "end": (540, 600), "order": 8},
-                {"start": (540, 600), "end": (660, 850), "order": 9},
-                {"start": (660, 850), "end": (420, 850), "order": 10},
-            ],
-            "fills": [
-                {"points": [(500, 1000), (580, 1000), (580, 1300), (500, 1300)], "color": (139, 90, 43), "order": 1},
-                {"points": [(400, 1000), (540, 750), (680, 1000)], "color": (34, 139, 34), "order": 2},
-                {"points": [(420, 850), (540, 600), (660, 850)], "color": (50, 160, 50), "order": 3},
-            ]
-        },
-        "star": {
-            "lines": [
-                {"start": (540, 600), "end": (580, 750), "order": 1},
-                {"start": (580, 750), "end": (740, 750), "order": 2},
-                {"start": (740, 750), "end": (620, 850), "order": 3},
-                {"start": (620, 850), "end": (680, 1000), "order": 4},
-                {"start": (680, 1000), "end": (540, 900), "order": 5},
-                {"start": (540, 900), "end": (400, 1000), "order": 6},
-                {"start": (400, 1000), "end": (460, 850), "order": 7},
-                {"start": (460, 850), "end": (340, 750), "order": 8},
-                {"start": (340, 750), "end": (500, 750), "order": 9},
-                {"start": (500, 750), "end": (540, 600), "order": 10},
-            ],
-            "fills": [
-                {"points": [(540, 600), (580, 750), (740, 750), (620, 850), (680, 1000), 
-                           (540, 900), (400, 1000), (460, 850), (340, 750), (500, 750)], 
-                 "color": (255, 215, 0), "order": 1},
-            ]
-        },
-        "heart": {
-            "lines": [
-                # Left curve (approximated with lines)
-                {"start": (540, 750), "end": (440, 650), "order": 1},
-                {"start": (440, 650), "end": (380, 700), "order": 2},
-                {"start": (380, 700), "end": (380, 800), "order": 3},
-                {"start": (380, 800), "end": (540, 1000), "order": 4},
-                # Right curve
-                {"start": (540, 750), "end": (640, 650), "order": 5},
-                {"start": (640, 650), "end": (700, 700), "order": 6},
-                {"start": (700, 700), "end": (700, 800), "order": 7},
-                {"start": (700, 800), "end": (540, 1000), "order": 8},
-            ],
-            "fills": [
-                {"points": [(540, 750), (440, 650), (380, 700), (380, 800), (540, 1000),
-                           (700, 800), (700, 700), (640, 650)], 
-                 "color": (255, 100, 100), "order": 1},
-            ]
-        }
-    }
-    
-    def __init__(self):
-        self.frames = []
-    
-    def draw_line_animated(
-        self,
-        start: Tuple[int, int],
-        end: Tuple[int, int],
-        progress: float
-    ) -> Tuple[Tuple[int, int], Tuple[int, int]]:
-        """Calculate partial line based on progress (0.0 to 1.0)"""
-        x1, y1 = start
-        x2, y2 = end
-        
-        current_x = int(x1 + (x2 - x1) * progress)
-        current_y = int(y1 + (y2 - y1) * progress)
-        
-        return (start, (current_x, current_y))
-    
-    def create_frame(
-        self,
-        template_name: str,
-        line_progress: Dict[int, float],  # order -> progress
-        fill_progress: Dict[int, bool]     # order -> filled
-    ) -> Image.Image:
-        """Create a single frame of the drawing animation"""
-        template = self.TEMPLATES.get(template_name, self.TEMPLATES["house"])
-        
-        # Create white background
-        img = Image.new('RGB', (self.WIDTH, self.HEIGHT), self.BG_COLOR)
-        draw = ImageDraw.Draw(img)
-        
-        # Draw completed fills
-        for fill in template.get("fills", []):
-            if fill_progress.get(fill["order"], False):
-                draw.polygon(fill["points"], fill=fill["color"])
-        
-        # Draw lines with progress
-        for line in template["lines"]:
-            order = line["order"]
-            progress = line_progress.get(order, 0.0)
-            
-            if progress > 0:
-                if progress >= 1.0:
-                    # Complete line
-                    draw.line([line["start"], line["end"]], 
-                             fill=self.OUTLINE_COLOR, width=self.LINE_WIDTH)
-                else:
-                    # Partial line
-                    start, end = self.draw_line_animated(
-                        line["start"], line["end"], progress
-                    )
-                    draw.line([start, end], 
-                             fill=self.OUTLINE_COLOR, width=self.LINE_WIDTH)
-        
-        return img
-    
-    def generate_drawing_animation(
-        self,
-        subject: str = "house",
-        output_dir: str = "temp",
-        with_colors: bool = True,
-        frames_per_line: int = 15
-    ) -> List[str]:
-        """
-        Generate frame-by-frame drawing animation.
-        
-        Args:
-            subject: What to draw (house, tree, star, heart)
-            output_dir: Directory to save frames
-            with_colors: Whether to add color fill after outline
-            frames_per_line: Frames per line segment
-            
-        Returns:
-            List of frame file paths
-        """
-        os.makedirs(output_dir, exist_ok=True)
-        
-        template_name = subject.lower()
-        if template_name not in self.TEMPLATES:
-            template_name = "house"
-        
-        template = self.TEMPLATES[template_name]
-        lines = sorted(template["lines"], key=lambda x: x["order"])
-        fills = sorted(template.get("fills", []), key=lambda x: x["order"])
-        
-        frame_paths = []
-        frame_num = 0
-        
-        # Track progress
-        line_progress = {}
-        fill_progress = {}
-        
-        # Animate each line
-        for line in lines:
-            order = line["order"]
-            
-            for i in range(frames_per_line):
-                progress = (i + 1) / frames_per_line
-                line_progress[order] = progress
-                
-                # Create frame
-                frame = self.create_frame(template_name, line_progress, fill_progress)
-                
-                # Add "Drawing..." text
-                draw = ImageDraw.Draw(frame)
-                try:
-                    font = ImageFont.truetype("arial.ttf", 40)
-                except:
-                    font = ImageFont.load_default()
-                
-                text = f"Drawing {subject.title()}..."
-                bbox = draw.textbbox((0, 0), text, font=font)
-                text_width = bbox[2] - bbox[0]
-                draw.text(
-                    ((self.WIDTH - text_width) // 2, self.HEIGHT - 150),
-                    text,
-                    fill=(100, 100, 100),
-                    font=font
-                )
-                
-                frame_path = os.path.join(output_dir, f"frame_{frame_num:04d}.png")
-                frame.save(frame_path)
-                frame_paths.append(frame_path)
-                frame_num += 1
-        
-        # Animate color fills
-        if with_colors and fills:
-            for fill in fills:
-                fill_progress[fill["order"]] = True
-                
-                # Hold each fill for some frames
-                for _ in range(20):
-                    frame = self.create_frame(template_name, line_progress, fill_progress)
-                    
-                    draw = ImageDraw.Draw(frame)
-                    try:
-                        font = ImageFont.truetype("arial.ttf", 40)
-                    except:
-                        font = ImageFont.load_default()
-                    
-                    text = "Adding colors..."
-                    bbox = draw.textbbox((0, 0), text, font=font)
-                    text_width = bbox[2] - bbox[0]
-                    draw.text(
-                        ((self.WIDTH - text_width) // 2, self.HEIGHT - 150),
-                        text,
-                        fill=(100, 100, 100),
-                        font=font
-                    )
-                    
-                    frame_path = os.path.join(output_dir, f"frame_{frame_num:04d}.png")
-                    frame.save(frame_path)
-                    frame_paths.append(frame_path)
-                    frame_num += 1
-        
-        # Final frame with "Complete!"
-        for _ in range(45):  # 1.5 seconds
-            frame = self.create_frame(template_name, line_progress, fill_progress)
-            
-            draw = ImageDraw.Draw(frame)
-            try:
-                font = ImageFont.truetype("arial.ttf", 60)
-            except:
-                font = ImageFont.load_default()
-            
-            text = "Done! Complete!"
-            bbox = draw.textbbox((0, 0), text, font=font)
-            text_width = bbox[2] - bbox[0]
-            draw.text(
-                ((self.WIDTH - text_width) // 2, self.HEIGHT - 150),
-                text,
-                fill=(76, 175, 80),
-                font=font
-            )
-            
-            frame_path = os.path.join(output_dir, f"frame_{frame_num:04d}.png")
-            frame.save(frame_path)
-            frame_paths.append(frame_path)
-            frame_num += 1
-        
-        logger.info(f"Generated {len(frame_paths)} frames for drawing animation")
-        return frame_paths

modules/art_reels/services/professional_stick_figure.py

@@ -1,1086 +0,0 @@
-"""
-Professional Stick Figure Animation System
-Whiteboard-style animation with multiple characters, backgrounds, and visual metaphors
-"""
-import logging
-import os
-import json
-import math
-import random
-from PIL import Image, ImageDraw, ImageFont
-from typing import List, Tuple, Dict, Optional
-from groq import Groq
-
-logger = logging.getLogger(__name__)
-
-
-# Enhanced AI System Prompt for professional scene generation
-PROFESSIONAL_SCENE_PROMPT = """You are an AI that creates professional whiteboard animation scenes.
-
-For each 2-second narration chunk, generate a detailed scene description.
-
-SCENE TYPES:
-- "title": Text on white background (for introductions, key terms)
-- "single": One character doing something
-- "dual": Two characters interacting
-- "multi": 3+ characters in a scene
-- "metaphor": Visual metaphor (bridge, rope, handshake)
-- "chart": Show a simple graph or comparison
-
-BACKGROUNDS:
-- "white": Default clean background
-- "blackboard": Teacher/education scene
-- "office": Work/business scene
-- "outdoor": Nature, street, park
-- "room": Indoor with furniture
-
-POSES: standing, walking, running, sitting, sleeping, waving, thinking, jumping, celebrating, pointing, talking
-
-EMOTIONS: happy, sad, thinking, excited, tired, angry, surprised, confused
-
-INTERACTIONS (for dual/multi scenes):
-- "handshake": Agreement/cooperation
-- "tug_of_war": Conflict/competition
-- "conversation": Talking to each other
-- "helping": One helping another
-- "fighting": Conflict
-
-OUTPUT FORMAT (JSON array):
-[
-  {
-    "chunk_id": 0,
-    "scene_type": "title|single|dual|multi|metaphor|chart",
-    "background": "white|blackboard|office|outdoor|room",
-    "title_text": "Main Title Here" or null,
-    "subtitle_text": "Subtitle here" or null,
-    "characters": [
-      {
-        "position": "left|center|right",
-        "pose": "standing|walking|etc",
-        "emotion": "happy|sad|etc",
-        "props": ["crown", "book", etc],
-        "thought_bubble": "What they are thinking" or null,
-        "label": "Teacher" or null
-      }
-    ],
-    "metaphor": "bridge|rope|scale|chart" or null,
-    "metaphor_state": "intact|breaking|balanced" or null,
-    "caption": "Short caption text for this scene"
-  }
-]
-
-RULES:
-1. Match scenes to narration MEANING - use visual metaphors
-2. Use title scenes for new concepts (like "Prisoner's Dilemma")
-3. Use dual scenes for comparisons and interactions
-4. Add thought bubbles for internal decisions
-5. Always include a short caption summarizing the scene
-6. Be creative with visual storytelling
-
-EXAMPLES:
-- "Game theory explained" -> title scene with "GAME THEORY" as title
-- "Two prisoners are questioned" -> dual scene with jail background, both sitting
-- "They must decide to cooperate or betray" -> dual with thought bubbles "Silent?" vs "Betray?"
-- "One cuts the bridge" -> metaphor scene with bridge breaking
-"""
-
-
-class ProfessionalStickFigure:
-    """
-    Professional Whiteboard Animation System.
-    
-    Features:
-    - Multiple characters with positions
-    - Scene backgrounds
-    - Title screens
-    - Thought bubbles
-    - Visual metaphors
-    - Captions with proper styling
-    """
-    
-    # Video dimensions (9:16 portrait)
-    WIDTH = 1080
-    HEIGHT = 1920
-    
-    # Stick figure dimensions
-    HEAD_RADIUS = 40
-    BODY_LENGTH = 120
-    ARM_LENGTH = 80
-    LEG_LENGTH = 100
-    LINE_WIDTH = 8
-    
-    # Professional color scheme (black & white with accents)
-    BG_COLOR = (255, 255, 255)          # White
-    FIGURE_COLOR = (30, 30, 30)          # Near black
-    ACCENT_COLOR = (41, 128, 185)        # Professional blue
-    TITLE_COLOR = (44, 62, 80)           # Dark blue-gray
-    CAPTION_BG = (0, 0, 0)               # Black
-    CAPTION_TEXT = (255, 255, 255)       # White
-    THOUGHT_BG = (245, 245, 245)         # Light gray
-    HIGHLIGHT = (231, 76, 60)            # Red for emphasis
-    
-    # Character positions (x coordinates)
-    POSITIONS = {
-        "left": 270,
-        "center": 540,
-        "right": 810
-    }
-    
-    # Character Y base
-    CHARACTER_Y = 1100
-    
-    def __init__(self, groq_api_key: str = None):
-        # Try both GROQ_API (config) and GROQ_API_KEY env vars
-        self.groq_api_key = groq_api_key or os.environ.get("GROQ_API") or os.environ.get("GROQ_API_KEY")
-        if self.groq_api_key:
-            self.groq = Groq(api_key=self.groq_api_key)
-            logger.info("Groq API initialized for AI scene generation")
-        else:
-            self.groq = None
-            logger.warning("Groq API key not found (GROQ_API or GROQ_API_KEY) - AI scene generation disabled")
-        
-        # Load fonts
-        self._load_fonts()
-    
-    def _load_fonts(self):
-        """Load fonts with fallbacks"""
-        try:
-            self.font_title = ImageFont.truetype("arial.ttf", 72)
-            self.font_subtitle = ImageFont.truetype("arial.ttf", 48)
-            self.font_caption = ImageFont.truetype("arial.ttf", 42)
-            self.font_thought = ImageFont.truetype("arial.ttf", 32)
-            self.font_label = ImageFont.truetype("arial.ttf", 28)
-        except:
-            self.font_title = ImageFont.load_default()
-            self.font_subtitle = ImageFont.load_default()
-            self.font_caption = ImageFont.load_default()
-            self.font_thought = ImageFont.load_default()
-            self.font_label = ImageFont.load_default()
-    
-    # ==========================================
-    # AI SCENE GENERATION
-    # ==========================================
-    
-    def generate_scenes_with_ai(self, chunks: List[Dict]) -> List[Dict]:
-        """Generate professional scene descriptions using AI"""
-        if not self.groq:
-            return self._generate_fallback_scenes(chunks)
-        
-        try:
-            chunk_texts = "\n".join([
-                f"Chunk {c.get('chunk_id', i)}: \"{c.get('text', '')}\""
-                for i, c in enumerate(chunks)
-            ])
-            
-            user_prompt = f"""Create professional whiteboard animation scenes for:
-
-{chunk_texts}
-
-Generate exactly {len(chunks)} scenes. Return ONLY valid JSON array."""
-
-            response = self.groq.chat.completions.create(
-                model="openai/gpt-oss-120b",
-                messages=[
-                    {"role": "system", "content": PROFESSIONAL_SCENE_PROMPT},
-                    {"role": "user", "content": user_prompt}
-                ],
-                temperature=0.7,
-                max_tokens=4000
-            )
-            
-            content = response.choices[0].message.content.strip()
-            
-            # Parse JSON
-            if "```" in content:
-                content = content.split("```")[1]
-                if content.startswith("json"):
-                    content = content[4:]
-            
-            scenes = json.loads(content)
-            logger.info(f"AI generated {len(scenes)} professional scenes")
-            return scenes
-            
-        except Exception as e:
-            logger.error(f"AI scene generation failed: {e}")
-            return self._generate_fallback_scenes(chunks)
-    
-    def _generate_fallback_scenes(self, chunks: List[Dict]) -> List[Dict]:
-        """Fallback scene generation with varied poses and emotions"""
-        scenes = []
-        
-        # Pose keywords for text detection
-        pose_keywords = {
-            "walking": ["walk", "walked", "forward", "step", "move", "journey"],
-            "running": ["run", "ran", "fast", "quick", "rush", "hurry"],
-            "sitting": ["sit", "sat", "rest", "relax", "seat", "chair"],
-            "sleeping": ["sleep", "slept", "tired", "exhausted", "rest", "night"],
-            "thinking": ["think", "thought", "wonder", "consider", "decide", "choice"],
-            "jumping": ["jump", "leap", "excited", "joy", "success", "win"],
-            "celebrating": ["celebrate", "success", "victory", "won", "achieve", "happy"],
-            "pointing": ["point", "show", "look", "direction", "this", "that"],
-            "talking": ["said", "told", "speak", "talk", "explain", "teach"],
-            "waving": ["hello", "hi", "bye", "goodbye", "wave", "greeting"]
-        }
-        
-        # Emotion keywords
-        emotion_keywords = {
-            "happy": ["happy", "joy", "success", "win", "good", "great", "smile"],
-            "sad": ["sad", "fail", "failed", "lost", "wrong", "bad", "sorry"],
-            "thinking": ["think", "wonder", "decide", "choose", "question"],
-            "excited": ["excited", "wow", "amazing", "incredible", "jump", "celebrate"],
-            "surprised": ["surprise", "shock", "unexpected", "suddenly"],
-            "confused": ["confused", "wonder", "how", "why", "what"]
-        }
-        
-        # Default poses for variety cycling
-        default_poses = ["standing", "walking", "pointing", "thinking", "talking", "waving"]
-        default_emotions = ["happy", "thinking", "excited", "happy"]
-        
-        for i, chunk in enumerate(chunks):
-            text = chunk.get("text", "").lower()
-            
-            # Detect pose from text
-            detected_pose = None
-            for pose, keywords in pose_keywords.items():
-                if any(kw in text for kw in keywords):
-                    detected_pose = pose
-                    break
-            
-            # If no pose detected, cycle through defaults
-            if not detected_pose:
-                detected_pose = default_poses[i % len(default_poses)]
-            
-            # Detect emotion from text
-            detected_emotion = None
-            for emotion, keywords in emotion_keywords.items():
-                if any(kw in text for kw in keywords):
-                    detected_emotion = emotion
-                    break
-            
-            # If no emotion detected, cycle through defaults
-            if not detected_emotion:
-                detected_emotion = default_emotions[i % len(default_emotions)]
-            
-            # Detect scene type
-            scene_type = "single"
-            if any(word in text for word in ["vs", "versus", "compare", "between", "both", "two"]):
-                scene_type = "dual"
-            elif any(word in text for word in ["introduce", "what is", "explained", "definition"]):
-                scene_type = "title"
-            
-            # Build scene
-            scene = {
-                "chunk_id": i,
-                "scene_type": scene_type,
-                "background": "white",
-                "title_text": text[:30].upper() if scene_type == "title" else None,
-                "characters": [
-                    {
-                        "position": "center", 
-                        "pose": detected_pose, 
-                        "emotion": detected_emotion, 
-                        "props": []
-                    }
-                ] if scene_type != "title" else [],
-                "caption": text[:50] + "..." if len(text) > 50 else text
-            }
-            
-            scenes.append(scene)
-            logger.info(f"Fallback scene {i}: pose={detected_pose}, emotion={detected_emotion}")
-        
-        return scenes
-    
-    # ==========================================
-    # BACKGROUND DRAWING
-    # ==========================================
-    
-    def draw_background(self, draw: ImageDraw, bg_type: str = "white"):
-        """Draw scene background"""
-        if bg_type == "blackboard":
-            # Green chalkboard
-            draw.rectangle([0, 0, self.WIDTH, self.HEIGHT], fill=(34, 49, 39))
-            # Frame
-            draw.rectangle([30, 200, self.WIDTH - 30, 900], 
-                          outline=(139, 90, 43), width=15)
-            draw.rectangle([40, 210, self.WIDTH - 40, 890], 
-                          fill=(40, 68, 50))
-        
-        elif bg_type == "office":
-            # Light gray wall
-            draw.rectangle([0, 0, self.WIDTH, self.HEIGHT], fill=(240, 240, 240))
-            # Floor
-            draw.rectangle([0, 1400, self.WIDTH, self.HEIGHT], fill=(180, 150, 120))
-            # Simple desk
-            draw.rectangle([200, 1200, 880, 1250], fill=(139, 90, 43))
-            draw.rectangle([250, 1250, 300, 1400], fill=(100, 65, 30))
-            draw.rectangle([780, 1250, 830, 1400], fill=(100, 65, 30))
-        
-        elif bg_type == "outdoor":
-            # Sky gradient (simplified)
-            draw.rectangle([0, 0, self.WIDTH, 600], fill=(135, 206, 235))
-            # Ground
-            draw.rectangle([0, 1400, self.WIDTH, self.HEIGHT], fill=(76, 153, 0))
-            # Sun
-            draw.ellipse([850, 100, 1000, 250], fill=(255, 223, 0))
-        
-        elif bg_type == "room":
-            # Wall
-            draw.rectangle([0, 0, self.WIDTH, self.HEIGHT], fill=(255, 248, 240))
-            # Floor
-            draw.rectangle([0, 1400, self.WIDTH, self.HEIGHT], fill=(139, 119, 101))
-        
-        # Default white - no additional drawing needed
-    
-    # ==========================================
-    # TITLE SCREEN
-    # ==========================================
-    
-    def draw_title_screen(
-        self,
-        img: Image.Image,
-        title: str,
-        subtitle: str = None
-    ):
-        """Draw professional title screen"""
-        draw = ImageDraw.Draw(img)
-        
-        # Main title
-        bbox = draw.textbbox((0, 0), title, font=self.font_title)
-        title_width = bbox[2] - bbox[0]
-        title_x = (self.WIDTH - title_width) // 2
-        title_y = self.HEIGHT // 2 - 100
-        
-        # Draw title with underline
-        draw.text((title_x, title_y), title, fill=self.TITLE_COLOR, font=self.font_title)
-        
-        # Underline
-        draw.line([title_x, title_y + 90, title_x + title_width, title_y + 90],
-                 fill=self.ACCENT_COLOR, width=4)
-        
-        # Subtitle if provided
-        if subtitle:
-            bbox = draw.textbbox((0, 0), subtitle, font=self.font_subtitle)
-            sub_width = bbox[2] - bbox[0]
-            sub_x = (self.WIDTH - sub_width) // 2
-            draw.text((sub_x, title_y + 120), subtitle, 
-                     fill=(100, 100, 100), font=self.font_subtitle)
-    
-    # ==========================================
-    # CAPTION (Bottom Bar)
-    # ==========================================
-    
-    def draw_caption(
-        self,
-        img: Image.Image,
-        caption: str,
-        position: str = "bottom"
-    ):
-        """Draw professional caption bar"""
-        if not caption:
-            return
-        
-        draw = ImageDraw.Draw(img)
-        
-        # Caption background
-        caption_height = 120
-        if position == "bottom":
-            caption_y = self.HEIGHT - caption_height - 50
-        else:
-            caption_y = 50
-        
-        # Semi-transparent background
-        draw.rectangle([40, caption_y, self.WIDTH - 40, caption_y + caption_height],
-                      fill=(0, 0, 0), outline=None)
-        
-        # Text
-        bbox = draw.textbbox((0, 0), caption, font=self.font_caption)
-        text_width = bbox[2] - bbox[0]
-        text_x = (self.WIDTH - text_width) // 2
-        text_y = caption_y + (caption_height - 42) // 2
-        
-        draw.text((text_x, text_y), caption, fill=self.CAPTION_TEXT, font=self.font_caption)
-    
-    # ==========================================
-    # THOUGHT BUBBLE
-    # ==========================================
-    
-    def draw_thought_bubble(
-        self,
-        draw: ImageDraw,
-        x: int,
-        y: int,
-        text: str,
-        direction: str = "right"
-    ):
-        """Draw thought bubble with text"""
-        # Bubble dimensions
-        padding = 20
-        bbox = draw.textbbox((0, 0), text, font=self.font_thought)
-        text_width = bbox[2] - bbox[0]
-        text_height = bbox[3] - bbox[1]
-        
-        bubble_width = text_width + padding * 2
-        bubble_height = text_height + padding * 2
-        
-        # Position bubble
-        if direction == "right":
-            bubble_x = x + 30
-        else:
-            bubble_x = x - bubble_width - 30
-        bubble_y = y - 150
-        
-        # Draw bubble (ellipse)
-        draw.ellipse([bubble_x, bubble_y, bubble_x + bubble_width, bubble_y + bubble_height],
-                    fill=self.THOUGHT_BG, outline=self.FIGURE_COLOR, width=2)
-        
-        # Small circles leading to head
-        for i, offset in enumerate([(15, 40), (8, 60), (3, 75)]):
-            size = 12 - i * 3
-            cx = x + (offset[0] if direction == "right" else -offset[0])
-            cy = y - 80 + offset[1]
-            draw.ellipse([cx - size, cy - size, cx + size, cy + size],
-                        fill=self.THOUGHT_BG, outline=self.FIGURE_COLOR, width=2)
-        
-        # Text
-        draw.text((bubble_x + padding, bubble_y + padding), text,
-                 fill=self.FIGURE_COLOR, font=self.font_thought)
-    
-    # ==========================================
-    # STICK FIGURE DRAWING
-    # ==========================================
-    
-    def draw_stick_figure(
-        self,
-        draw: ImageDraw,
-        x: int,
-        y: int,
-        pose: str = "standing",
-        emotion: str = "happy",
-        props: List[str] = None,
-        scale: float = 1.0,
-        facing: str = "front"  # front, left, right
-    ):
-        """Draw expressive stick figure"""
-        props = props or []
-        
-        # Scale dimensions
-        head_r = int(self.HEAD_RADIUS * scale)
-        body_len = int(self.BODY_LENGTH * scale)
-        arm_len = int(self.ARM_LENGTH * scale)
-        leg_len = int(self.LEG_LENGTH * scale)
-        line_w = max(4, int(self.LINE_WIDTH * scale))
-        
-        # Draw based on pose
-        pose_methods = {
-            "standing": self._draw_standing,
-            "walking": self._draw_walking,
-            "running": self._draw_running,
-            "sitting": self._draw_sitting,
-            "sleeping": self._draw_sleeping,
-            "waving": self._draw_waving,
-            "thinking": self._draw_thinking,
-            "jumping": self._draw_jumping,
-            "celebrating": self._draw_celebrating,
-            "pointing": self._draw_pointing,
-            "talking": self._draw_talking,
-        }
-        
-        draw_method = pose_methods.get(pose, self._draw_standing)
-        draw_method(draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion)
-        
-        # Draw props
-        for prop in props:
-            self._draw_prop(draw, x, y - body_len - head_r, head_r, prop, scale)
-    
-    def _draw_face(self, draw, x, y, head_r, emotion, line_w):
-        """Draw expressive face"""
-        eye_y = y - head_r // 4
-        eye_offset = head_r // 3
-        eye_size = head_r // 5
-        
-        if emotion == "happy":
-            # Happy curved eyes
-            draw.arc([x - eye_offset - eye_size, eye_y - eye_size, 
-                     x - eye_offset + eye_size, eye_y + eye_size],
-                    0, 180, fill=self.FIGURE_COLOR, width=line_w//2)
-            draw.arc([x + eye_offset - eye_size, eye_y - eye_size, 
-                     x + eye_offset + eye_size, eye_y + eye_size],
-                    0, 180, fill=self.FIGURE_COLOR, width=line_w//2)
-            # Smile
-            draw.arc([x - head_r//2, y - head_r//4, x + head_r//2, y + head_r//2],
-                    0, 180, fill=self.FIGURE_COLOR, width=line_w//2)
-        
-        elif emotion == "sad":
-            draw.ellipse([x - eye_offset - eye_size, eye_y - eye_size,
-                         x - eye_offset + eye_size, eye_y + eye_size],
-                        fill=self.FIGURE_COLOR)
-            draw.ellipse([x + eye_offset - eye_size, eye_y - eye_size,
-                         x + eye_offset + eye_size, eye_y + eye_size],
-                        fill=self.FIGURE_COLOR)
-            # Frown
-            draw.arc([x - head_r//2, y, x + head_r//2, y + head_r//2],
-                    180, 360, fill=self.FIGURE_COLOR, width=line_w//2)
-        
-        elif emotion == "thinking":
-            draw.ellipse([x - eye_offset - eye_size, eye_y - eye_size - 5,
-                         x - eye_offset + eye_size, eye_y + eye_size - 5],
-                        fill=self.FIGURE_COLOR)
-            draw.ellipse([x + eye_offset - eye_size, eye_y - eye_size - 5,
-                         x + eye_offset + eye_size, eye_y + eye_size - 5],
-                        fill=self.FIGURE_COLOR)
-            # Neutral
-            draw.line([x - head_r//3, y + head_r//4, x + head_r//3, y + head_r//4],
-                     fill=self.FIGURE_COLOR, width=line_w//2)
-        
-        elif emotion == "excited":
-            big_eye = eye_size * 2
-            draw.ellipse([x - eye_offset - big_eye, eye_y - big_eye,
-                         x - eye_offset + big_eye, eye_y + big_eye],
-                        fill=self.FIGURE_COLOR)
-            draw.ellipse([x + eye_offset - big_eye, eye_y - big_eye,
-                         x + eye_offset + big_eye, eye_y + big_eye],
-                        fill=self.FIGURE_COLOR)
-            draw.arc([x - head_r//2, y - head_r//3, x + head_r//2, y + head_r//2],
-                    0, 180, fill=self.FIGURE_COLOR, width=line_w)
-        
-        elif emotion == "surprised":
-            # Wide eyes
-            draw.ellipse([x - eye_offset - eye_size*2, eye_y - eye_size*2,
-                         x - eye_offset + eye_size*2, eye_y + eye_size*2],
-                        outline=self.FIGURE_COLOR, width=line_w//2)
-            draw.ellipse([x + eye_offset - eye_size*2, eye_y - eye_size*2,
-                         x + eye_offset + eye_size*2, eye_y + eye_size*2],
-                        outline=self.FIGURE_COLOR, width=line_w//2)
-            # O mouth
-            draw.ellipse([x - head_r//4, y + head_r//8, x + head_r//4, y + head_r//2],
-                        outline=self.FIGURE_COLOR, width=line_w//2)
-        
-        else:
-            # Default neutral
-            draw.ellipse([x - eye_offset - eye_size, eye_y - eye_size,
-                         x - eye_offset + eye_size, eye_y + eye_size],
-                        fill=self.FIGURE_COLOR)
-            draw.ellipse([x + eye_offset - eye_size, eye_y - eye_size,
-                         x + eye_offset + eye_size, eye_y + eye_size],
-                        fill=self.FIGURE_COLOR)
-            draw.line([x - head_r//3, y + head_r//4, x + head_r//3, y + head_r//4],
-                     fill=self.FIGURE_COLOR, width=line_w//2)
-    
-    def _draw_standing(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw standing pose"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, emotion, line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y + arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_walking(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw walking pose"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, emotion, line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x + 10, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len//2, arm_y + arm_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y - arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x + 10, body_bottom, x - leg_len, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + 10, body_bottom, x + leg_len, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_running(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw running pose"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x + 20 - head_r, head_y - head_r, x + 20 + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x + 20, head_y, head_r, "excited", line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x + 20, body_top, x + 40, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4 + 20
-        draw.line([x + 20, arm_y, x - arm_len, arm_y + arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + 20, arm_y, x + arm_len + 30, arm_y - arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x + 40, body_bottom, x - leg_len - 20, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + 40, body_bottom, x + leg_len + 40, body_bottom + leg_len//3], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_sitting(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw sitting pose"""
-        y_offset = leg_len // 2
-        head_y = y - body_len - head_r + y_offset
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, emotion, line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len // 2
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 6
-        draw.line([x, arm_y, x - arm_len // 2, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len // 2, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Chair
-        draw.line([x - leg_len, body_bottom, x + leg_len, body_bottom], fill=self.FIGURE_COLOR, width=line_w//2)
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_sleeping(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw sleeping pose (horizontal)"""
-        draw.ellipse([x - body_len - head_r, y - head_r, x - body_len + head_r, y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        
-        # Closed eyes
-        draw.line([x - body_len - head_r//2, y - head_r//4, x - body_len - head_r//4, y - head_r//4],
-                 fill=self.FIGURE_COLOR, width=line_w//2)
-        draw.line([x - body_len + head_r//4, y - head_r//4, x - body_len + head_r//2, y - head_r//4],
-                 fill=self.FIGURE_COLOR, width=line_w//2)
-        
-        draw.line([x - body_len + head_r, y, x, y], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, y, x + leg_len, y + 10], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, y, x + leg_len, y - 10], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Zzz
-        draw.text((x - body_len, y - head_r - 50), "Zzz", fill=(150, 150, 150), font=self.font_label)
-        
-        # Bed
-        draw.rectangle([x - body_len - head_r - 20, y + head_r, x + leg_len + 20, y + head_r + 20],
-                      fill=(139, 90, 43))
-    
-    def _draw_waving(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw waving pose"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, "happy", line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len//2, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Wave lines
-        draw.line([x + arm_len//2 - 10, arm_y - arm_len - 30, x + arm_len//2 + 10, arm_y - arm_len - 20],
-                 fill=self.ACCENT_COLOR, width=3)
-        
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_thinking(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw thinking pose"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, "thinking", line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        # Hand on chin
-        draw.line([x, arm_y, x + arm_len//3, arm_y - arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + arm_len//3, arm_y - arm_len//3, x + head_r//2, head_y + head_r],
-                 fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_jumping(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw jumping pose"""
-        y_offset = -80
-        head_y = y - body_len - head_r + y_offset
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, "excited", line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y - arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y - arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x, body_bottom, x - leg_len, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len, body_bottom + leg_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Jump line
-        draw.line([x - 30, body_bottom + leg_len + 30, x + 30, body_bottom + leg_len + 30],
-                 fill=(200, 200, 200), width=4)
-    
-    def _draw_celebrating(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw celebrating pose"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, "excited", line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Confetti
-        colors = [(255, 87, 51), (255, 195, 0), (76, 175, 80), (33, 150, 243)]
-        for _ in range(8):
-            cx = x + random.randint(-120, 120)
-            cy = head_y + random.randint(-120, 40)
-            color = random.choice(colors)
-            draw.ellipse([cx - 4, cy - 4, cx + 4, cy + 4], fill=color)
-    
-    def _draw_pointing(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw pointing pose"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        self._draw_face(draw, x, head_y, head_r, emotion, line_w)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//3], fill=self.FIGURE_COLOR, width=line_w)
-        # Pointing arm
-        draw.line([x, arm_y, x + arm_len + 20, arm_y - arm_len//2], fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_talking(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w, emotion):
-        """Draw talking pose with speech lines"""
-        head_y = y - body_len - head_r
-        
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r],
-                    outline=self.FIGURE_COLOR, width=line_w)
-        
-        # Open mouth
-        eye_y = head_y - head_r // 4
-        eye_offset = head_r // 3
-        eye_size = head_r // 5
-        draw.ellipse([x - eye_offset - eye_size, eye_y - eye_size,
-                     x - eye_offset + eye_size, eye_y + eye_size],
-                    fill=self.FIGURE_COLOR)
-        draw.ellipse([x + eye_offset - eye_size, eye_y - eye_size,
-                     x + eye_offset + eye_size, eye_y + eye_size],
-                    fill=self.FIGURE_COLOR)
-        # Talking mouth
-        draw.ellipse([x - head_r//3, head_y + head_r//6, x + head_r//3, head_y + head_r//2],
-                    outline=self.FIGURE_COLOR, width=line_w//2)
-        
-        # Speech lines
-        for i in range(3):
-            sx = x + head_r + 10 + i * 15
-            sy = head_y - 10 + i * 5
-            draw.line([sx, sy, sx + 20, sy], fill=(150, 150, 150), width=3)
-        
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len//4], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y + arm_len//4], fill=self.FIGURE_COLOR, width=line_w)
-        
-        draw.line([x, body_bottom, x - leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len//2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-    
-    # ==========================================
-    # PROPS DRAWING
-    # ==========================================
-    
-    def _draw_prop(self, draw, x, head_y, head_r, prop: str, scale: float):
-        """Draw props"""
-        if prop == "crown":
-            crown_y = head_y - head_r - 15
-            points = [
-                (x - 35, crown_y),
-                (x - 20, crown_y - 35),
-                (x, crown_y - 15),
-                (x + 20, crown_y - 35),
-                (x + 35, crown_y)
-            ]
-            draw.polygon(points, fill=(255, 215, 0), outline=(200, 170, 0), width=2)
-        
-        elif prop == "glasses":
-            glass_y = head_y - head_r // 4
-            # Left lens
-            draw.ellipse([x - head_r//2 - 15, glass_y - 12, x - head_r//2 + 15, glass_y + 12],
-                        outline=self.FIGURE_COLOR, width=3)
-            # Right lens
-            draw.ellipse([x + head_r//2 - 15, glass_y - 12, x + head_r//2 + 15, glass_y + 12],
-                        outline=self.FIGURE_COLOR, width=3)
-            # Bridge
-            draw.line([x - head_r//2 + 15, glass_y, x + head_r//2 - 15, glass_y],
-                     fill=self.FIGURE_COLOR, width=2)
-        
-        elif prop == "money":
-            bag_x = x + 80
-            bag_y = head_y + 120
-            draw.ellipse([bag_x, bag_y, bag_x + 50, bag_y + 60], 
-                        fill=(34, 139, 34), outline=(20, 100, 20), width=2)
-            draw.text((bag_x + 18, bag_y + 15), "$", fill=(255, 255, 255), font=self.font_label)
-        
-        elif prop == "book":
-            book_x = x + 70
-            book_y = head_y + 100
-            draw.rectangle([book_x, book_y, book_x + 40, book_y + 55], 
-                          fill=(139, 69, 19), outline=(100, 50, 10), width=2)
-            draw.line([book_x + 20, book_y, book_x + 20, book_y + 55], fill=(80, 40, 10), width=2)
-        
-        elif prop == "briefcase":
-            bc_x = x + 70
-            bc_y = head_y + 130
-            draw.rectangle([bc_x, bc_y, bc_x + 50, bc_y + 35], 
-                          fill=(60, 40, 30), outline=(40, 25, 15), width=2)
-            draw.rectangle([bc_x + 15, bc_y - 8, bc_x + 35, bc_y + 5], 
-                          fill=(60, 40, 30), outline=(40, 25, 15), width=2)
-        
-        elif prop == "phone":
-            phone_x = x + 75
-            phone_y = head_y + 80
-            draw.rectangle([phone_x, phone_y, phone_x + 25, phone_y + 40], 
-                          fill=(50, 50, 50), outline=(30, 30, 30), width=2)
-            draw.rectangle([phone_x + 3, phone_y + 5, phone_x + 22, phone_y + 32], 
-                          fill=(100, 150, 200))
-    
-    # ==========================================
-    # VISUAL METAPHORS
-    # ==========================================
-    
-    def draw_metaphor(
-        self,
-        draw: ImageDraw,
-        metaphor: str,
-        state: str = "intact",
-        y_pos: int = None
-    ):
-        """Draw visual metaphors"""
-        y = y_pos or self.HEIGHT // 2 + 200
-        
-        if metaphor == "bridge":
-            self._draw_bridge(draw, y, state)
-        elif metaphor == "rope":
-            self._draw_rope(draw, y, state)
-        elif metaphor == "scale":
-            self._draw_scale(draw, y, state)
-        elif metaphor == "handshake":
-            self._draw_handshake(draw, y)
-    
-    def _draw_bridge(self, draw, y, state):
-        """Draw bridge metaphor"""
-        bridge_y = y
-        
-        if state == "intact":
-            # Full bridge
-            draw.rectangle([200, bridge_y, 880, bridge_y + 30], 
-                          fill=(139, 90, 43), outline=(100, 65, 30), width=2)
-            # Supports
-            draw.rectangle([200, bridge_y + 30, 250, bridge_y + 150], fill=(100, 65, 30))
-            draw.rectangle([830, bridge_y + 30, 880, bridge_y + 150], fill=(100, 65, 30))
-        
-        elif state == "breaking":
-            # Left part
-            draw.polygon([
-                (200, bridge_y), (500, bridge_y), (520, bridge_y + 80),
-                (200, bridge_y + 30)
-            ], fill=(139, 90, 43), outline=(100, 65, 30))
-            # Right part
-            draw.polygon([
-                (560, bridge_y + 60), (880, bridge_y), (880, bridge_y + 30),
-                (580, bridge_y + 90)
-            ], fill=(139, 90, 43), outline=(100, 65, 30))
-            # Supports
-            draw.rectangle([200, bridge_y + 30, 250, bridge_y + 150], fill=(100, 65, 30))
-            draw.rectangle([830, bridge_y + 30, 880, bridge_y + 150], fill=(100, 65, 30))
-    
-    def _draw_rope(self, draw, y, state):
-        """Draw rope/tug-of-war metaphor"""
-        rope_y = y
-        
-        # Rope
-        if state == "tense":
-            # Straight tense rope
-            draw.line([200, rope_y, 880, rope_y], fill=(139, 90, 43), width=8)
-        else:
-            # Slight curve
-            for i in range(20):
-                x1 = 200 + i * 34
-                x2 = x1 + 34
-                y1 = rope_y + math.sin(i * 0.5) * 10
-                y2 = rope_y + math.sin((i + 1) * 0.5) * 10
-                draw.line([x1, y1, x2, y2], fill=(139, 90, 43), width=8)
-        
-        # Center marker
-        draw.rectangle([530, rope_y - 15, 550, rope_y + 15], fill=self.HIGHLIGHT)
-    
-    def _draw_scale(self, draw, y, state):
-        """Draw balance scale metaphor"""
-        center_x = self.WIDTH // 2
-        base_y = y + 100
-        
-        # Base
-        draw.polygon([
-            (center_x - 50, base_y), (center_x + 50, base_y),
-            (center_x + 30, base_y + 40), (center_x - 30, base_y + 40)
-        ], fill=(139, 90, 43))
-        
-        # Pole
-        draw.rectangle([center_x - 5, y - 50, center_x + 5, base_y], fill=(100, 65, 30))
-        
-        # Beam
-        if state == "balanced":
-            draw.rectangle([center_x - 150, y - 55, center_x + 150, y - 45], fill=(100, 65, 30))
-            # Plates
-            draw.ellipse([center_x - 180, y - 30, center_x - 100, y], fill=(180, 150, 120))
-            draw.ellipse([center_x + 100, y - 30, center_x + 180, y], fill=(180, 150, 120))
-        else:
-            # Tilted beam
-            draw.polygon([
-                (center_x - 150, y - 30), (center_x + 150, y - 70),
-                (center_x + 150, y - 60), (center_x - 150, y - 20)
-            ], fill=(100, 65, 30))
-    
-    def _draw_handshake(self, draw, y):
-        """Draw handshake"""
-        center_x = self.WIDTH // 2
-        
-        # Left hand
-        draw.line([center_x - 100, y, center_x - 20, y], fill=self.FIGURE_COLOR, width=10)
-        draw.ellipse([center_x - 40, y - 15, center_x, y + 15], fill=self.FIGURE_COLOR)
-        
-        # Right hand
-        draw.line([center_x + 100, y, center_x + 20, y], fill=self.FIGURE_COLOR, width=10)
-        draw.ellipse([center_x, y - 15, center_x + 40, y + 15], fill=self.FIGURE_COLOR)
-        
-        # Grip
-        draw.ellipse([center_x - 15, y - 10, center_x + 15, y + 10], fill=self.FIGURE_COLOR)
-    
-    # ==========================================
-    # SCENE RENDERING
-    # ==========================================
-    
-    def create_scene_frame(self, scene: Dict) -> Image.Image:
-        """Create a complete scene frame"""
-        img = Image.new('RGB', (self.WIDTH, self.HEIGHT), self.BG_COLOR)
-        draw = ImageDraw.Draw(img)
-        
-        scene_type = scene.get("scene_type", "single")
-        background = scene.get("background", "white")
-        
-        # Draw background
-        self.draw_background(draw, background)
-        
-        # Title scene
-        if scene_type == "title":
-            title = scene.get("title_text", "")
-            subtitle = scene.get("subtitle_text")
-            if title:
-                self.draw_title_screen(img, title, subtitle)
-        
-        # Character scenes
-        else:
-            characters = scene.get("characters", [])
-            for char in characters:
-                pos = char.get("position", "center")
-                x = self.POSITIONS.get(pos, self.POSITIONS["center"])
-                y = self.CHARACTER_Y
-                
-                pose = char.get("pose", "standing")
-                emotion = char.get("emotion", "happy")
-                props = char.get("props", [])
-                
-                self.draw_stick_figure(draw, x, y, pose, emotion, props, scale=1.2)
-                
-                # Thought bubble
-                thought = char.get("thought_bubble")
-                if thought:
-                    direction = "right" if pos == "left" else "left"
-                    head_y = y - self.BODY_LENGTH * 1.2 - self.HEAD_RADIUS * 1.2
-                    self.draw_thought_bubble(draw, x, int(head_y), thought, direction)
-                
-                # Label
-                label = char.get("label")
-                if label:
-                    bbox = draw.textbbox((0, 0), label, font=self.font_label)
-                    label_width = bbox[2] - bbox[0]
-                    draw.text((x - label_width // 2, y + 130), label,
-                             fill=(100, 100, 100), font=self.font_label)
-        
-        # Draw metaphor
-        metaphor = scene.get("metaphor")
-        if metaphor:
-            state = scene.get("metaphor_state", "intact")
-            self.draw_metaphor(draw, metaphor, state)
-        
-        # Draw caption
-        caption = scene.get("caption")
-        if caption:
-            self.draw_caption(img, caption)
-        
-        return img
-    
-    def generate_frames_from_scenes(
-        self,
-        scenes: List[Dict],
-        chunk_durations: List[float],
-        output_dir: str,
-        fps: int = 30
-    ) -> List[str]:
-        """Generate frames for all scenes"""
-        os.makedirs(output_dir, exist_ok=True)
-        frame_paths = []
-        frame_num = 0
-        
-        for i, scene in enumerate(scenes):
-            duration = chunk_durations[i] if i < len(chunk_durations) else 2.0
-            num_frames = int(duration * fps)
-            
-            logger.info(f"Generating {num_frames} frames for scene {i}: {scene.get('scene_type', 'unknown')}")
-            
-            frame = self.create_scene_frame(scene)
-            
-            for _ in range(num_frames):
-                frame_path = os.path.join(output_dir, f"frame_{frame_num:05d}.png")
-                frame.save(frame_path)
-                frame_paths.append(frame_path)
-                frame_num += 1
-        
-        logger.info(f"Generated {len(frame_paths)} total frames")
-        return frame_paths

modules/art_reels/services/stick_figure.py

@@ -1,375 +0,0 @@
-"""
-Stick Figure - Simple Stick Figure Drawing for Motivation Videos
-Pure Python implementation using Pillow
-"""
-import logging
-import math
-from PIL import Image, ImageDraw, ImageFont
-from typing import List, Tuple, Dict, Optional
-import os
-
-logger = logging.getLogger(__name__)
-
-
-class StickFigure:
-    """
-    Creates stick figure drawings for motivation/story videos.
-    
-    Features:
-    - Simple black stick figures
-    - Various poses (standing, walking, running, etc.)
-    - Props (crown, money bag, bed, etc.)
-    - Text overlays
-    - White background (clean look)
-    """
-    
-    # Video dimensions (9:16 portrait)
-    WIDTH = 1080
-    HEIGHT = 1920
-    
-    # Stick figure size
-    HEAD_RADIUS = 40
-    BODY_LENGTH = 120
-    ARM_LENGTH = 80
-    LEG_LENGTH = 100
-    LINE_WIDTH = 8
-    
-    # Colors
-    BG_COLOR = (255, 255, 255)  # White
-    FIGURE_COLOR = (0, 0, 0)    # Black
-    
-    def __init__(self):
-        self.frames = []
-    
-    def draw_stick_figure(
-        self,
-        draw: ImageDraw,
-        x: int,
-        y: int,
-        pose: str = "standing",
-        scale: float = 1.0,
-        props: List[str] = None
-    ):
-        """
-        Draw a stick figure at position (x, y).
-        
-        Args:
-            draw: PIL ImageDraw object
-            x, y: Center position for the figure
-            pose: Pose type
-            scale: Size multiplier
-            props: List of props to add
-        """
-        props = props or []
-        
-        # Scale dimensions
-        head_r = int(self.HEAD_RADIUS * scale)
-        body_len = int(self.BODY_LENGTH * scale)
-        arm_len = int(self.ARM_LENGTH * scale)
-        leg_len = int(self.LEG_LENGTH * scale)
-        line_w = max(4, int(self.LINE_WIDTH * scale))
-        
-        # Head position
-        head_y = y - body_len - head_r
-        
-        # Draw based on pose
-        if pose == "standing":
-            self._draw_standing(draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w)
-        elif pose == "walking":
-            self._draw_walking(draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w)
-        elif pose == "running":
-            self._draw_running(draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w)
-        elif pose == "sitting":
-            self._draw_sitting(draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w)
-        elif pose == "sleeping":
-            self._draw_sleeping(draw, x, y, head_r, body_len, arm_len, leg_len, line_w)
-        elif pose == "waving":
-            self._draw_waving(draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w)
-        elif pose == "thinking":
-            self._draw_thinking(draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w)
-        else:
-            self._draw_standing(draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w)
-        
-        # Draw props
-        for prop in props:
-            self._draw_prop(draw, x, head_y, head_r, prop, scale)
-    
-    def _draw_standing(self, draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w):
-        """Draw standing pose"""
-        # Head
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r], 
-                     outline=self.FIGURE_COLOR, width=line_w)
-        
-        # Body
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Arms (slightly down)
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len // 2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y + arm_len // 2], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Legs
-        draw.line([x, body_bottom, x - leg_len // 2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len // 2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_walking(self, draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w):
-        """Draw walking pose"""
-        # Head
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r], 
-                     outline=self.FIGURE_COLOR, width=line_w)
-        
-        # Body (slightly leaning)
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x + 10, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Arms (swinging)
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len // 2, arm_y + arm_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len, arm_y - arm_len // 3], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Legs (one forward, one back)
-        draw.line([x + 10, body_bottom, x - leg_len, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + 10, body_bottom, x + leg_len, body_bottom + leg_len // 2], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_running(self, draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w):
-        """Draw running pose"""
-        # Head (leaning forward)
-        draw.ellipse([x - head_r + 20, head_y - head_r, x + head_r + 20, head_y + head_r], 
-                     outline=self.FIGURE_COLOR, width=line_w)
-        
-        # Body (leaning forward)
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x + 20, body_top, x + 40, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Arms (dynamic swing)
-        arm_y = body_top + body_len // 4 + 20
-        draw.line([x + 20, arm_y, x - arm_len, arm_y + arm_len // 3], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + 20, arm_y, x + arm_len + 30, arm_y - arm_len // 2], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Legs (wide stride)
-        draw.line([x + 40, body_bottom, x - leg_len - 20, body_bottom + leg_len // 2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + 40, body_bottom, x + leg_len + 40, body_bottom + leg_len // 3], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_sitting(self, draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w):
-        """Draw sitting pose"""
-        head_y = head_y + leg_len  # Lower position
-        
-        # Head
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r], 
-                     outline=self.FIGURE_COLOR, width=line_w)
-        
-        # Body
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len // 2
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Arms (on lap)
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len // 2, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len // 2, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Legs (bent)
-        draw.line([x, body_bottom, x - leg_len, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x - leg_len, body_bottom, x - leg_len, body_bottom + leg_len // 2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + leg_len, body_bottom, x + leg_len, body_bottom + leg_len // 2], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_sleeping(self, draw, x, y, head_r, body_len, arm_len, leg_len, line_w):
-        """Draw sleeping pose (horizontal)"""
-        # Horizontal figure
-        y = y - leg_len  # Adjust position
-        
-        # Head
-        draw.ellipse([x - body_len - head_r, y - head_r, x - body_len + head_r, y + head_r], 
-                     outline=self.FIGURE_COLOR, width=line_w)
-        
-        # Body (horizontal)
-        draw.line([x - body_len + head_r, y, x, y], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Arms (tucked)
-        draw.line([x - body_len // 2, y, x - body_len // 2, y - arm_len // 3], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Legs (horizontal)
-        draw.line([x, y, x + leg_len, y + 10], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, y, x + leg_len, y - 10], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Zzz
-        draw.text((x - body_len, y - head_r - 60), "Zzz", fill=self.FIGURE_COLOR)
-    
-    def _draw_waving(self, draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w):
-        """Draw waving pose"""
-        # Head
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r], 
-                     outline=self.FIGURE_COLOR, width=line_w)
-        
-        # Body
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Arms (one waving up)
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len // 2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, arm_y, x + arm_len // 2, arm_y - arm_len], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Legs
-        draw.line([x, body_bottom, x - leg_len // 2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len // 2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-    
-    def _draw_thinking(self, draw, x, head_y, head_r, body_len, arm_len, leg_len, line_w):
-        """Draw thinking pose"""
-        # Head
-        draw.ellipse([x - head_r, head_y - head_r, x + head_r, head_y + head_r], 
-                     outline=self.FIGURE_COLOR, width=line_w)
-        
-        # Body
-        body_top = head_y + head_r
-        body_bottom = body_top + body_len
-        draw.line([x, body_top, x, body_bottom], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Arms (one on chin)
-        arm_y = body_top + body_len // 4
-        draw.line([x, arm_y, x - arm_len, arm_y + arm_len // 2], fill=self.FIGURE_COLOR, width=line_w)
-        # Arm to chin
-        draw.line([x, arm_y, x + arm_len // 3, arm_y - arm_len // 2], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x + arm_len // 3, arm_y - arm_len // 2, x + head_r // 2, head_y + head_r // 2], 
-                  fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Legs
-        draw.line([x, body_bottom, x - leg_len // 2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        draw.line([x, body_bottom, x + leg_len // 2, body_bottom + leg_len], fill=self.FIGURE_COLOR, width=line_w)
-        
-        # Thought bubble
-        draw.ellipse([x + head_r + 20, head_y - head_r - 80, x + head_r + 120, head_y - head_r], 
-                     outline=self.FIGURE_COLOR, width=3)
-        draw.text((x + head_r + 45, head_y - head_r - 55), "?", fill=self.FIGURE_COLOR)
-    
-    def _draw_prop(self, draw, x, head_y, head_r, prop: str, scale: float):
-        """Draw props on the figure"""
-        if prop == "crown":
-            # Crown on head
-            crown_y = head_y - head_r - 10
-            points = [
-                (x - 30, crown_y),
-                (x - 20, crown_y - 30),
-                (x, crown_y - 10),
-                (x + 20, crown_y - 30),
-                (x + 30, crown_y)
-            ]
-            draw.polygon(points, fill=(255, 215, 0), outline=(0, 0, 0))
-        
-        elif prop == "money":
-            # Money bag
-            bag_x = x + 80
-            bag_y = head_y + 100
-            draw.ellipse([bag_x, bag_y, bag_x + 50, bag_y + 60], fill=(34, 139, 34), outline=(0, 0, 0))
-            draw.text((bag_x + 15, bag_y + 15), "$", fill=(255, 255, 255))
-        
-        elif prop == "suit":
-            # Simple tie
-            tie_y = head_y + head_r + 10
-            draw.polygon([
-                (x, tie_y),
-                (x - 15, tie_y + 20),
-                (x, tie_y + 80),
-                (x + 15, tie_y + 20)
-            ], fill=(128, 0, 0))
-    
-    def add_text_overlay(
-        self,
-        img: Image.Image,
-        text: str,
-        position: str = "center",
-        font_size: int = 80
-    ) -> Image.Image:
-        """Add text overlay to image"""
-        draw = ImageDraw.Draw(img)
-        
-        try:
-            font = ImageFont.truetype("arial.ttf", font_size)
-        except:
-            font = ImageFont.load_default()
-        
-        bbox = draw.textbbox((0, 0), text, font=font)
-        text_width = bbox[2] - bbox[0]
-        text_height = bbox[3] - bbox[1]
-        
-        if position == "center":
-            pos = ((self.WIDTH - text_width) // 2, (self.HEIGHT - text_height) // 2)
-        elif position == "top":
-            pos = ((self.WIDTH - text_width) // 2, 100)
-        elif position == "bottom":
-            pos = ((self.WIDTH - text_width) // 2, self.HEIGHT - text_height - 100)
-        else:
-            pos = ((self.WIDTH - text_width) // 2, (self.HEIGHT - text_height) // 2)
-        
-        # Draw text with outline
-        draw.text(pos, text, fill=self.FIGURE_COLOR, font=font, 
-                  stroke_width=3, stroke_fill=(200, 200, 200))
-        
-        return img
-    
-    def create_scene(
-        self,
-        pose: str = "standing",
-        props: List[str] = None,
-        text: str = None,
-        text_position: str = "bottom"
-    ) -> Image.Image:
-        """Create a single scene with stick figure"""
-        # Create white background
-        img = Image.new('RGB', (self.WIDTH, self.HEIGHT), self.BG_COLOR)
-        draw = ImageDraw.Draw(img)
-        
-        # Draw figure in center
-        self.draw_stick_figure(draw, self.WIDTH // 2, self.HEIGHT // 2 + 100, 
-                               pose=pose, scale=1.5, props=props)
-        
-        # Add text if provided
-        if text:
-            self.add_text_overlay(img, text, position=text_position)
-        
-        return img
-    
-    def generate_motivation_frames(
-        self,
-        scenes: List[Dict],
-        output_dir: str = "temp"
-    ) -> List[str]:
-        """
-        Generate frames for motivation video.
-        
-        Args:
-            scenes: List of scene dicts with pose, props, text, duration
-            output_dir: Directory to save frames
-            
-        Returns:
-            List of frame file paths
-        """
-        os.makedirs(output_dir, exist_ok=True)
-        frame_paths = []
-        frame_num = 0
-        
-        for scene in scenes:
-            pose = scene.get("pose", "standing")
-            props = scene.get("props", [])
-            text = scene.get("text", None)
-            duration = scene.get("duration", 1.0)  # seconds
-            
-            # Create scene image
-            img = self.create_scene(pose=pose, props=props, text=text)
-            
-            # Generate frames for duration (30 fps)
-            num_frames = int(duration * 30)
-            for _ in range(num_frames):
-                frame_path = os.path.join(output_dir, f"frame_{frame_num:04d}.png")
-                img.save(frame_path)
-                frame_paths.append(frame_path)
-                frame_num += 1
-        
-        logger.info(f"Generated {len(frame_paths)} frames for motivation video")
-        return frame_paths

modules/art_reels/services/video_composer.py

@@ -1,215 +0,0 @@
-"""
-Video Composer - Combines frames into final video with captions
-Uses MoviePy for video rendering with word-by-word captions like Story Reels
-"""
-import logging
-import os
-import uuid
-from pathlib import Path
-from typing import List, Optional, Dict
-from moviepy.editor import (
-    ImageSequenceClip, 
-    AudioFileClip, 
-    CompositeAudioClip,
-    CompositeVideoClip,
-    TextClip
-)
-
-logger = logging.getLogger(__name__)
-
-
-class VideoComposer:
-    """
-    Combines image frames into final video with professional captions.
-    
-    Features:
-    - Frame sequence to video
-    - Audio overlay
-    - Background music
-    - Word-by-word captions (like Story Reels)
-    """
-    
-    # Video settings
-    FPS = 30
-    TARGET_WIDTH = 1080
-    TARGET_HEIGHT = 1920
-    
-    # Caption settings (matching Story Reels)
-    CAPTION_FONT_SIZE = 72
-    CAPTION_COLOR = 'white'
-    CAPTION_STROKE_COLOR = 'black'
-    CAPTION_STROKE_WIDTH = 4
-    CAPTION_Y_POS = 0.75  # 75% down
-    
-    def __init__(self, output_dir: str = "videos"):
-        self.output_dir = output_dir
-        os.makedirs(output_dir, exist_ok=True)
-    
-    def _find_font(self) -> str:
-        """Find a suitable font for captions"""
-        # Try common font paths
-        font_paths = [
-            "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
-            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
-            "/usr/share/fonts/TTF/DejaVuSans-Bold.ttf",
-            "C:/Windows/Fonts/arial.ttf",
-            "C:/Windows/Fonts/arialbd.ttf",
-        ]
-        
-        for path in font_paths:
-            if os.path.exists(path):
-                return path
-        
-        # Fallback
-        return "DejaVu-Sans-Bold"
-    
-    def compose_video(
-        self,
-        frame_paths: List[str],
-        audio_path: Optional[str] = None,
-        music_path: Optional[str] = None,
-        output_name: Optional[str] = None,
-        fps: int = None,
-        captions: Optional[List[Dict]] = None
-    ) -> str:
-        """
-        Compose video from frames with optional captions.
-        
-        Args:
-            frame_paths: List of frame image paths
-            audio_path: Optional voice audio path
-            music_path: Optional background music path
-            output_name: Custom output filename
-            fps: Frames per second
-            captions: Optional list of captions [{text, startMs, endMs}]
-            
-        Returns:
-            Path to output video
-        """
-        fps = fps or self.FPS
-        output_name = output_name or f"art_video_{uuid.uuid4().hex[:8]}.mp4"
-        output_path = os.path.join(self.output_dir, output_name)
-        
-        try:
-            logger.info(f"Composing video from {len(frame_paths)} frames")
-            
-            # Create video clip from frames
-            base_clip = ImageSequenceClip(frame_paths, fps=fps)
-            
-            # If captions provided, add them
-            if captions:
-                base_clip = self._add_captions(base_clip, captions)
-            
-            # Add audio if provided
-            audio_clips = []
-            
-            if audio_path and os.path.exists(audio_path):
-                voice_audio = AudioFileClip(audio_path)
-                audio_clips.append(voice_audio)
-            
-            if music_path and os.path.exists(music_path):
-                music_audio = AudioFileClip(music_path)
-                # Loop music if needed
-                if music_audio.duration < base_clip.duration:
-                    music_audio = music_audio.loop(duration=base_clip.duration)
-                else:
-                    music_audio = music_audio.subclip(0, base_clip.duration)
-                # Lower volume for background
-                music_audio = music_audio.volumex(0.3)
-                audio_clips.append(music_audio)
-            
-            if audio_clips:
-                if len(audio_clips) > 1:
-                    final_audio = CompositeAudioClip(audio_clips)
-                else:
-                    final_audio = audio_clips[0]
-                base_clip = base_clip.set_audio(final_audio)
-            
-            # Write video
-            base_clip.write_videofile(
-                output_path,
-                codec='libx264',
-                audio_codec='aac',
-                fps=fps,
-                preset='medium',
-                threads=4
-            )
-            
-            # Cleanup
-            base_clip.close()
-            for ac in audio_clips:
-                ac.close()
-            
-            logger.info(f"Video saved to: {output_path}")
-            return output_path
-            
-        except Exception as e:
-            logger.error(f"Error composing video: {e}")
-            raise
-    
-    def _add_captions(
-        self, 
-        video_clip, 
-        captions: List[Dict]
-    ):
-        """
-        Add word-by-word captions to video.
-        
-        Args:
-            video_clip: Base video clip
-            captions: List of [{text, startMs, endMs}]
-            
-        Returns:
-            CompositeVideoClip with captions
-        """
-        font_name = self._find_font()
-        caption_clips = []
-        y_pos = self.TARGET_HEIGHT * self.CAPTION_Y_POS
-        
-        for cap in captions:
-            start_time = cap.get("startMs", 0) / 1000
-            end_time = cap.get("endMs", 0) / 1000
-            duration = end_time - start_time
-            text = cap.get("text", "")
-            
-            if duration <= 0 or not text:
-                continue
-            
-            try:
-                txt_clip = TextClip(
-                    text,
-                    fontsize=self.CAPTION_FONT_SIZE,
-                    font=font_name,
-                    color=self.CAPTION_COLOR,
-                    stroke_color=self.CAPTION_STROKE_COLOR,
-                    stroke_width=self.CAPTION_STROKE_WIDTH,
-                    method='caption',
-                    size=(self.TARGET_WIDTH - 100, None),
-                    align='center'
-                )
-                
-                # Position at bottom center
-                txt_clip = txt_clip.set_position(('center', y_pos))
-                txt_clip = txt_clip.set_start(start_time)
-                txt_clip = txt_clip.set_duration(duration)
-                
-                caption_clips.append(txt_clip)
-                
-            except Exception as e:
-                logger.warning(f"Failed to create caption: {e}")
-                continue
-        
-        if caption_clips:
-            logger.info(f"Added {len(caption_clips)} caption clips")
-            return CompositeVideoClip([video_clip] + caption_clips)
-        
-        return video_clip
-    
-    def cleanup_frames(self, frame_paths: List[str]):
-        """Delete temporary frame files"""
-        for path in frame_paths:
-            try:
-                if os.path.exists(path):
-                    os.remove(path)
-            except Exception as e:
-                logger.warning(f"Failed to delete frame {path}: {e}")

static/index.html

@@ -276,9 +276,6 @@
             <button class="tab-btn" data-tab="trends">
                 📊 Trends
             </button>
-            <button class="tab-btn" data-tab="art">
-                🎨 Art Reels
-            </button>
         </div>
 
         <!-- Story Reels Tab -->
@@ -572,81 +569,6 @@
         </div>
     </div>
 
-    <!-- Art Reels Tab -->
-    <div id="art-tab" class="tab-content">
-        <div class="card">
-            <h2>🎨 Art Reels Generator</h2>
-            <p style="color: var(--text-secondary); margin-bottom: 1.5rem;">
-                Create animated art videos using pure Python - No AI API needed!
-            </p>
-
-            <!-- Minecraft Block Art -->
-            <div style="margin-bottom: 2rem; padding: 1.5rem; background: var(--bg-secondary); border-radius: 12px;">
-                <h3 style="margin-bottom: 1rem;">🏠 Minecraft Block Art</h3>
-                <p style="color: var(--text-secondary); font-size: 0.9rem; margin-bottom: 1rem;">
-                    Isometric block-by-block building animation
-                </p>
-                <form id="minecraftForm">
-                    <div class="form-group">
-                        <label>Description</label>
-                        <input type="text" id="mcDescription" value="wooden survival house"
-                            placeholder="e.g., wooden survival house">
-                    </div>
-                    <div class="form-row">
-                        <div class="form-group">
-                            <label>Speed</label>
-                            <select id="mcSpeed">
-                                <option value="0.5">Slow</option>
-                                <option value="1.0" selected>Normal</option>
-                                <option value="2.0">Fast</option>
-                            </select>
-                        </div>
-                    </div>
-                    <button type="submit" class="submit-btn">🏠 Generate Minecraft Video</button>
-                </form>
-                <div id="minecraftStatus" class="status hidden"></div>
-            </div>
-
-            <!-- AI Drawing Animation -->
-            <div style="margin-bottom: 2rem; padding: 1.5rem; background: var(--bg-secondary); border-radius: 12px;">
-                <h3 style="margin-bottom: 1rem;">✏️ AI Drawing Animation</h3>
-                <p style="color: var(--text-secondary); font-size: 0.9rem; margin-bottom: 1rem;">
-                    AI generates paths → Line-by-line animated drawing. Type anything!
-                </p>
-                <form id="drawingForm">
-                    <div class="form-group">
-                        <label>What to Draw (AI-Powered)</label>
-                        <input type="text" id="drawSubject"
-                            placeholder="e.g., sports car, human face, flower, sunset, rocket..." value="sports car">
-                        <small style="color: var(--text-secondary); display: block; margin-top: 0.5rem;">
-                            💡 Try: car, face, tree, house, flower, star, heart, sun, or any custom prompt
-                        </small>
-                    </div>
-                    <button type="submit" class="submit-btn">✏️ Generate AI Drawing Video</button>
-                </form>
-                <div id="drawingStatus" class="status hidden"></div>
-            </div>
-
-            <!-- Stick Figure Motivation -->
-            <div style="padding: 1.5rem; background: var(--bg-secondary); border-radius: 12px;">
-                <h3 style="margin-bottom: 1rem;">🎭 Stick Figure Motivation</h3>
-                <p style="color: var(--text-secondary); font-size: 0.9rem; margin-bottom: 1rem;">
-                    White background + black stick figures + voice sync
-                </p>
-                <form id="stickForm">
-                    <div class="form-group">
-                        <label>Script (Keywords: king, rich, sleep, run, walk, think, etc.)</label>
-                        <textarea id="stickScript" rows="4"
-                            placeholder="A rich man woke up from sleep. He thought about what to do today. Get ready for success!"></textarea>
-                    </div>
-                    <button type="submit" class="submit-btn">🎭 Generate Stick Figure Video</button>
-                </form>
-                <div id="stickStatus" class="status hidden"></div>
-            </div>
-
-        </div>
-    </div>
-
     <script>
         // Tab switching
         document.querySelectorAll('.tab-btn').forEach(btn => {