Ai Video Gen

#!/usr/bin/env python3
"""
Add voiceover to existing video
"""

import argparse
import subprocess
import sys
import os
from pathlib import Path
from dotenv import load_dotenv

load_dotenv()


def generate_audio(text, voice="alloy", output_path="voiceover.mp3"):
    """Generate audio using OpenAI TTS"""
    OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
    
    if not OPENAI_API_KEY:
        print("❌ Error: OPENAI_API_KEY not set")
        sys.exit(1)
    
    import openai
    client = openai.OpenAI(api_key=OPENAI_API_KEY)
    
    print(f"🎤 Generating voiceover...")
    
    response = client.audio.speech.create(
        model="tts-1",
        voice=voice,
        input=text
    )
    
    response.stream_to_file(output_path)
    print(f"✓ Audio saved: {output_path}")
    return output_path


def add_audio_to_video(video_path, audio_path, output_path, mix_audio=False):
    """Combine video with audio using FFmpeg"""
    
    print(f"🎞️ Adding audio to video...")
    
    if mix_audio:
        # Mix new audio with existing audio
        cmd = [
            'ffmpeg', '-y',
            '-i', video_path,
            '-i', audio_path,
            '-filter_complex', '[0:a][1:a]amix=inputs=2:duration=longest',
            '-c:v', 'copy',
            output_path
        ]
    else:
        # Replace audio
        cmd = [
            'ffmpeg', '-y',
            '-i', video_path,
            '-i', audio_path,
            '-c:v', 'copy',
            '-c:a', 'aac',
            '-map', '0:v:0',
            '-map', '1:a:0',
            '-shortest',
            output_path
        ]
    
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        print(f"✅ Video with audio created: {output_path}")
        return output_path
    except subprocess.CalledProcessError as e:
        print(f"❌ FFmpeg error: {e.stderr}")
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(description='Add voiceover to video')
    parser.add_argument('--video', required=True, help='Input video file')
    parser.add_argument('--text', help='Text for voiceover')
    parser.add_argument('--audio', help='Pre-existing audio file (alternative to --text)')
    parser.add_argument('--output', default='output_with_audio.mp4', help='Output video file')
    parser.add_argument('--voice', default='alloy', 
                       choices=['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'],
                       help='OpenAI TTS voice')
    parser.add_argument('--mix', action='store_true', 
                       help='Mix with existing audio instead of replacing')
    
    args = parser.parse_args()
    
    # Validate video exists
    if not Path(args.video).exists():
        print(f"❌ Error: Video not found: {args.video}")
        sys.exit(1)
    
    # Get or generate audio
    if args.audio:
        if not Path(args.audio).exists():
            print(f"❌ Error: Audio file not found: {args.audio}")
            sys.exit(1)
        audio_path = args.audio
    elif args.text:
        audio_path = generate_audio(args.text, args.voice)
    else:
        print("❌ Error: Must provide either --text or --audio")
        sys.exit(1)
    
    # Combine video and audio
    add_audio_to_video(args.video, audio_path, args.output, args.mix)
    
    # Clean up temp audio if we generated it
    if args.text and not args.audio:
        Path(audio_path).unlink(missing_ok=True)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
AI Video Generator - End-to-end video creation from text prompts
Supports: OpenAI DALL-E, Replicate, LumaAI, Runway, FFmpeg
"""

import os
import sys
import argparse
import json
import time
import requests
from pathlib import Path
from dotenv import load_dotenv

load_dotenv()

# API clients
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
REPLICATE_API_TOKEN = os.getenv('REPLICATE_API_TOKEN')
LUMAAI_API_KEY = os.getenv('LUMAAI_API_KEY')
RUNWAY_API_KEY = os.getenv('RUNWAY_API_KEY')
ELEVENLABS_API_KEY = os.getenv('ELEVENLABS_API_KEY')


class VideoGenerator:
    def __init__(self, output_dir='output'):
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True)
        
    def generate_image_openai(self, prompt, size="1024x1024"):
        """Generate image using DALL-E 3"""
        if not OPENAI_API_KEY:
            raise ValueError("OPENAI_API_KEY not set")
            
        import openai
        client = openai.OpenAI(api_key=OPENAI_API_KEY)
        
        print(f"🎨 Generating image with DALL-E 3: {prompt[:50]}...")
        
        response = client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size=size,
            quality="standard",
            n=1,
        )
        
        image_url = response.data[0].url
        
        # Download image
        img_path = self.output_dir / f"image_{int(time.time())}.png"
        img_data = requests.get(image_url).content
        with open(img_path, 'wb') as f:
            f.write(img_data)
            
        print(f"✓ Image saved: {img_path}")
        return str(img_path)
    
    def generate_image_replicate(self, prompt, model="stability-ai/sdxl"):
        """Generate image using Replicate (Stable Diffusion, Flux, etc.)"""
        if not REPLICATE_API_TOKEN:
            raise ValueError("REPLICATE_API_TOKEN not set")
            
        import replicate
        
        print(f"🎨 Generating image with {model}: {prompt[:50]}...")
        
        output = replicate.run(
            model,
            input={"prompt": prompt}
        )
        
        # Download image
        img_path = self.output_dir / f"image_{int(time.time())}.png"
        if isinstance(output, list):
            img_data = requests.get(output[0]).content
        else:
            img_data = requests.get(output).content
            
        with open(img_path, 'wb') as f:
            f.write(img_data)
            
        print(f"✓ Image saved: {img_path}")
        return str(img_path)
    
    def image_to_video_luma(self, image_path, prompt=None):
        """Convert image to video using LumaAI"""
        if not LUMAAI_API_KEY:
            raise ValueError("LUMAAI_API_KEY not set")
            
        print(f"🎬 Creating video from image with LumaAI...")
        
        headers = {
            "Authorization": f"Bearer {LUMAAI_API_KEY}",
            "Content-Type": "application/json"
        }
        
        # Upload image and create video
        # This is a placeholder - actual LumaAI API structure may vary
        data = {
            "image": image_path,
            "prompt": prompt or "animate this image"
        }
        
        response = requests.post(
            "https://api.lumalabs.ai/dream-machine/v1/generations",
            headers=headers,
            json=data
        )
        
        if response.status_code != 200:
            raise Exception(f"LumaAI API error: {response.text}")
            
        generation_id = response.json()['id']
        
        # Poll for completion
        while True:
            status = requests.get(
                f"https://api.lumalabs.ai/dream-machine/v1/generations/{generation_id}",
                headers=headers
            ).json()
            
            if status['state'] == 'completed':
                video_url = status['video']['url']
                break
            elif status['state'] == 'failed':
                raise Exception(f"Video generation failed: {status}")
            
            print("⏳ Waiting for video generation...")
            time.sleep(5)
        
        # Download video
        video_path = self.output_dir / f"video_{int(time.time())}.mp4"
        video_data = requests.get(video_url).content
        with open(video_path, 'wb') as f:
            f.write(video_data)
            
        print(f"✓ Video saved: {video_path}")
        return str(video_path)
    
    def add_audio_openai(self, text, voice="alloy"):
        """Generate audio using OpenAI TTS"""
        if not OPENAI_API_KEY:
            raise ValueError("OPENAI_API_KEY not set")
            
        import openai
        client = openai.OpenAI(api_key=OPENAI_API_KEY)
        
        print(f"🎤 Generating voiceover: {text[:50]}...")
        
        response = client.audio.speech.create(
            model="tts-1",
            voice=voice,
            input=text
        )
        
        audio_path = self.output_dir / f"audio_{int(time.time())}.mp3"
        response.stream_to_file(str(audio_path))
        
        print(f"✓ Audio saved: {audio_path}")
        return str(audio_path)
    
    def combine_video_audio(self, video_path, audio_path, output_path):
        """Combine video and audio using FFmpeg"""
        import subprocess
        
        print(f"🎞️ Combining video and audio...")
        
        cmd = [
            'ffmpeg', '-y',
            '-i', video_path,
            '-i', audio_path,
            '-c:v', 'copy',
            '-c:a', 'aac',
            '-shortest',
            output_path
        ]
        
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        if result.returncode != 0:
            raise Exception(f"FFmpeg error: {result.stderr}")
            
        print(f"✓ Final video saved: {output_path}")
        return output_path


def main():
    parser = argparse.ArgumentParser(description='Generate AI videos from text prompts')
    parser.add_argument('--prompt', required=True, help='Text prompt for video generation')
    parser.add_argument('--voiceover', help='Text for voiceover narration')
    parser.add_argument('--output', default='output.mp4', help='Output video file')
    parser.add_argument('--image-model', choices=['dalle', 'replicate'], default='dalle', help='Image generation model')
    parser.add_argument('--video-model', choices=['luma', 'runway'], default='luma', help='Video generation model')
    parser.add_argument('--voice', default='alloy', help='Voice for TTS (alloy, echo, fable, onyx, nova, shimmer)')
    
    args = parser.parse_args()
    
    try:
        generator = VideoGenerator()
        
        # Step 1: Generate image
        if args.image_model == 'dalle':
            image_path = generator.generate_image_openai(args.prompt)
        else:
            image_path = generator.generate_image_replicate(args.prompt)
        
        # Step 2: Convert to video
        if args.video_model == 'luma':
            video_path = generator.image_to_video_luma(image_path, args.prompt)
        else:
            print("⚠️ Runway support coming soon. Using Luma for now.")
            video_path = generator.image_to_video_luma(image_path, args.prompt)
        
        # Step 3: Add voiceover if requested
        if args.voiceover:
            audio_path = generator.add_audio_openai(args.voiceover, args.voice)
            final_path = generator.combine_video_audio(video_path, audio_path, args.output)
        else:
            # Just rename/move the video
            os.rename(video_path, args.output)
            final_path = args.output
        
        print(f"\n✅ SUCCESS! Video created: {final_path}")
        
    except Exception as e:
        print(f"\n❌ ERROR: {str(e)}")
        sys.exit(1)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Convert image sequence to video using FFmpeg
"""

import argparse
import subprocess
import sys
from pathlib import Path


def images_to_video(image_files, output_path, fps=24, quality='high'):
    """Convert list of images to video"""
    
    # Quality presets
    crf_values = {
        'low': 28,
        'medium': 23,
        'high': 18,
        'ultra': 15
    }
    crf = crf_values.get(quality, 18)
    
    print(f"🎬 Creating video from {len(image_files)} images at {fps} fps...")
    
    # Create temporary file list
    file_list_path = Path('filelist.txt')
    with open(file_list_path, 'w') as f:
        for img in image_files:
            duration = 1.0 / fps
            f.write(f"file '{Path(img).absolute()}'\n")
            f.write(f"duration {duration}\n")
    
    # FFmpeg command
    cmd = [
        'ffmpeg', '-y',
        '-f', 'concat',
        '-safe', '0',
        '-i', str(file_list_path),
        '-vsync', 'vfr',
        '-pix_fmt', 'yuv420p',
        '-crf', str(crf),
        output_path
    ]
    
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        print(f"✅ Video created: {output_path}")
        return output_path
    except subprocess.CalledProcessError as e:
        print(f"❌ FFmpeg error: {e.stderr}")
        sys.exit(1)
    finally:
        # Clean up temp file
        if file_list_path.exists():
            file_list_path.unlink()


def main():
    parser = argparse.ArgumentParser(description='Convert images to video')
    parser.add_argument('--images', nargs='+', required=True, help='Input image files')
    parser.add_argument('--output', default='output.mp4', help='Output video file')
    parser.add_argument('--fps', type=int, default=24, help='Frames per second')
    parser.add_argument('--quality', choices=['low', 'medium', 'high', 'ultra'], 
                       default='high', help='Output quality')
    
    args = parser.parse_args()
    
    # Validate images exist
    for img in args.images:
        if not Path(img).exists():
            print(f"❌ Error: Image not found: {img}")
            sys.exit(1)
    
    images_to_video(args.images, args.output, args.fps, args.quality)


if __name__ == '__main__':
    main()

openai>=1.0.0
replicate>=0.20.0
requests>=2.31.0
pillow>=10.0.0
python-dotenv>=1.0.0