Add Pixabay video API: dual search (Pexels + Pixabay), optional both APIs, 9:16 portrait filtering

config.py

@@ -57,6 +57,7 @@ class NCAkitConfig(BaseConfig):
     # Video Creator Module Config
     # ===================
     pexels_api_key: Optional[str] = None
+    pixabay_api_key: Optional[str] = None  # Optional: Pixabay API for additional video source
     hf_tts: Optional[str] = None
     whisper_model: str = "tiny.en"
     whisper_verbose: bool = False

modules/video_creator/__init__.py

@@ -22,14 +22,15 @@ def register(app: FastAPI, config):
     from .services.libraries.tts_client import TTSClient
     from .services.libraries.whisper_client import WhisperClient
     from .services.libraries.pexels_client import PexelsClient
+    from .services.libraries.pixabay_client import PixabayClient
     from .services.music_manager import MusicManager
     from .services.short_creator import ShortCreator
     
     logger.info("Registering video_creator module...")
     
     # Validate environment variables
-    if not config.pexels_api_key:
-        logger.warning("PEXELS_API_KEY is missing! Video generation will fail.")
+    if not config.pexels_api_key and not config.pixabay_api_key:
+        logger.warning("Neither PEXELS_API_KEY nor PIXABAY_API_KEY is set! Video generation may fail.")
     
     if not config.hf_tts:
         logger.warning("HF_TTS is missing! TTS will fail.")
@@ -45,9 +46,21 @@ def register(app: FastAPI, config):
         model_dir=config.whisper_model_dir
     )
     
-    # Initialize Pexels client
-    logger.info("Initializing Pexels client...")
-    pexels_client = PexelsClient(config.pexels_api_key)
+    # Initialize Pexels client (optional)
+    pexels_client = None
+    if config.pexels_api_key:
+        logger.info("Initializing Pexels client...")
+        pexels_client = PexelsClient(config.pexels_api_key)
+    else:
+        logger.info("Pexels API key not set, skipping Pexels client")
+    
+    # Initialize Pixabay client (optional)
+    pixabay_client = None
+    if config.pixabay_api_key:
+        logger.info("Initializing Pixabay client...")
+        pixabay_client = PixabayClient(config.pixabay_api_key)
+    else:
+        logger.info("Pixabay API key not set, skipping Pixabay client")
     
     # Initialize music manager
     logger.info("Initializing music manager...")
@@ -59,13 +72,14 @@ def register(app: FastAPI, config):
         logger.warning("Creating empty music directory")
         config.music_dir_path.mkdir(parents=True, exist_ok=True)
     
-    # Initialize short creator
+    # Initialize short creator with both video clients
     logger.info("Initializing short creator...")
     short_creator = ShortCreator(
         config=config,
         tts_client=tts_client,
         whisper_client=whisper_client,
         pexels_client=pexels_client,
+        pixabay_client=pixabay_client,
         music_manager=music_manager
     )
     
@@ -79,3 +93,4 @@ def register(app: FastAPI, config):
     app.include_router(router, prefix=MODULE_PREFIX, tags=["Video Creator"])
     
     logger.info("video_creator module registered successfully!")
+

modules/video_creator/services/libraries/pixabay_client.py

@@ -0,0 +1,161 @@
+"""
+Pixabay Video Client
+Fetches background videos from Pixabay API
+"""
+import logging
+import random
+import requests
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class PixabayClient:
+    """Client for Pixabay API to fetch background videos"""
+    
+    def __init__(self, api_key: str):
+        """
+        Initialize Pixabay client
+        
+        Args:
+            api_key: Pixabay API key
+        """
+        self.api_key = api_key
+        self.base_url = "https://pixabay.com/api/videos/"
+        self.joker_terms = ["nature", "abstract", "space", "ocean"]
+    
+    def find_video(
+        self,
+        search_terms: List[str],
+        duration: float,
+        exclude_ids: Optional[List[int]] = None,
+        orientation: str = "portrait"
+    ) -> Optional[dict]:
+        """
+        Find a suitable video from Pixabay
+        
+        Args:
+            search_terms: Keywords to search for
+            duration: Required video duration in seconds
+            exclude_ids: List of video IDs to exclude
+            orientation: 'portrait' or 'landscape'
+        
+        Returns:
+            Dict with 'id' and 'url' of the selected video, or None
+        """
+        exclude_ids = exclude_ids or []
+        
+        # Try user-provided search terms first
+        for term in search_terms:
+            video = self._search_and_select(term, duration, exclude_ids, orientation)
+            if video:
+                return video
+        
+        # Fall back to joker terms
+        logger.info(f"Pixabay: No videos found for {search_terms}, using joker terms")
+        for term in self.joker_terms:
+            video = self._search_and_select(term, duration, exclude_ids, orientation)
+            if video:
+                return video
+        
+        return None
+    
+    def _search_and_select(
+        self,
+        query: str,
+        min_duration: float,
+        exclude_ids: List[int],
+        orientation: str
+    ) -> Optional[dict]:
+        """Search for videos and select a suitable one"""
+        try:
+            logger.debug(f"Searching Pixabay for: {query} ({orientation})")
+            
+            response = requests.get(
+                self.base_url,
+                params={
+                    "key": self.api_key,
+                    "q": query,
+                    "per_page": 30,
+                    "safesearch": "true",
+                    "video_type": "film"
+                },
+                timeout=15
+            )
+            
+            if response.status_code != 200:
+                logger.warning(f"Pixabay API error: {response.status_code}")
+                return None
+            
+            data = response.json()
+            videos = data.get("hits", [])
+            
+            if not videos:
+                logger.debug(f"Pixabay: No videos found for query: {query}")
+                return None
+            
+            # Filter suitable videos
+            suitable_videos = []
+            for video in videos:
+                if video["id"] in exclude_ids:
+                    continue
+                
+                video_files = video.get("videos", {})
+                if not video_files:
+                    continue
+                
+                # Get large or medium quality
+                large = video_files.get("large", {})
+                medium = video_files.get("medium", {})
+                
+                # Prefer large, fallback to medium
+                selected_file = large if large.get("url") else medium
+                
+                if not selected_file.get("url"):
+                    continue
+                
+                width = selected_file.get("width", 0)
+                height = selected_file.get("height", 0)
+                
+                # Filter by orientation
+                if orientation == "portrait":
+                    # Portrait: height > width (9:16)
+                    if height <= width:
+                        continue
+                else:
+                    # Landscape: width > height (16:9)
+                    if width <= height:
+                        continue
+                
+                video_duration = video.get("duration", 0)
+                
+                suitable_videos.append({
+                    "id": video["id"],
+                    "url": selected_file["url"],
+                    "duration": video_duration,
+                    "width": width,
+                    "height": height
+                })
+            
+            if not suitable_videos:
+                logger.debug(f"Pixabay: No {orientation} videos found for: {query}")
+                return None
+            
+            # Filter by duration if possible
+            duration_threshold = min(min_duration * 0.5, 15)
+            long_enough_videos = [v for v in suitable_videos if v["duration"] >= duration_threshold]
+            
+            if long_enough_videos:
+                # Select FIRST (most relevant) video
+                selected = long_enough_videos[0]
+                logger.info(f"Pixabay: Selected video ID {selected['id']} (duration: {selected['duration']}s) for '{query}'")
+                return selected
+            
+            # Fallback to first suitable video
+            selected = suitable_videos[0]
+            logger.info(f"Pixabay: Selected video ID {selected['id']} ({selected['duration']}s) for '{query}' (fallback)")
+            return selected
+            
+        except Exception as e:
+            logger.error(f"Pixabay search error: {e}")
+            return None

modules/video_creator/services/short_creator.py

@@ -28,13 +28,15 @@ class ShortCreator:
         config: Any,  # NCAkitConfig from parent
         tts_client: TTSClient,
         whisper_client: WhisperClient,
-        pexels_client: PexelsClient,
-        music_manager: MusicManager
+        pexels_client: PexelsClient = None,
+        pixabay_client = None,  # Optional PixabayClient
+        music_manager: MusicManager = None
     ):
         self.config = config
         self.tts = tts_client
         self.whisper = whisper_client
         self.pexels = pexels_client
+        self.pixabay = pixabay_client
         self.music_manager = music_manager
         self.queue: List[Dict] = []
         self.processing = False
@@ -195,19 +197,46 @@ class ShortCreator:
                 # Ensure keywords is a list for find_video
                 search_keywords = keywords if isinstance(keywords, list) else [keywords]
                 
-                pexels_video = self.pexels.find_video(
-                    search_keywords,  # Pass full list, not just first keyword
-                    search_duration,
-                    exclude_video_ids,
-                    orientation
-                )
+                # Try Pexels first (if configured)
+                pexels_video = None
+                pixabay_video = None
+                selected_video = None
+                
+                if self.pexels:
+                    logger.debug(f"Trying Pexels for: {search_keywords}")
+                    pexels_video = self.pexels.find_video(
+                        search_keywords,
+                        search_duration,
+                        exclude_video_ids,
+                        orientation
+                    )
+                    if pexels_video:
+                        selected_video = pexels_video
+                        logger.info(f"Found video on Pexels for '{keyword}'")
+                
+                # Try Pixabay if Pexels didn't find anything (and Pixabay is configured)
+                if not selected_video and self.pixabay:
+                    logger.debug(f"Trying Pixabay for: {search_keywords}")
+                    pixabay_video = self.pixabay.find_video(
+                        search_keywords,
+                        search_duration,
+                        exclude_video_ids,
+                        orientation
+                    )
+                    if pixabay_video:
+                        selected_video = pixabay_video
+                        logger.info(f"Found video on Pixabay for '{keyword}'")
+                
+                # If no video found on either platform
+                if not selected_video:
+                    raise Exception(f"No video found for {search_keywords} on any platform")
                 
                 video_path = self.config.temp_dir_path / f"{temp_vid_id}.mp4"
                 temp_files.append(video_path)
                 
                 # Download video
                 logger.debug(f"Downloading video for '{keyword}' (Target: {audio_duration:.2f}s)")
-                response = requests.get(pexels_video["url"], stream=True, timeout=30)
+                response = requests.get(selected_video["url"], stream=True, timeout=30)
                 response.raise_for_status()
                 
                 with open(video_path, 'wb') as f: