Add stock media service

backend/services/stock_media.py

@@ -0,0 +1,300 @@
+"""Stock media fetching service using Pexels and Unsplash APIs."""
+import os
+import httpx
+import logging
+import asyncio
+from pathlib import Path
+from typing import List, Optional
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY", "")
+UNSPLASH_ACCESS_KEY = os.environ.get("UNSPLASH_ACCESS_KEY", "")
+
+
+@dataclass
+class StockImage:
+    url: str
+    photographer: str
+    alt: str
+    width: int
+    height: int
+    local_path: str = ""
+
+
+@dataclass
+class StockVideo:
+    url: str
+    duration: int
+    width: int
+    height: int
+    local_path: str = ""
+
+
+async def fetch_stock_images(
+    keywords: List[str],
+    output_dir: str,
+    per_keyword: int = 2,
+    orientation: str = "portrait"
+) -> List[StockImage]:
+    """Fetch stock images from Pexels API.
+    
+    Args:
+        keywords: Search keywords
+        output_dir: Directory to save downloaded images
+        per_keyword: Number of images per keyword
+        orientation: Image orientation (portrait, landscape, square)
+    
+    Returns:
+        List of StockImage objects with local paths
+    """
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    all_images = []
+    
+    if PEXELS_API_KEY:
+        all_images = await _pexels_images(keywords, output_dir, per_keyword, orientation)
+    elif UNSPLASH_ACCESS_KEY:
+        all_images = await _unsplash_images(keywords, output_dir, per_keyword, orientation)
+    else:
+        logger.warning("No stock image API key configured, generating placeholder images")
+        all_images = _generate_placeholder_images(keywords, output_dir, per_keyword)
+    
+    return all_images
+
+
+async def _pexels_images(
+    keywords: List[str], output_dir: str, per_keyword: int, orientation: str
+) -> List[StockImage]:
+    """Fetch images from Pexels API."""
+    images = []
+    
+    async with httpx.AsyncClient() as client:
+        for keyword in keywords:
+            try:
+                response = await client.get(
+                    "https://api.pexels.com/v1/search",
+                    params={
+                        "query": keyword,
+                        "per_page": per_keyword,
+                        "orientation": orientation
+                    },
+                    headers={"Authorization": PEXELS_API_KEY},
+                    timeout=15.0
+                )
+                
+                if response.status_code != 200:
+                    logger.warning(f"Pexels API error for '{keyword}': {response.status_code}")
+                    continue
+                
+                data = response.json()
+                
+                for i, photo in enumerate(data.get("photos", [])):
+                    # Download the image
+                    img_url = photo["src"]["large2x"]  # High quality
+                    local_path = str(Path(output_dir) / f"{keyword.replace(' ', '_')}_{i}.jpg")
+                    
+                    try:
+                        img_response = await client.get(img_url, timeout=15.0)
+                        with open(local_path, "wb") as f:
+                            f.write(img_response.content)
+                        
+                        images.append(StockImage(
+                            url=img_url,
+                            photographer=photo.get("photographer", "Unknown"),
+                            alt=photo.get("alt", keyword),
+                            width=photo["width"],
+                            height=photo["height"],
+                            local_path=local_path
+                        ))
+                    except Exception as e:
+                        logger.warning(f"Failed to download image: {e}")
+                        
+            except Exception as e:
+                logger.error(f"Pexels search error for '{keyword}': {e}")
+    
+    logger.info(f"Fetched {len(images)} images from Pexels")
+    return images
+
+
+async def _unsplash_images(
+    keywords: List[str], output_dir: str, per_keyword: int, orientation: str
+) -> List[StockImage]:
+    """Fetch images from Unsplash API."""
+    images = []
+    
+    async with httpx.AsyncClient() as client:
+        for keyword in keywords:
+            try:
+                response = await client.get(
+                    "https://api.unsplash.com/search/photos",
+                    params={
+                        "query": keyword,
+                        "per_page": per_keyword,
+                        "orientation": orientation
+                    },
+                    headers={"Authorization": f"Client-ID {UNSPLASH_ACCESS_KEY}"},
+                    timeout=15.0
+                )
+                
+                if response.status_code != 200:
+                    continue
+                
+                data = response.json()
+                
+                for i, photo in enumerate(data.get("results", [])):
+                    img_url = photo["urls"]["regular"]
+                    local_path = str(Path(output_dir) / f"{keyword.replace(' ', '_')}_{i}.jpg")
+                    
+                    try:
+                        img_response = await client.get(img_url, timeout=15.0)
+                        with open(local_path, "wb") as f:
+                            f.write(img_response.content)
+                        
+                        images.append(StockImage(
+                            url=img_url,
+                            photographer=photo["user"]["name"],
+                            alt=photo.get("alt_description", keyword),
+                            width=photo["width"],
+                            height=photo["height"],
+                            local_path=local_path
+                        ))
+                    except Exception as e:
+                        logger.warning(f"Failed to download Unsplash image: {e}")
+                        
+            except Exception as e:
+                logger.error(f"Unsplash search error for '{keyword}': {e}")
+    
+    return images
+
+
+async def fetch_stock_videos(
+    keywords: List[str],
+    output_dir: str,
+    per_keyword: int = 1
+) -> List[StockVideo]:
+    """Fetch stock video clips from Pexels Videos API.
+    
+    Args:
+        keywords: Search keywords
+        output_dir: Directory to save videos
+        per_keyword: Number of videos per keyword
+    
+    Returns:
+        List of StockVideo objects
+    """
+    if not PEXELS_API_KEY:
+        return []
+    
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    videos = []
+    
+    async with httpx.AsyncClient() as client:
+        for keyword in keywords:
+            try:
+                response = await client.get(
+                    "https://api.pexels.com/videos/search",
+                    params={
+                        "query": keyword,
+                        "per_page": per_keyword,
+                        "orientation": "portrait",
+                        "size": "medium"
+                    },
+                    headers={"Authorization": PEXELS_API_KEY},
+                    timeout=15.0
+                )
+                
+                if response.status_code != 200:
+                    continue
+                
+                data = response.json()
+                
+                for i, video in enumerate(data.get("videos", [])):
+                    # Get the best quality video file
+                    video_files = video.get("video_files", [])
+                    hd_file = next(
+                        (f for f in video_files if f.get("quality") == "hd"),
+                        video_files[0] if video_files else None
+                    )
+                    
+                    if not hd_file:
+                        continue
+                    
+                    video_url = hd_file["link"]
+                    local_path = str(Path(output_dir) / f"broll_{keyword.replace(' ', '_')}_{i}.mp4")
+                    
+                    try:
+                        vid_response = await client.get(video_url, timeout=30.0)
+                        with open(local_path, "wb") as f:
+                            f.write(vid_response.content)
+                        
+                        videos.append(StockVideo(
+                            url=video_url,
+                            duration=video.get("duration", 0),
+                            width=hd_file.get("width", 1920),
+                            height=hd_file.get("height", 1080),
+                            local_path=local_path
+                        ))
+                    except Exception as e:
+                        logger.warning(f"Failed to download video: {e}")
+                        
+            except Exception as e:
+                logger.error(f"Pexels video search error: {e}")
+    
+    return videos
+
+
+def _generate_placeholder_images(
+    keywords: List[str], output_dir: str, per_keyword: int
+) -> List[StockImage]:
+    """Generate placeholder gradient images when no API key is available."""
+    from PIL import Image, ImageDraw, ImageFont
+    import random
+    
+    images = []
+    colors = [
+        ((30, 60, 120), (80, 150, 220)),
+        ((120, 30, 60), (220, 80, 150)),
+        ((30, 120, 60), (80, 220, 150)),
+        ((100, 50, 150), (200, 100, 250)),
+        ((150, 100, 30), (250, 200, 80)),
+    ]
+    
+    for keyword in keywords:
+        for i in range(per_keyword):
+            local_path = str(Path(output_dir) / f"{keyword.replace(' ', '_')}_{i}.jpg")
+            
+            # Create gradient image
+            img = Image.new("RGB", (1080, 1920))
+            draw = ImageDraw.Draw(img)
+            
+            color_pair = random.choice(colors)
+            for y in range(1920):
+                ratio = y / 1920
+                r = int(color_pair[0][0] * (1 - ratio) + color_pair[1][0] * ratio)
+                g = int(color_pair[0][1] * (1 - ratio) + color_pair[1][1] * ratio)
+                b = int(color_pair[0][2] * (1 - ratio) + color_pair[1][2] * ratio)
+                draw.line([(0, y), (1080, y)], fill=(r, g, b))
+            
+            # Add keyword text
+            try:
+                font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 48)
+            except:
+                font = ImageFont.load_default()
+            
+            bbox = draw.textbbox((0, 0), keyword, font=font)
+            text_width = bbox[2] - bbox[0]
+            draw.text(((1080 - text_width) // 2, 900), keyword, fill="white", font=font)
+            
+            img.save(local_path, quality=90)
+            
+            images.append(StockImage(
+                url="",
+                photographer="Generated",
+                alt=keyword,
+                width=1080,
+                height=1920,
+                local_path=local_path
+            ))
+    
+    return images