app.py

#!/usr/bin/env python3
"""
AI Video Generator with Gradio - WaveSpeed API Version
Single file application - app.py
"""

import os
import gradio as gr
import requests
import json
import time
import base64
from PIL import Image
import io
from datetime import datetime
import tempfile

# Try to import video processing libraries for watermark
try:
    import cv2
    import numpy as np
    VIDEO_PROCESSING_AVAILABLE = True
except ImportError:
    VIDEO_PROCESSING_AVAILABLE = False
    print("Warning: cv2 not available. Watermark feature will be disabled.")

# API keys setup from environment variables
API_KEY_T2V = os.getenv("WAVESPEED_API_KEY_T2V", "946b77acd6a456dfde349aa0bac7b6d2bdf9c0c995fff072898c6d8734f866c4")
API_KEY_I2V = os.getenv("WAVESPEED_API_KEY_I2V", "5a90eaa7ded95066c07adf55b91185a83abfa8db3fdc74d12ba5ad66db1d68fe")

# API endpoints
API_BASE_URL = "https://api.wavespeed.ai/api/v3"
T2V_ENDPOINT = f"{API_BASE_URL}/bytedance/seedance-v1-lite-t2v-480p"
I2V_ENDPOINT = f"{API_BASE_URL}/bytedance/seedance-v1-lite-i2v-480p"

# Aspect ratio options
ASPECT_RATIOS = {
    "16:9": "16:9 (YouTube, Standard Video)",
    "4:3": "4:3 (Traditional TV Format)",
    "1:1": "1:1 (Instagram Feed)",
    "3:4": "3:4 (Instagram Portrait)",
    "9:16": "9:16 (Instagram Reels, TikTok)",
    "21:9": "21:9 (Cinematic Wide)",
    "9:21": "9:21 (Ultra Vertical)"
}

# Default prompts
DEFAULT_TEXT_PROMPT = ""
DEFAULT_IMAGE_PROMPT = "Generate a video with smooth and natural movement. Objects should have visible motion while maintaining fluid transitions."

def add_watermark_cv2(input_video_path, output_video_path):
    """Add watermark to video using OpenCV"""
    if not VIDEO_PROCESSING_AVAILABLE:
        return False
    
    try:
        cap = cv2.VideoCapture(input_video_path)
        fps = int(cap.get(cv2.CAP_PROP_FPS))
        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
        
        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
        out = cv2.VideoWriter(output_video_path, fourcc, fps, (width, height))
        
        watermark_text = "ginigen.com"
        font = cv2.FONT_HERSHEY_SIMPLEX
        font_scale = max(0.4, height * 0.001)
        font_thickness = max(1, int(height * 0.002))
        
        (text_width, text_height), baseline = cv2.getTextSize(watermark_text, font, font_scale, font_thickness)
        padding = int(width * 0.02)
        x = width - text_width - padding
        y = height - padding
        
        while True:
            ret, frame = cap.read()
            if not ret:
                break
            
            overlay = frame.copy()
            cv2.rectangle(overlay, 
                         (x - 5, y - text_height - 5), 
                         (x + text_width + 5, y + 5), 
                         (0, 0, 0), 
                         -1)
            frame = cv2.addWeighted(frame, 0.7, overlay, 0.3, 0)
            cv2.putText(frame, watermark_text, (x, y), font, font_scale, (255, 255, 255), font_thickness, cv2.LINE_AA)
            out.write(frame)
        
        cap.release()
        out.release()
        cv2.destroyAllWindows()
        return True
        
    except Exception as e:
        print(f"Watermark error: {str(e)}")
        return False

def add_watermark(input_video_path, output_video_path):
    """Add watermark to video"""
    if VIDEO_PROCESSING_AVAILABLE:
        success = add_watermark_cv2(input_video_path, output_video_path)
        if success:
            return True
    
    # Fallback - just copy without watermark
    try:
        import shutil
        shutil.copy2(input_video_path, output_video_path)
        return False
    except:
        return False

def compress_image(image, max_size_mb=2, max_dimension=1920):
    """Compress and resize image to meet size requirements"""
    # Convert to RGB if necessary
    if image.mode in ('RGBA', 'LA'):
        rgb_image = Image.new('RGB', image.size, (255, 255, 255))
        rgb_image.paste(image, mask=image.split()[-1] if image.mode == 'RGBA' else None)
        image = rgb_image
    elif image.mode not in ('RGB', 'L'):
        image = image.convert('RGB')
    
    # Resize if dimensions are too large
    width, height = image.size
    if width > max_dimension or height > max_dimension:
        ratio = min(max_dimension / width, max_dimension / height)
        new_width = int(width * ratio)
        new_height = int(height * ratio)
        image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
    
    # Compress with varying quality to meet size requirement
    quality = 95
    while quality > 20:
        buffered = io.BytesIO()
        image.save(buffered, format="JPEG", quality=quality, optimize=True)
        size_mb = len(buffered.getvalue()) / (1024 * 1024)
        
        if size_mb <= max_size_mb:
            return buffered.getvalue()
        
        quality -= 5
    
    # If still too large, resize more aggressively
    width, height = image.size
    image = image.resize((width // 2, height // 2), Image.Resampling.LANCZOS)
    buffered = io.BytesIO()
    image.save(buffered, format="JPEG", quality=50, optimize=True)
    return buffered.getvalue()

def update_prompt_placeholder(mode):
    """Update prompt placeholder based on mode"""
    if mode == "Text to Video":
        return gr.update(
            placeholder="Describe the video you want to create.\nExample: The sun rises slowly between tall buildings. [Ground-level follow shot] Bicycle tires roll over a dew-covered street at dawn.",
            value=""
        )
    else:
        return gr.update(
            placeholder="Describe how the image should move.\nExample: Camera slowly zooms in while clouds move across the sky. The subject's hair gently moves in the wind.",
            value=DEFAULT_IMAGE_PROMPT
        )

def update_image_input(mode):
    """Show/hide image input based on mode"""
    if mode == "Image to Video":
        # Show image input, hide aspect ratio for I2V
        return gr.update(visible=True), gr.update(visible=False)
    else:
        # Hide image input, show aspect ratio for T2V
        return gr.update(visible=False), gr.update(visible=True)

def poll_for_result(request_id, api_key, progress_callback=None):
    """Poll WaveSpeed API for video generation result"""
    url = f"{API_BASE_URL}/predictions/{request_id}/result"
    headers = {"Authorization": f"Bearer {api_key}"}
    
    start_time = time.time()
    while True:
        try:
            response = requests.get(url, headers=headers, timeout=30)
            
            if response.status_code == 200:
                result = response.json()["data"]
                status = result["status"]
                
                elapsed = time.time() - start_time
                if progress_callback:
                    progress_val = min(0.3 + (elapsed / 120) * 0.6, 0.9)
                    progress_callback(progress_val, desc=f"Processing... Status: {status} ({int(elapsed)}s)")
                
                if status == "completed":
                    video_url = result["outputs"][0]
                    return True, video_url
                elif status == "failed":
                    error_msg = result.get('error', 'Unknown error')
                    return False, f"Generation failed: {error_msg}"
                elif elapsed > 300:  # 5 minute timeout
                    return False, "Timeout: Generation took too long"
                
                # Continue polling
                time.sleep(2)
            else:
                return False, f"API Error: {response.status_code} - {response.text}"
                
        except Exception as e:
            return False, f"Connection error: {str(e)}"

def generate_video(mode, prompt, image_url, image_file, aspect_ratio, seed, api_key_override_t2v, api_key_override_i2v, progress=gr.Progress()):
    """Main video generation function using WaveSpeed API"""
    
    # Input validation
    if not prompt:
        return None, "❌ Please enter a prompt."
    
    if mode == "Image to Video":
        if not image_url and image_file is None:
            return None, "❌ Please provide an image URL or upload an image."
    
    try:
        progress(0, desc="Preparing request...")
        
        # Determine which API to use
        if mode == "Text to Video":
            api_key = api_key_override_t2v or API_KEY_T2V
            endpoint = T2V_ENDPOINT
            
            payload = {
                "aspect_ratio": aspect_ratio,
                "duration": 5,
                "prompt": prompt,
                "seed": seed if seed >= 0 else -1
            }
        else:  # Image to Video
            api_key = api_key_override_i2v or API_KEY_I2V
            endpoint = I2V_ENDPOINT
            
            # Handle image input
            if image_url:
                # Use provided URL directly
                final_image_url = image_url
            elif image_file is not None:
                # Compress image to reduce size
                try:
                    # Get original size
                    orig_buffered = io.BytesIO()
                    image_file.save(orig_buffered, format="PNG")
                    orig_size_mb = len(orig_buffered.getvalue()) / (1024 * 1024)
                    
                    progress(0.1, desc=f"Compressing image (Original: {orig_size_mb:.1f}MB)...")
                    
                    compressed_data = compress_image(image_file, max_size_mb=2, max_dimension=1920)
                    compressed_size_mb = len(compressed_data) / (1024 * 1024)
                    
                    progress(0.15, desc=f"Image compressed: {orig_size_mb:.1f}MB → {compressed_size_mb:.1f}MB")
                    
                    image_base64 = base64.b64encode(compressed_data).decode()
                    
                    # Check encoded size
                    encoded_size_mb = len(image_base64) / (1024 * 1024)
                    if encoded_size_mb > 20:  # Conservative limit for base64
                        return None, f"""❌ Image too large even after compression.

Original size: {orig_size_mb:.1f}MB
Compressed size: {compressed_size_mb:.1f}MB
Encoded size: {encoded_size_mb:.1f}MB (exceeds API limit)

Please use an image hosting service:
1. Go to [imgur.com](https://imgur.com)
2. Upload your image (drag & drop)
3. Right-click uploaded image → "Copy image address"
4. Paste URL in the Image URL field above"""
                    
                    # Try data URL format
                    final_image_url = f"data:image/jpeg;base64,{image_base64}"
                    
                except Exception as e:
                    return None, f"❌ Error processing image: {str(e)}"
            else:
                return None, "❌ No image provided."
            
            payload = {
                "duration": 5,
                "image": final_image_url,
                "prompt": prompt,
                "seed": seed if seed >= 0 else -1
            }
        
        # Submit request
        progress(0.2, desc="Submitting request to WaveSpeed AI...")
        
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {api_key}"
        }
        
        response = requests.post(endpoint, headers=headers, data=json.dumps(payload), timeout=30)
        
        if response.status_code == 200:
            result = response.json()["data"]
            request_id = result["id"]
            progress(0.3, desc=f"Request submitted. ID: {request_id}")
        else:
            error_detail = response.text
            if mode == "Image to Video" and image_file is not None and not image_url:
                # Check if it's a size limit error
                if "size exceeds" in error_detail or "30MB" in error_detail:
                    return None, f"""❌ Image size exceeds API limit (30MB).

Your image was compressed but still too large for the API.

**Please use an image hosting service instead:**
1. Go to [imgur.com](https://imgur.com) (no account needed)
2. Click "New post" → Drop your image
3. After upload, right-click the image → "Copy image address"
4. Paste the URL in the Image URL field above

Alternative services:
- [imgbb.com](https://imgbb.com) - Simple, no account needed
- [postimages.org](https://postimages.org) - Direct links available

Error: {response.status_code}"""
                else:
                    return None, f"""❌ API Error: {response.status_code}

The API does not accept base64 data URLs. Please use a direct image URL instead:

1. Upload your image to [imgur.com](https://imgur.com)
2. Copy the direct image URL (ends with .jpg or .png)
3. Paste it in the Image URL field above

Error details: {error_detail}"""
            else:
                return None, f"❌ API Error: {response.status_code} - {error_detail}"
        
        # Poll for result
        success, result = poll_for_result(request_id, api_key, lambda p, desc: progress(p, desc=desc))
        
        if not success:
            return None, f"❌ {result}"
        
        video_url = result
        progress(0.9, desc="Downloading video...")
        
        # Download video
        video_response = requests.get(video_url, timeout=60)
        if video_response.status_code != 200:
            return None, f"❌ Failed to download video from {video_url}"
        
        video_data = video_response.content
        
        # Save to temporary file
        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
            tmp_file.write(video_data)
            temp_video_path = tmp_file.name
        
        # Try to add watermark
        watermark_added = False
        final_video_path = temp_video_path
        
        if VIDEO_PROCESSING_AVAILABLE:
            progress(0.95, desc="Adding watermark...")
            final_video_path = tempfile.mktemp(suffix='.mp4')
            watermark_added = add_watermark(temp_video_path, final_video_path)
            
            if not watermark_added or not os.path.exists(final_video_path):
                final_video_path = temp_video_path
        
        # Save final video
        with open(final_video_path, "rb") as f:
            final_video_data = f.read()
        with open("output.mp4", "wb") as file:
            file.write(final_video_data)
        
        # Clean up temp files
        if temp_video_path != final_video_path and os.path.exists(temp_video_path):
            try:
                os.unlink(temp_video_path)
            except:
                pass
        
        progress(1.0, desc="Complete!")
        
        # Generation info
        watermark_status = "Added" if watermark_added else "Not available (cv2 not installed)" if not VIDEO_PROCESSING_AVAILABLE else "Failed"
        
        # Add image info if applicable
        image_info = ""
        if mode == "Image to Video":
            if image_url:
                image_info = "\n- Image Source: URL provided"
            elif image_file:
                image_info = "\n- Image Source: Uploaded & compressed"
        
        info = f"""✅ Video generated successfully!

📊 Generation Info:
- Mode: {mode}
- Aspect Ratio: {aspect_ratio if mode == "Text to Video" else "N/A"}{image_info}
- Seed: {seed}
- Duration: 5 seconds
- Resolution: 480p
- Watermark: {watermark_status}
- API: WaveSpeed AI
- File: output.mp4"""
        
        return final_video_path, info
        
    except requests.exceptions.Timeout:
        return None, "⏱️ Request timed out. Please try again."
    except Exception as e:
        return None, f"❌ Error occurred: {str(e)}"

# Gradio interface
with gr.Blocks(title="Bytedance Seedance Video Free", theme=gr.themes.Soft()) as app:
    gr.Markdown("""
    # 🎬 Bytedance Seedance Video' Free
    
    Generate videos from text or images using **API**.
    
    [![Powered by Ginigen](https://img.shields.io/badge/Powered%20by-Ginigen)](https://ginigen.com/)
    
    """)
    
    with gr.Row():
        with gr.Column(scale=1):
            # API Settings
            with gr.Accordion("⚙️ API Settings", open=False):
                gr.Markdown("""
                API keys are loaded from environment variables:
                - `WS_API_KEY_T2V` for Text-to-Video
                - `WS_API_KEY_I2V` for Image-to-Video
                
                You can override them below if needed.
                """)
                
                api_key_override_t2v = gr.Textbox(
                    label="Text-to-Video API Key (Optional Override)",
                    type="password",
                    placeholder="Leave empty to use environment variable",
                    value=""
                )
                
                api_key_override_i2v = gr.Textbox(
                    label="Image-to-Video API Key (Optional Override)",
                    type="password",
                    placeholder="Leave empty to use environment variable",
                    value=""
                )
            
            # Generation mode
            mode = gr.Radio(
                label="🎯 Generation Mode",
                choices=["Text to Video", "Image to Video"],
                value="Text to Video"
            )
            
            # Image input - URL or file
            with gr.Column(visible=False) as image_input_group:
                gr.Markdown("### Image Input")
                image_url_input = gr.Textbox(
                    label="📷 Image URL (Recommended) - Direct image URL works best",
                    placeholder="https://example.com/image.jpg"
                )
                gr.Markdown("**OR**")
                image_file_input = gr.Image(
                    label="📤 Upload Image (Will be compressed, max 2MB after compression)",
                    type="pil"
                )
                gr.Markdown("""
                ⚠️ **Note**: API has a 30MB limit. Large images will be compressed.
                If upload fails, use [imgur.com](https://imgur.com) to host your image.
                """)
            
            # Aspect ratio (only for T2V)
            aspect_ratio = gr.Dropdown(
                label="📐 Aspect Ratio (Text to Video only)",
                choices=list(ASPECT_RATIOS.keys()),
                value="16:9",
                info="Choose ratio optimized for social media platforms",
                visible=True
            )
            
            # Ratio description
            ratio_info = gr.Markdown(value=f"Selected ratio: {ASPECT_RATIOS['16:9']}")
            
            # Seed setting
            seed = gr.Number(
                label="🎲 Random Seed",
                value=-1,
                precision=0,
                info="Use -1 for random, or set a specific value for reproducible results"
            )
            
            # Fixed settings display
            watermark_info = "ginigen.com" if VIDEO_PROCESSING_AVAILABLE else "ginigen.com (requires cv2)"
            gr.Markdown(f"""
            ### 📋 Fixed Settings
            - **Duration**: 5 seconds
            - **Resolution**: 480p
            - **Watermark**: {watermark_info}
            """)
        
        with gr.Column(scale=2):
            # Prompt input
            prompt = gr.Textbox(
                label="✍️ Prompt",
                lines=5,
                placeholder="Describe the video you want to create.\nExample: The sun rises slowly between tall buildings. [Ground-level follow shot] Bicycle tires roll over a dew-covered street at dawn.",
                value=""
            )
            
            # Generate button
            generate_btn = gr.Button("🎬 Generate Video", variant="primary", size="lg")
            
            # Results display
            with gr.Column():
                output_video = gr.Video(
                    label="📹 Generated Video",
                    autoplay=True
                )
                output_info = gr.Textbox(
                    label="Information",
                    lines=10,
                    interactive=False
                )
    
    
    # Examples
    gr.Examples(
        examples=[
            ["Text to Video", "A cat walking gracefully across a sunlit room", "", None, "16:9", -1],
            ["Text to Video", "A serene lake at sunrise with mist rolling over the water. Camera slowly pans across the landscape as birds fly overhead.", "", None, "16:9", 42],
            ["Text to Video", "Urban street scene at night with neon lights reflecting on wet pavement. People walking with umbrellas, camera tracking forward.", "", None, "9:16", 123],
        ],
        inputs=[mode, prompt, image_url_input, image_file_input, aspect_ratio, seed],
        label="Example Prompts"
    )
    
    # Event handlers
    mode.change(
        fn=update_prompt_placeholder,
        inputs=[mode],
        outputs=[prompt]
    )
    
    mode.change(
        fn=update_image_input,
        inputs=[mode],
        outputs=[image_input_group, aspect_ratio]
    )
    
    aspect_ratio.change(
        fn=lambda x: f"Selected ratio: {ASPECT_RATIOS[x]}",
        inputs=[aspect_ratio],
        outputs=[ratio_info]
    )
    
    generate_btn.click(
        fn=generate_video,
        inputs=[mode, prompt, image_url_input, image_file_input, aspect_ratio, seed, api_key_override_t2v, api_key_override_i2v],
        outputs=[output_video, output_info]
    )

# Run app
if __name__ == "__main__":
    app.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=False,
        inbrowser=True
    )