video-processor/examples/docker_demo.py

#!/usr/bin/env python3
"""
Docker Demo Application for Video Processor

This demo shows how to use the video processor in a containerized environment
with Procrastinate background tasks and PostgreSQL.
"""

import asyncio
import logging
import os
import tempfile
from pathlib import Path

from video_processor import ProcessorConfig, VideoProcessor
from video_processor.tasks import setup_procrastinate
from video_processor.tasks.compat import get_version_info
from video_processor.tasks.migration import migrate_database

# Configure logging
logging.basicConfig(
    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)


async def create_sample_video(output_path: Path) -> Path:
    """Create a sample video using ffmpeg for testing."""
    video_file = output_path / "sample_test_video.mp4"

    # Create a simple test video using ffmpeg
    import subprocess

    cmd = [
        "ffmpeg",
        "-y",
        "-f",
        "lavfi",
        "-i",
        "testsrc=duration=10:size=640x480:rate=30",
        "-c:v",
        "libx264",
        "-preset",
        "fast",
        "-crf",
        "23",
        str(video_file),
    ]

    try:
        result = subprocess.run(cmd, capture_output=True, text=True)
        if result.returncode != 0:
            logger.error(f"FFmpeg failed: {result.stderr}")
            raise RuntimeError("Failed to create sample video")

        logger.info(f"Created sample video: {video_file}")
        return video_file

    except FileNotFoundError:
        logger.error("FFmpeg not found. Please install FFmpeg.")
        raise


async def demo_sync_processing():
    """Demonstrate synchronous video processing."""
    logger.info("🎬 Starting Synchronous Processing Demo")

    with tempfile.TemporaryDirectory() as temp_dir:
        temp_path = Path(temp_dir)

        # Create sample video
        sample_video = await create_sample_video(temp_path)

        # Configure processor
        config = ProcessorConfig(
            output_dir=temp_path / "outputs",
            output_formats=["mp4", "webm"],
            quality_preset="fast",
            generate_thumbnails=True,
            generate_sprites=True,
            enable_360_processing=True,  # Will be disabled if deps not available
        )

        # Process video
        processor = VideoProcessor(config)
        result = processor.process_video(sample_video)

        logger.info("✅ Synchronous processing completed!")
        logger.info(f"📹 Processed video ID: {result.video_id}")
        logger.info(f"📁 Output files: {len(result.encoded_files)} formats")
        logger.info(f"🖼️  Thumbnails: {len(result.thumbnails)}")

        if result.sprite_file:
            sprite_size = result.sprite_file.stat().st_size // 1024
            logger.info(f"🎯 Sprite sheet: {sprite_size}KB")

        if hasattr(result, "thumbnails_360") and result.thumbnails_360:
            logger.info(f"🌐 360° thumbnails: {len(result.thumbnails_360)}")


async def demo_async_processing():
    """Demonstrate asynchronous video processing with Procrastinate."""
    logger.info("⚡ Starting Asynchronous Processing Demo")

    # Get database URL from environment
    database_url = os.environ.get(
        "PROCRASTINATE_DATABASE_URL",
        "postgresql://video_user:video_password@postgres:5432/video_processor",
    )

    try:
        # Show version info
        version_info = get_version_info()
        logger.info(f"📦 Using Procrastinate {version_info['procrastinate_version']}")

        # Run migrations
        logger.info("🔄 Running database migrations...")
        migration_success = await migrate_database(database_url)

        if not migration_success:
            logger.error("❌ Database migration failed")
            return

        logger.info("✅ Database migrations completed")

        # Set up Procrastinate
        app = setup_procrastinate(database_url)

        with tempfile.TemporaryDirectory() as temp_dir:
            temp_path = Path(temp_dir)

            # Create sample video
            sample_video = await create_sample_video(temp_path)

            # Configure processing
            config_dict = {
                "base_path": str(temp_path),
                "output_formats": ["mp4"],
                "quality_preset": "fast",
                "generate_thumbnails": True,
                "sprite_interval": 5,
            }

            async with app.open_async() as app_context:
                # Submit video processing task
                logger.info("📤 Submitting async video processing job...")

                job = await app_context.configure_task(
                    "process_video_async", queue="video_processing"
                ).defer_async(
                    input_path=str(sample_video),
                    output_dir=str(temp_path / "async_outputs"),
                    config_dict=config_dict,
                )

                logger.info(f"✅ Job submitted with ID: {job.id}")
                logger.info("🔄 Job will be processed by background worker...")

                # In a real app, you would monitor job status or use webhooks
                # For demo purposes, we'll just show the job was submitted

                # Submit additional tasks
                logger.info("📤 Submitting thumbnail generation job...")

                thumb_job = await app_context.configure_task(
                    "generate_thumbnail_async", queue="thumbnail_generation"
                ).defer_async(
                    video_path=str(sample_video),
                    output_dir=str(temp_path / "thumbnails"),
                    timestamp=5,
                    video_id="demo_thumb",
                )

                logger.info(f"✅ Thumbnail job submitted: {thumb_job.id}")

    except Exception as e:
        logger.error(f"❌ Async processing demo failed: {e}")
        raise


async def demo_migration_features():
    """Demonstrate migration utilities."""
    logger.info("🔄 Migration Features Demo")

    from video_processor.tasks.migration import ProcrastinateMigrationHelper

    database_url = os.environ.get(
        "PROCRASTINATE_DATABASE_URL",
        "postgresql://video_user:video_password@postgres:5432/video_processor",
    )

    # Show migration plan
    helper = ProcrastinateMigrationHelper(database_url)
    helper.print_migration_plan()

    # Show version-specific features
    version_info = get_version_info()
    logger.info("🆕 Available Features:")
    for feature, available in version_info["features"].items():
        status = "✅" if available else "❌"
        logger.info(f"  {status} {feature}")


async def main():
    """Run all demo scenarios."""
    logger.info("🚀 Video Processor Docker Demo Starting...")

    try:
        # Run demos in sequence
        await demo_sync_processing()
        await demo_async_processing()
        await demo_migration_features()

        logger.info("🎉 All demos completed successfully!")

        # Keep the container running to show logs
        logger.info(
            "📋 Demo completed. Container will keep running for log inspection..."
        )
        logger.info("💡 Check the logs with: docker-compose logs app")
        logger.info("🛑 Stop with: docker-compose down")

        # Keep running for log inspection
        while True:
            await asyncio.sleep(30)
            logger.info("💓 Demo container heartbeat - still running...")

    except KeyboardInterrupt:
        logger.info("🛑 Demo interrupted by user")
    except Exception as e:
        logger.error(f"❌ Demo failed: {e}")
        raise


if __name__ == "__main__":
    asyncio.run(main())