Add Art Reels module - Minecraft Block Art, Code Drawing, Stick Figure Motivation

modules/art_reels/__init__.py

@@ -0,0 +1,26 @@
+"""
+Art Reels Module - Animated Art Content Generator
+Pure Python implementation using Pillow and MoviePy
+"""
+import logging
+from config import NCAkitConfig
+
+logger = logging.getLogger(__name__)
+
+
+def register(app, config: NCAkitConfig):
+    """Register art_reels module with the app"""
+    try:
+        from .router import router
+        
+        # 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

@@ -0,0 +1,386 @@
+"""
+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.stick_figure import StickFigure
+from .services.video_composer import VideoComposer
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# 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 drawing animation video"""
+    temp_dir = f"temp/art_{job_id}"
+    
+    try:
+        update_job(job_id, "processing", 10)
+        
+        # Generate frames
+        logger.info(f"Generating drawing frames for job {job_id}")
+        frame_paths = drawing_animator.generate_drawing_animation(
+            subject=subject,
+            output_dir=temp_dir,
+            with_colors=colors
+        )
+        
+        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", 90)
+        
+        # Cleanup
+        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"Drawing video ready: {job_id}")
+        
+    except Exception as e:
+        logger.error(f"Error generating drawing video: {e}")
+        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"""
+    temp_dir = f"temp/art_{job_id}"
+    
+    try:
+        update_job(job_id, "processing", 10)
+        
+        # Parse script into scenes (simple keyword matching)
+        scenes = parse_script_to_scenes(script)
+        
+        update_job(job_id, "processing", 30)
+        
+        # Generate frames
+        logger.info(f"Generating stick figure frames for job {job_id}")
+        frame_paths = stick_figure.generate_motivation_frames(
+            scenes=scenes,
+            output_dir=temp_dir
+        )
+        
+        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"stick_{job_id}.mp4",
+            fps=30
+        )
+        
+        update_job(job_id, "processing", 90)
+        
+        # Cleanup
+        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"Stick figure video ready: {job_id}")
+        
+    except Exception as e:
+        logger.error(f"Error generating stick figure video: {e}")
+        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

@@ -0,0 +1,84 @@
+"""
+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

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

modules/art_reels/services/block_art.py

@@ -0,0 +1,283 @@
+"""
+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 = "✓ 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

@@ -0,0 +1,303 @@
+"""
+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 = "✓ 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/stick_figure.py

@@ -0,0 +1,375 @@
+"""
+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

@@ -0,0 +1,116 @@
+"""
+Video Composer - Combines frames into final video
+Uses MoviePy for video rendering
+"""
+import logging
+import os
+import uuid
+from typing import List, Optional
+from moviepy.editor import ImageSequenceClip, AudioFileClip, CompositeAudioClip
+
+logger = logging.getLogger(__name__)
+
+
+class VideoComposer:
+    """
+    Combines image frames into final video.
+    
+    Features:
+    - Frame sequence to video
+    - Audio overlay
+    - Background music
+    """
+    
+    # Video settings
+    FPS = 30
+    
+    def __init__(self, output_dir: str = "videos"):
+        self.output_dir = output_dir
+        os.makedirs(output_dir, exist_ok=True)
+    
+    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
+    ) -> str:
+        """
+        Compose video from frames.
+        
+        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
+            
+        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
+            clip = ImageSequenceClip(frame_paths, fps=fps)
+            
+            # 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 < clip.duration:
+                    music_audio = music_audio.loop(duration=clip.duration)
+                else:
+                    music_audio = music_audio.subclip(0, 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]
+                clip = clip.set_audio(final_audio)
+            
+            # Write video
+            clip.write_videofile(
+                output_path,
+                codec='libx264',
+                audio_codec='aac',
+                fps=fps,
+                preset='medium',
+                threads=4
+            )
+            
+            # Cleanup
+            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 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,6 +276,9 @@
             <button class="tab-btn" data-tab="trends">
                 📊 Trends
             </button>
+            <button class="tab-btn" data-tab="art">
+                🎨 Art Reels
+            </button>
         </div>
 
         <!-- Story Reels Tab -->
@@ -569,6 +572,91 @@
         </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>
+
+            <!-- Code Drawing Animation -->
+            <div style="margin-bottom: 2rem; padding: 1.5rem; background: var(--bg-secondary); border-radius: 12px;">
+                <h3 style="margin-bottom: 1rem;">✏️ Code Drawing Animation</h3>
+                <p style="color: var(--text-secondary); font-size: 0.9rem; margin-bottom: 1rem;">
+                    Line-by-line drawing with color fill
+                </p>
+                <form id="drawingForm">
+                    <div class="form-group">
+                        <label>What to Draw</label>
+                        <select id="drawSubject">
+                            <option value="house">House</option>
+                            <option value="tree">Tree</option>
+                            <option value="star">Star</option>
+                            <option value="heart">Heart</option>
+                        </select>
+                    </div>
+                    <div class="form-row">
+                        <div class="form-group">
+                            <label>Style</label>
+                            <select id="drawStyle">
+                                <option value="outline_first">Outline First</option>
+                                <option value="color_fill">With Colors</option>
+                            </select>
+                        </div>
+                    </div>
+                    <button type="submit" class="submit-btn">✏️ Generate 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: রাজা, বড়লোক, ঘুম, দৌড়, etc.)</label>
+                        <textarea id="stickScript" rows="4"
+                            placeholder="একজন বড়লোক মানুষ সকালে ঘুম থেকে উঠল। সে মনে মনে ভাবল আজকে কি করব। 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 => {
@@ -882,6 +970,132 @@
             }
         });
 
+        // ==========================================
+        // ART REELS MODULE
+        // ==========================================
+
+        // Helper function for polling art job status
+        async function pollArtStatus(jobId, statusDiv, type) {
+            const checkStatus = async () => {
+                try {
+                    const res = await fetch(`/api/art/${jobId}/status`);
+                    const status = await res.json();
+
+                    if (status.status === 'ready') {
+                        statusDiv.className = 'status success';
+                        statusDiv.innerHTML = `✅ Video Ready! <a href="${status.video_url}" target="_blank" style="color: var(--accent);">Download Video</a>`;
+                        return;
+                    } else if (status.status === 'failed') {
+                        statusDiv.className = 'status error';
+                        statusDiv.innerHTML = `❌ Failed: ${status.error}`;
+                        return;
+                    } else {
+                        statusDiv.innerHTML = `⏳ ${status.status}... ${status.progress}%`;
+                        setTimeout(checkStatus, 2000);
+                    }
+                } catch (err) {
+                    statusDiv.className = 'status error';
+                    statusDiv.innerHTML = `❌ Error: ${err.message}`;
+                }
+            };
+            checkStatus();
+        }
+
+        // Minecraft Form
+        document.getElementById('minecraftForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const status = document.getElementById('minecraftStatus');
+            status.className = 'status';
+            status.classList.remove('hidden');
+            status.innerHTML = '⏳ Starting Minecraft video generation...';
+
+            const data = {
+                description: document.getElementById('mcDescription').value,
+                blocks: 50,
+                speed: parseFloat(document.getElementById('mcSpeed').value)
+            };
+
+            try {
+                const res = await fetch('/api/art/minecraft', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(data)
+                });
+                const result = await res.json();
+
+                if (result.job_id) {
+                    status.innerHTML = `⏳ Job started: ${result.job_id}`;
+                    pollArtStatus(result.job_id, status, 'minecraft');
+                }
+            } catch (err) {
+                status.className = 'status error';
+                status.innerHTML = '❌ Error: ' + err.message;
+            }
+        });
+
+        // Drawing Form
+        document.getElementById('drawingForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const status = document.getElementById('drawingStatus');
+            status.className = 'status';
+            status.classList.remove('hidden');
+            status.innerHTML = '⏳ Starting drawing animation...';
+
+            const data = {
+                subject: document.getElementById('drawSubject').value,
+                style: document.getElementById('drawStyle').value,
+                colors: true
+            };
+
+            try {
+                const res = await fetch('/api/art/drawing', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(data)
+                });
+                const result = await res.json();
+
+                if (result.job_id) {
+                    status.innerHTML = `⏳ Job started: ${result.job_id}`;
+                    pollArtStatus(result.job_id, status, 'drawing');
+                }
+            } catch (err) {
+                status.className = 'status error';
+                status.innerHTML = '❌ Error: ' + err.message;
+            }
+        });
+
+        // Stick Figure Form
+        document.getElementById('stickForm').addEventListener('submit', async (e) => {
+            e.preventDefault();
+            const status = document.getElementById('stickStatus');
+            status.className = 'status';
+            status.classList.remove('hidden');
+            status.innerHTML = '⏳ Starting stick figure video...';
+
+            const data = {
+                script: document.getElementById('stickScript').value,
+                voice: 'af_heart'
+            };
+
+            try {
+                const res = await fetch('/api/art/stick-figure', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(data)
+                });
+                const result = await res.json();
+
+                if (result.job_id) {
+                    status.innerHTML = `⏳ Job started: ${result.job_id}`;
+                    pollArtStatus(result.job_id, status, 'stick');
+                }
+            } catch (err) {
+                status.className = 'status error';
+                status.innerHTML = '❌ Error: ' + err.message;
+            }
+        });
+
         // ==========================================
         // GEMINI CHATBOT TEST
         // ==========================================