veo change

src/api_clients.py

@@ -466,16 +466,29 @@ class APIClients:
         """
         try:
             if os.getenv("TEST_AUTOMATION", "").lower() == "true":
-                return {
-                    "task_id": "644319db-5226-42cf-b45f-5388e40d38a6",
-                    "video_url": f"{os.getenv('TEST_DATA_DIRECTORY')}/veo_text_to_video.mp4",
-                    "local_path": f"{os.getenv('TEST_DATA_DIRECTORY')}/veo_text_to_video.mp4",
-                    "duration": 3,
-                    "prompt": prompt,
-                    "status": "SUCCEEDED",
-                    "created_at": "2025-10-15T12:39:24.279Z",
-                    "model": "gen4_turbo",
-                }
+                if image_input:
+                    return {
+                        "task_id": "644319db-5226-42cf-b45f-5388e40d38a6",
+                        "video_url": f"{os.getenv('TEST_DATA_DIRECTORY')}/image-to-video.mp4",
+                        "local_path": f"{os.getenv('TEST_DATA_DIRECTORY')}/image-to-video.mp4",
+                        "duration": 3,
+                        "prompt": prompt,
+                        "status": "SUCCEEDED",
+                        "created_at": "2025-10-15T12:39:24.279Z",
+                        "model": "gen4_turbo",
+                    }
+                else:
+                    return {
+                        "task_id": "644319db-5226-42cf-b45f-5388e40d38a6",
+                        "video_url": f"{os.getenv('TEST_DATA_DIRECTORY')}/veo_text_to_video.mp4",
+                        "local_path": f"{os.getenv('TEST_DATA_DIRECTORY')}/veo_text_to_video.mp4",
+                        "duration": 3,
+                        "prompt": prompt,
+                        "status": "SUCCEEDED",
+                        "created_at": "2025-10-15T12:39:24.279Z",
+                        "model": "gen4_turbo",
+                    }
+
             logger.info(f"🎬 Generating video with: {prompt[:1000]}...")
 
             prompt_image_value = ""

src/automation.py

@@ -258,26 +258,27 @@ class ContentAutomation:
                 logger.info(f"Auto-generated captions: {captions[:50]}...")
 
             if os.getenv("USE_VEO", "false").lower() == "true":
-                video_data = await self.api_clients.generate_video(
+                veo_video_data = await self.api_clients.generate_video(
                     prompt=strategy["runway_veo_prompt"], duration=strategy.get("duration", 4)
                 )
-            else:
-                # Step 1: Generate image using Imagen 4 Ultra
-                image_path = await self.api_clients.generate_image(strategy["gemini_prompt"])
-                if not image_path:
-                    raise Exception("Image generation failed")
 
-                # Step 2: Upload image to GCS
-                await self.api_clients.store_in_gcs(image_path, "image")
+            # Step 1: Generate image using Imagen 4 Ultra
+            image_path = await self.api_clients.generate_image(strategy["gemini_prompt"])
+            if not image_path:
+                raise Exception("Image generation failed")
 
+            # Step 2: Upload image to GCS
+            await self.api_clients.store_in_gcs(image_path, "image")
 
-                # Step 3: Generate video using gen4_turbo
-                video_data = await self.api_clients.generate_video(
-                    prompt=strategy["runway_prompt"], image_input=image_path, duration=strategy.get("duration", 3)
-                )
+
+            # Step 3: Generate video using gen4_turbo
+            video_data = await self.api_clients.generate_video(
+                prompt=strategy["runway_prompt"], image_input=image_path, duration=strategy.get("duration", 3)
+            )
 
             video_data["captions"] = captions
             video_data["script"] = self.data_holder.tts_script
+            video_data["veo_video_data"] = veo_video_data
 
             logger.info(f"✓ Hook video generated: {video_data['task_id']}")
             return video_data
@@ -300,6 +301,12 @@ class ContentAutomation:
             download_tasks.append(
                 self._download_with_fallback(hook_url, "hook_video.mp4", assets["hook_video"], "local_path")
             )
+            # VEO library videos
+            if assets["hook_video"].get("veo_video_data") and assets["hook_video"].get("veo_video_data").get("video_url"):
+                veo_hook_url = assets["hook_video"]["veo_video_data"]["video_url"]
+                download_tasks.append(
+                    self._download_with_fallback(veo_hook_url, "veo_hook_url.mp4", assets["hook_video"]["veo_video_data"], "local_path")
+                )
 
         # Download library videos
         for i, video in enumerate(assets.get("selected_videos", [])):

src/video_renderer.py

@@ -36,6 +36,7 @@ import numpy as np
 ALLOWED_BG_MUSIC_VOLUME = 0.08
 REVERSE_THRESHOLD = 0.5
 HOOK_VIDEO_DURATION = 1.5
+HOOK_START_ORIGINAL_CLIP_USED = 0
 
 class VideoRenderer:
     def __init__(self, config: Dict, data_holder: DataHolder = None):
@@ -83,35 +84,43 @@ class VideoRenderer:
     async def _prepare_video_clips_natural_speed(self) -> List[VideoFileClip]:
         """Load and prepare all video clips - NO speed adjustments"""
         clips = []
+        global HOOK_START_ORIGINAL_CLIP_USED
+        global HOOK_VIDEO_DURATION
 
         try:
             assets = self.data_holder.visual_assets
             # Load hook video for seamless looping
+            runway_as_second_ai_video = None
             if assets.get("hook_video") and assets["hook_video"].get("local_path"):
-                hook_clip = VideoFileClip(assets["hook_video"]["local_path"])
+                HOOK_VIDEO_DURATION = 1.5
+                if os.getenv("USE_VEO", "false").lower() == "true":
+                    HOOK_VIDEO_DURATION = 2
+                    hook_clip = VideoFileClip(assets["hook_video"]["veo_video_data"]["local_path"])
+                    runway_as_second_ai_video = VideoFileClip(assets["hook_video"]["local_path"]).subclip(0, 2)
+                    runway_as_second_ai_video = self._resize_for_vertical(runway_as_second_ai_video)
+                else:
+                    hook_clip = VideoFileClip(assets["hook_video"]["local_path"])
+
                 hook_duration = hook_clip.duration
                 hook_clip = hook_clip.without_audio()
 
                 logger.info(f"🔄 Creating seamless loop from {hook_duration:.2f}s hook video (NATURAL SPEED)")
 
-                # FIXED DURATIONS: 1.5 seconds each
-                HOOK_SEGMENT_DURATION = 1.5
-
                 # Last 1.5 seconds for start
-                start_segment_begin = max(0, hook_duration - HOOK_SEGMENT_DURATION)
+                start_segment_begin = max(0, hook_duration - HOOK_VIDEO_DURATION)
                 hook_start = hook_clip.subclip(start_segment_begin, hook_duration)
                 # clips.append(("hook_start", hook_start))
                 logger.info(f"✓ Hook start: {hook_start.duration:.2f}s")
 
                 # First 1.5 seconds for end
-                hook_end_duration = min(HOOK_SEGMENT_DURATION, hook_duration)
+                hook_end_duration = min(HOOK_VIDEO_DURATION, hook_duration)
                 hook_end = hook_clip.subclip(0, hook_end_duration)
                 # clips.append(("hook_end", hook_end))
                 logger.info(f"✓ Hook end: {hook_end.duration:.2f}s")
 
                 hook_clip.close()
             else:
-                logger.warning("⚠️ No hook video available for processing")
+                raise ValueError("⚠️ No hook video available for processing")
 
             # Combine all tts_script_segment texts into one string
             selected_videos = assets["selected_videos"]
@@ -127,6 +136,7 @@ class VideoRenderer:
 
             target_size = (1080, 1920)
             extra_secs = 0.0
+            HOOK_START_ORIGINAL_CLIP_USED = 0
             # Load library videos - NO speed adjustments
             for i, lib_video in enumerate(selected_videos):
                 if lib_video.get("local_path"):
@@ -139,6 +149,10 @@ class VideoRenderer:
                         prev_clip_file = None
                         if i == 0:
                             lib_hook_start = self._resize_for_vertical(hook_start, target_size)
+                            original_clip = runway_as_second_ai_video if runway_as_second_ai_video else original_clip
+                        if i == 1 and os.getenv("USE_VEO", "false").lower() == "true":
+                            if HOOK_START_ORIGINAL_CLIP_USED < runway_as_second_ai_video.duration-0.5:
+                                original_clip = runway_as_second_ai_video.subclip(HOOK_START_ORIGINAL_CLIP_USED, runway_as_second_ai_video.duration) if runway_as_second_ai_video else original_clip
                         if i+1 == len(assets.get("selected_videos", [])):
                             lib_hook_end = self._resize_for_vertical(hook_end, target_size)
                             prev_clip = clips[-1][1]
@@ -218,6 +232,7 @@ class VideoRenderer:
 
     def _prepare_with_start_hook(self, lib_video, original_clip_path, alternate_url_local_path, original_clip, lib_hook_start, target_duration, prev_clip):
         """Handle clip preparation when a start hook is present."""
+        global HOOK_START_ORIGINAL_CLIP_USED
         logger.info(f"Start hook detected with duration {lib_hook_start.duration:.2f}s")
         total_duration = lib_hook_start.duration + original_clip.duration
         
@@ -226,12 +241,15 @@ class VideoRenderer:
             logger.info("Target duration fits start hook + original clip, concatenating and trimming")
             result = concatenate_videoclips([lib_hook_start, original_clip], method="compose").subclip(0, target_duration)
             logger.info(f"Prepared clip duration: {result.duration:.2f}s")
+            HOOK_START_ORIGINAL_CLIP_USED = max(0, target_duration - lib_hook_start.duration)
             return prev_clip, result, 0.0
         
         # Case 2: Need to extend beyond original clip
         modified_clip, extra_secs = self._extend_or_trim_clip(lib_video, original_clip_path, alternate_url_local_path, original_clip, target_duration-HOOK_VIDEO_DURATION)
 
         result = concatenate_videoclips([lib_hook_start, modified_clip], method="compose").subclip(0, target_duration)
+        HOOK_START_ORIGINAL_CLIP_USED = max(0, target_duration - lib_hook_start.duration)
+        print(HOOK_START_ORIGINAL_CLIP_USED)
         logger.info(f"Prepared clip duration: {result.duration:.2f}s")
         return prev_clip, result, extra_secs
 
@@ -331,10 +349,10 @@ class VideoRenderer:
         elif target_duration > total_duration:
             if alternate_url_local_path is None or (target_duration - total_duration <= REVERSE_THRESHOLD): # Small tolerance for floating point
                 logger.info("⚠️ Reversing clip.")
-                if original_clip_path:
-                    reversed_clip = self.reverse_clip(original_clip_path)
-                else:
-                    reversed_clip = self.reverse_clip(original_clip)
+                # if original_clip_path:
+                #     reversed_clip = self.reverse_clip(original_clip_path)
+                # else:
+                reversed_clip = self.reverse_clip(original_clip)
                 loop_clip = concatenate_videoclips([original_clip, reversed_clip, original_clip, reversed_clip], method="compose")
                 return loop_clip.subclip(0, target_duration), target_duration - original_clip.duration
             else:
@@ -460,10 +478,6 @@ class VideoRenderer:
             hook_end = None
             library_clips = []
 
-            HOOK_DURATION = 1.5
-            if os.getenv("USE_VEO", "false").lower() == "true":
-                HOOK_DURATION = 2
-
             for clip in video_clips:
                 library_clips.append(clip)