Initial commit: Content automation system framework

.env.example

@@ -0,0 +1,10 @@
+# API Keys - Fill these with your actual keys
+GEMINI_API_KEY=your_gemini_api_key_here
+RUNWAYML_API_KEY=your_runwayml_api_key_here
+TTS_API_KEY=your_tts_api_key_here
+GCS_BUCKET_NAME=your_bucket_name_here
+
+# Configuration
+AUDIO_LIBRARY_SIZE=27
+VIDEO_LIBRARY_SIZE=47
+DEFAULT_VOICE=en-US-AriaNeural

.gitattributes

@@ -0,0 +1,11 @@
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
+*.db filter=lfs diff=lfs merge=lfs -text
+sliding_puzzle filter=lfs diff=lfs merge=lfs -text
+stockfish/stockfish-ubuntu-x86-64-avx2 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,29 @@
+# Environment variables
+.env
+*.env
+.venv
+
+# API keys
+*_key.txt
+*_secret.yaml
+
+# Output files
+outputs/videos/*
+!outputs/videos/.gitkeep
+outputs/logs/*.log
+
+# Temporary files
+*.tmp
+*.temp
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.DS_Store
+.thumbs.db
+
+# Large files
+*.mp4
+*.mp3
+*.wav
+*.avi

README.md

@@ -0,0 +1,25 @@
+# Content Automation System
+A Python-based automated video content creation system that generates videos using AI APIs, selects relevant footage from a library, adds text-to-speech audio, and produces finished videos with subtitles.
+
+## Quick Start
+
+### Prerequisites
+- Python 3.8+
+- API keys for:
+  - Google Gemini
+  - RunwayML
+  - Text-to-Speech service (Azure/Google/Amazon)
+  - Google Cloud Storage
+
+### Installation
+
+```bash
+git clone <your-repo>
+cd content-automation
+python -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+cp .env.example .env
+# Edit .env with your actual API keys
+python src/main.py
+```

config/api_keys.yaml

@@ -0,0 +1,17 @@
+# API Configuration
+gemini:
+  base_url: "https://generativelanguage.googleapis.com/v1beta"
+  model: "gemini-pro"
+
+runwayml:
+  base_url: "https://api.runwayml.com/v1"
+  timeout: 300
+
+tts:
+  provider: "azure"  # or "google", "amazon"
+  voice: "en-US-AriaNeural"
+  rate: "medium"
+
+gcs:
+  bucket: "somira-videos"
+  video_prefix: "automated-content/"

config/content_strategies.yaml

@@ -0,0 +1,32 @@
+# Content Strategies Template
+commercial:
+  gemini_prompt_template: |
+    A photorealistic, comical yet painfully real depiction of {subject} 
+    in a {setting}. {style_notes}. Format: {aspect_ratio}.
+  
+  runway_prompt_template: |
+    {camera_movement}: {action}. {scene_description}. 
+    {style_notes}. Vertical {aspect_ratio}.
+  
+  styles:
+    - name: "commercial"
+      camera_movement: "Slow push-in camera"
+      style_notes: "Photorealistic, cinematic, bright high-key lighting"
+    
+    - name: "educational"  
+      camera_movement: "Static shot"
+      style_notes: "Clean, professional, even lighting"
+
+# Video library metadata
+video_categories:
+  product_demo:
+    tags: ["somira massager", "product", "demo"]
+    usage: "When script mentions product features or demonstration"
+  
+  solution_highlight:
+    tags: ["solution", "relief", "comfort"] 
+    usage: "When script discusses problem-solving or benefits"
+  
+  customer_experience:
+    tags: ["satisfaction", "experience", "testimonial"]
+    usage: "When script shares customer stories or results"

requirements.txt

@@ -0,0 +1,9 @@
+aiohttp>=3.8.0
+google-cloud-storage>=2.0.0
+moviepy>=1.0.3
+openai>=1.0.0
+python-dotenv>=1.0.0
+pyyaml>=6.0
+asyncio>=3.4.3
+pillow>=9.0.0
+numpy>=1.21.0

setup.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+echo "Setting up Content Automation System..."
+
+# Create directories
+mkdir -p config src assets/video_library assets/audio_library outputs/videos outputs/logs
+
+# Run all the creation commands from above (you'd paste all the cat commands here)
+# [Paste all the file creation commands from above here]
+
+echo "✅ Setup complete!"
+echo "📝 Next steps:"
+echo "1. Edit .env with your API keys"
+echo "2. Run: pip install -r requirements.txt" 
+echo "3. Run: python src/main.py"

src/api_clients.py

@@ -0,0 +1,70 @@
+"""
+API clients for external services
+"""
+import aiohttp
+import json
+from utils import logger
+
+class APIClients:
+    def __init__(self, config):
+        self.config = config
+        
+    async def enhance_prompt(self, prompt):
+        """Enhance prompt using Gemini API"""
+        # Simplified implementation - replace with actual API call
+        logger.info(f"Enhancing prompt: {prompt[:100]}...")
+        return prompt  # Placeholder
+    
+    async def generate_video(self, prompt):
+        """Generate video using RunwayML API"""
+        # Simplified implementation - replace with actual API call
+        logger.info(f"Generating video with prompt: {prompt[:100]}...")
+        return "generated_video_url"  # Placeholder
+    
+    async def generate_tts(self, text):
+        """Generate TTS audio"""
+        # Simplified implementation - replace with actual API call
+        logger.info(f"Generating TTS for text: {text[:100]}...")
+        return {
+            'audio_url': 'generated_audio_url',
+            'lip_sync_data': {'timestamps': []}  # Placeholder
+        }
+    
+    async def select_videos(self, tts_script, count=3):
+        """AI agent selects videos based on script"""
+        keywords = self._extract_keywords(tts_script)
+        logger.info(f"Selecting {count} videos for keywords: {keywords}")
+        
+        # Simplified video selection logic
+        selected_videos = []
+        for i in range(min(count, 3)):  # Max 3 videos
+            video_id = (hash(tts_script) + i) % self.config['video_library_size'] + 1
+            selected_videos.append({
+                'id': video_id,
+                'url': f'gs://somira-videos/library/video{video_id}.mp4',
+                'reason': f'Matches keyword: {keywords[i % len(keywords)] if keywords else "general"}'
+            })
+        
+        return selected_videos
+    
+    async def store_in_gcs(self, file_path):
+        """Store file in Google Cloud Storage"""
+        logger.info(f"Storing file in GCS: {file_path}")
+        # Simplified implementation
+        return f"gs://{self.config['gcs_bucket']}/videos/{hash(file_path)}.mp4"
+    
+    def _extract_keywords(self, text):
+        """Extract keywords from TTS script"""
+        text_lower = text.lower()
+        keywords = []
+        
+        key_phrases = [
+            'somira massager', 'neck pain', 'product', 'massager',
+            'solution', 'comfort', 'using the product', 'relaxation'
+        ]
+        
+        for phrase in key_phrases:
+            if phrase in text_lower:
+                keywords.append(phrase)
+                
+        return keywords if keywords else ['general']

src/automation.py

@@ -0,0 +1,92 @@
+"""
+Main automation orchestrator
+"""
+import asyncio
+from api_clients import APIClients
+from video_renderer import VideoRenderer
+from utils import logger
+
+class ContentAutomation:
+    def __init__(self, config):
+        self.config = config
+        self.api_clients = APIClients(config)
+        self.video_renderer = VideoRenderer(config)
+        self.current_audio_index = 0
+        
+    async def execute_pipeline(self, content_strategy, tts_script):
+        """Execute the complete automation pipeline"""
+        logger.info("Starting automation pipeline...")
+        
+        # Step 1: Simultaneous execution
+        assets = await self.execute_step_1(content_strategy, tts_script)
+        
+        # Step 2: Merge and render
+        rendered_video = await self.video_renderer.render_video(assets)
+        
+        # Step 3: Add subtitles
+        subtitled_video = await self.video_renderer.add_subtitles(rendered_video, tts_script)
+        
+        # Step 4: Store in GCS
+        final_url = await self.api_clients.store_in_gcs(subtitled_video)
+        
+        logger.info(f"Pipeline completed. Video stored at: {final_url}")
+        return final_url
+    
+    async def execute_step_1(self, content_strategy, tts_script):
+        """Execute all step 1 processes simultaneously"""
+        tasks = [
+            self.generate_hook_video(content_strategy),
+            self.select_background_music(),
+            self.select_videos_from_library(tts_script),
+            self.generate_tts_audio(tts_script)
+        ]
+        
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        return {
+            'hook_video': results[0],
+            'background_music': results[1],
+            'selected_videos': results[2],
+            'tts_audio': results[3]
+        }
+    
+    async def generate_hook_video(self, strategy):
+        """Generate hook video using AI APIs"""
+        try:
+            # Enhance prompt with Gemini
+            enhanced_prompt = await self.api_clients.enhance_prompt(strategy['gemini_prompt'])
+            
+            # Generate video with RunwayML
+            video_url = await self.api_clients.generate_video(enhanced_prompt)
+            return video_url
+            
+        except Exception as e:
+            logger.error(f"Hook video generation failed: {e}")
+            return None
+    
+    async def select_background_music(self):
+        """Select background music linearly"""
+        audio_index = self.current_audio_index
+        self.current_audio_index = (self.current_audio_index + 1) % self.config['audio_library_size']
+        
+        audio_url = f"https://storage.googleapis.com/somira/{audio_index + 1}.mp3"
+        logger.info(f"Selected background music: {audio_url}")
+        return audio_url
+    
+    async def select_videos_from_library(self, tts_script):
+        """AI agent selects 3 videos based on TTS script"""
+        try:
+            selected_videos = await self.api_clients.select_videos(tts_script, count=3)
+            return selected_videos
+        except Exception as e:
+            logger.error(f"Video selection failed: {e}")
+            return []
+    
+    async def generate_tts_audio(self, tts_script):
+        """Generate TTS audio with lip-sync data"""
+        try:
+            tts_result = await self.api_clients.generate_tts(tts_script)
+            return tts_result
+        except Exception as e:
+            logger.error(f"TTS generation failed: {e}")
+            return None

src/main.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""
+Main entry point for Content Automation System
+"""
+import asyncio
+import os
+from dotenv import load_dotenv
+from automation import ContentAutomation
+
+# Load environment variables
+load_dotenv()
+
+async def main():
+    """Main execution function"""
+    print("🚀 Starting Content Automation System...")
+    
+    # Configuration
+    config = {
+        'gemini_api_key': os.getenv('GEMINI_API_KEY'),
+        'runwayml_api_key': os.getenv('RUNWAYML_API_KEY'),
+        'tts_api_key': os.getenv('TTS_API_KEY'),
+        'gcs_bucket': os.getenv('GCS_BUCKET_NAME'),
+        'audio_library_size': int(os.getenv('AUDIO_LIBRARY_SIZE', 27)),
+        'video_library_size': int(os.getenv('VIDEO_LIBRARY_SIZE', 47))
+    }
+    
+    # Initialize automation system
+    automation = ContentAutomation(config)
+    
+    # Example content strategy
+    content_strategy = {
+        'gemini_prompt': 'A photorealistic, comical yet painfully real depiction of an attractive blond, blue-eyed female stuck in a neck spasm nightmare in a luxurious home setting.',
+        'runway_prompt': 'Slow push-in camera: a blond woman suddenly tilts her head stiffly to the side and blinks in surprise, face frozen like mid-sneeze.',
+        'style': 'commercial',
+        'aspect_ratio': '9:16'
+    }
+    
+    # Example TTS script
+    tts_script = """
+    I heard a pop, and suddenly my neck was stuck. I looked like I was mid-sneeze all day. 
+    After one minute with the Somira massager it was gone. If you ever feel neck pain, 
+    you'll wish you bought one, because the moment I turned my head.
+    """
+    
+    try:
+        # Execute automation pipeline
+        final_video_url = await automation.execute_pipeline(content_strategy, tts_script)
+        print(f"✅ Automation completed! Final video: {final_video_url}")
+        
+    except Exception as e:
+        print(f"❌ Automation failed: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(main())

src/utils.py

@@ -0,0 +1,34 @@
+"""
+Utility functions and logging
+"""
+import logging
+import sys
+from pathlib import Path
+
+# Setup logging
+def setup_logging():
+    """Configure logging"""
+    log_dir = Path("outputs/logs")
+    log_dir.mkdir(parents=True, exist_ok=True)
+    
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler(log_dir / 'automation.log'),
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+
+setup_logging()
+logger = logging.getLogger(__name__)
+
+def validate_environment():
+    """Validate that required environment variables are set"""
+    required_vars = ['GEMINI_API_KEY', 'RUNWAYML_API_KEY', 'TTS_API_KEY']
+    missing_vars = [var for var in required_vars if not os.getenv(var)]
+    
+    if missing_vars:
+        raise EnvironmentError(f"Missing required environment variables: {', '.join(missing_vars)}")
+    
+    logger.info("Environment validation passed")

src/video_renderer.py

@@ -0,0 +1,62 @@
+"""
+Video rendering and subtitle engine
+"""
+import os
+from utils import logger
+
+class VideoRenderer:
+    def __init__(self, config):
+        self.config = config
+        
+    async def render_video(self, assets):
+        """Render final video by merging all assets"""
+        logger.info("Rendering video with assets...")
+        
+        # Simplified implementation - replace with actual video rendering
+        # This would use moviepy or similar library
+        
+        hook_video = assets.get('hook_video')
+        background_music = assets.get('background_music')
+        selected_videos = assets.get('selected_videos', [])
+        tts_audio = assets.get('tts_audio')
+        
+        logger.info(f"Merging {len(selected_videos)} selected videos")
+        logger.info(f"Using hook video: {hook_video}")
+        logger.info(f"Using background music: {background_music}")
+        
+        # Placeholder for actual video rendering logic
+        output_path = "outputs/videos/rendered_video.mp4"
+        logger.info(f"Video rendered to: {output_path}")
+        
+        return output_path
+    
+    async def add_subtitles(self, video_path, tts_script):
+        """Add subtitles to video"""
+        logger.info("Adding subtitles to video...")
+        
+        # Simplified implementation - replace with actual subtitle engine
+        # This would add subtitles in the middle of the screen
+        
+        subtitles = self._generate_subtitle_segments(tts_script)
+        logger.info(f"Generated {len(subtitles)} subtitle segments")
+        
+        # Placeholder for actual subtitle rendering
+        output_path = video_path.replace('.mp4', '_subtitled.mp4')
+        logger.info(f"Subtitled video saved to: {output_path}")
+        
+        return output_path
+    
+    def _generate_subtitle_segments(self, text):
+        """Generate subtitle segments from text"""
+        sentences = [s.strip() + '.' for s in text.split('.') if s.strip()]
+        segments = []
+        
+        for i, sentence in enumerate(sentences):
+            segments.append({
+                'text': sentence,
+                'start_time': i * 3,  # 3 seconds per segment
+                'end_time': (i + 1) * 3,
+                'position': 'middle'  # Your nuance: middle of screen
+            })
+        
+        return segments