resize on download

src/automation.py

@@ -304,24 +304,24 @@ class ContentAutomation:
         if assets.get("hook_video") and assets["hook_video"].get("video_url"):
             hook_url = assets["hook_video"]["video_url"]
             download_tasks.append(
-                self._download_with_fallback(hook_url, "hook_video.mp4", assets["hook_video"], "local_path")
+                self._download_with_fallback(hook_url, "hook_video.mp4", assets["hook_video"], "local_path", resize=True)
             )
             # 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")
+                    self._download_with_fallback(veo_hook_url, "veo_hook_url.mp4", assets["hook_video"]["veo_video_data"], "local_path", resize=True, remove_black_padding=True)
                 )
 
         # Download library videos
         for i, video in enumerate(assets.get("selected_videos", [])):
             if video.get("url"):
                 download_tasks.append(
-                    self._download_with_fallback(video["url"], f"library_video_{i}.mp4", video, "local_path")
+                    self._download_with_fallback(video["url"], f"library_video_{i}.mp4", video, "local_path", resize=True)
                 )
             if video.get("alternate_url"):
                 download_tasks.append(
-                    self._download_with_fallback(video["alternate_url"], f"library_all_video_alternate_url_{i}.mp4", video, "alternate_url_local_path")
+                    self._download_with_fallback(video["alternate_url"], f"library_all_video_alternate_url_{i}.mp4", video, "alternate_url_local_path", resize=True)
                 )
     
         # Download library videos
@@ -343,12 +343,15 @@ class ContentAutomation:
         # Verify all required assets have local_path
         self._verify_assets_downloaded(assets)
 
-    async def _download_with_fallback(self, url: str, filename: str, target_dict: Dict, key: str = "local_path"):
+    async def _download_with_fallback(self, url: str, filename: str, target_dict: Dict, key: str = "local_path", resize: bool = False, remove_black_padding: bool = False):
         """Download file with fallback to ensure local_path is always set"""
         try:
             local_path = await self.api_clients.download_file(url, filename)
+            if remove_black_padding:
+                utils.remove_black_padding(local_path, overwrite=True)
+            if resize:
+                utils.resize_video(local_path, overwrite=True)
             target_dict[key] = local_path
-            await self.api_clients.upload_to_temp_gcs(local_path)
             logger.info(f"✓ Downloaded {filename}")
             return local_path
         except Exception as e:

src/utils.py

@@ -12,6 +12,8 @@ import imagehash
 import subprocess
 import os
 import uuid
+import re
+import shutil
 
 class ColoredFormatter(logging.Formatter):
     """Custom formatter with colors for terminal output"""
@@ -640,4 +642,82 @@ def interpolate_video(input_path: str, target_duration: float = 4.0, fps: int =
     ]
 
     subprocess.run(cmd, check=True)
-    return output_path
+    return output_path
+
+def resize_video(input_path: str, target_width: int = 1080, target_height: int = 1920, overwrite: bool = False) -> str:
+    """
+    Resize a video to the given resolution (default 1080x1920) using FFmpeg.
+    If overwrite=True, replaces the original file safely after successful conversion.
+    """
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"Input video not found: {input_path}")
+
+    temp_output = os.path.join("/tmp", f"{uuid.uuid4().hex}.mp4")
+
+    # FFmpeg resize command (output goes to /tmp first)
+    cmd = [
+        "ffmpeg", "-y", "-i", input_path,
+        "-vf", f"scale={target_width}:{target_height}",
+        "-c:v", "libx264", "-crf", "18", "-preset", "slow",
+        "-c:a", "copy",
+        temp_output
+    ]
+
+    # Run FFmpeg process
+    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode != 0:
+        raise RuntimeError(f"FFmpeg failed:\n{result.stderr.decode('utf-8', errors='ignore')}")
+
+    # Overwrite original safely if requested
+    if overwrite:
+        shutil.move(temp_output, input_path)
+        return input_path
+
+    return temp_output
+
+def remove_black_padding(input_path: str, overwrite: bool = False) -> str:
+    """
+    Automatically detect and remove black padding (crop only) using FFmpeg.
+    Saves to /tmp with a unique UUID filename unless overwrite=True.
+
+    Args:
+        input_path (str): Path to the input video.
+        overwrite (bool): If True, safely replace the original file.
+
+    Returns:
+        str: Path to the cropped video.
+    """
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"Input video not found: {input_path}")
+
+    # Step 1: Detect crop parameters using cropdetect
+    detect_cmd = [
+        "ffmpeg", "-i", input_path, "-vf", "cropdetect=24:16:0",
+        "-frames:v", "500", "-f", "null", "-"
+    ]
+    result = subprocess.run(detect_cmd, stderr=subprocess.PIPE, text=True)
+    matches = re.findall(r"crop=\S+", result.stderr)
+
+    if not matches:
+        raise RuntimeError("Could not detect any crop region — video may not have black bars.")
+
+    # Get most frequent crop value
+    crop_value = max(set(matches), key=matches.count)
+    logger.info(f"Detected crop: {crop_value}")
+
+    # Step 2: Create temp output file
+    tmp_output = os.path.join("/tmp", f"{uuid.uuid4().hex}_cropped.mp4")
+
+    # Step 3: Run FFmpeg crop command
+    crop_cmd = ["ffmpeg", "-y", "-i", input_path, "-vf", crop_value, "-c:a", "copy", tmp_output]
+    crop_proc = subprocess.run(crop_cmd, stderr=subprocess.PIPE, text=True)
+
+    if crop_proc.returncode != 0:
+        raise RuntimeError(f"FFmpeg crop failed:\n{crop_proc.stderr}")
+
+    # Step 4: Handle overwrite safely
+    if overwrite:
+        shutil.move(tmp_output, input_path)
+        return input_path
+
+    return tmp_output