refactor: Remove explicit vertical video resizing and add `yuv420p` pixel format, and enhance social media publisher error reporting with API messages.

social_media_publishers/instagram/publisher.py

@@ -223,7 +223,7 @@ class InstagramPublisher(SocialPublisher):
         logger.info("⏳ Waiting for processing...")
 
         for attempt in range(1, max_attempts + 1):
-            params = {'access_token': self.access_token, 'fields': 'status_code,status'}
+            params = {'access_token': self.access_token, 'fields': 'status_code,status,error_message'}
             response = self._get_session().get(endpoint, params=params)
             result = response.json()
 
@@ -233,8 +233,8 @@ class InstagramPublisher(SocialPublisher):
             if status == 'FINISHED':
                 return status
             elif status == 'ERROR':
-                error_detail = result.get('status', '')
-                logger.error(f"❌ Instagram processing error: {error_detail}")
+                error_detail = result.get('error_message') or result.get('status', '')
+                logger.error(f"❌ Instagram processing error: {error_detail} | Full response: {result}")
                 return status
 
             time.sleep(10)

social_media_publishers/threads/publisher.py

@@ -241,16 +241,18 @@ class ThreadsPublisher(SocialPublisher):
         print("⏳ Waiting for processing...")
         
         for attempt in range(1, max_attempts + 1):
-            params = {'access_token': self.access_token, 'fields': 'status'}
+            params = {'access_token': self.access_token, 'fields': 'status,error_message'}
             response = self._get_session().get(endpoint, params=params)
             result = response.json()
-            
+
             status = result.get('status')
             print(f"  Attempt {attempt}/{max_attempts}: {status}")
-            
+
             if status == 'FINISHED':
                 return status
             elif status == 'ERROR':
+                error_detail = result.get('error_message', '')
+                print(f"❌ Threads processing error: {error_detail} | Full response: {result}")
                 return status
             
             time.sleep(5) # Threads might be faster/slower

src/video_renderer.py

@@ -97,7 +97,6 @@ class VideoRenderer:
                     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"])
 
@@ -141,7 +140,7 @@ class VideoRenderer:
                 if lib_video.get("local_path"):
                     try:
                         lib_clip = VideoFileClip(lib_video["local_path"])
-                        original_clip = self._resize_for_vertical(lib_clip, target_size)
+                        original_clip = lib_clip
                         lib_hook_start = None
                         lib_hook_end = None
                         prev_clip = None
@@ -149,13 +148,13 @@ class VideoRenderer:
 
                         # Only apply hook logic if hook is available
                         if hook_start and i == 0:
-                            lib_hook_start = self._resize_for_vertical(hook_start, target_size)
+                            lib_hook_start = hook_start
                             original_clip = runway_as_second_ai_video if runway_as_second_ai_video else original_clip
                         if i == 1 and get_config_value("use_veo", False) and runway_as_second_ai_video:
                             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 hook_end and i+1 == len(assets.get("selected_videos", [])):
-                            lib_hook_end = self._resize_for_vertical(hook_end, target_size)
+                            lib_hook_end = hook_end
                             if len(clips) > 0:
                                 prev_clip = clips[-1][1]
                                 prev_clip_file = selected_videos[-2]["local_path"] if len(selected_videos) > 1 else None
@@ -363,7 +362,6 @@ class VideoRenderer:
                 video_usage[lib_video['alternate_url']] = video_usage.get(lib_video['alternate_url'], 0) + 1
                 set_config_value("video_usage_count", video_usage)
                 alternate_clip = VideoFileClip(alternate_url_local_path)
-                alternate_clip = self._resize_for_vertical(alternate_clip)
                 reverse_alternate_clip = self.reverse_clip(alternate_url_local_path)
 
                 combined = concatenate_videoclips([original_clip, alternate_clip, reverse_alternate_clip, original_clip], method="compose")
@@ -384,8 +382,7 @@ class VideoRenderer:
             interpolated_file = utils.interpolate_video(original_clip_path)
             if interpolated_file:
                 interpolated = VideoFileClip(interpolated_file)
-                interpolated = self._resize_for_vertical(interpolated)
-                
+
                 if interpolated.duration >= target_duration:
                     logger.debug("Using interpolated clip for extension")
                     result = interpolated.subclip(0, target_duration)
@@ -421,7 +418,7 @@ class VideoRenderer:
 
     def reverse_clip(self, clip_path):
         reversed_clip = VideoFileClip(utils_reverse_clip(clip_path))
-        return self._resize_for_vertical(reversed_clip)
+        return reversed_clip
 
     def loop_clip(self, clip, target_duration):
         loop_count = int(target_duration // clip.duration) + 1  # how many loops needed
@@ -556,12 +553,8 @@ class VideoRenderer:
                 f"📊 Total video sequence duration: {total_duration:.2f}s (target: {TARGET_MIN_DURATION}-{TARGET_MAX_DURATION}s)"
             )
 
-            # Resize all clips to 9:16 vertical
-            target_size = (1080, 1920)
-            resized_clips = [self._resize_for_vertical(clip, target_size) for clip in sequence_clips]
-
             # FIXED: Remove transition_duration parameter
-            final_sequence = concatenate_videoclips(resized_clips, method="compose")
+            final_sequence = concatenate_videoclips(sequence_clips, method="compose")
             logger.debug(f"✅ Created video sequence with NATURAL SPEED: {final_sequence.duration:.2f}s")
 
             return final_sequence
@@ -795,28 +788,6 @@ class VideoRenderer:
 
         return phrases
 
-    def _resize_for_vertical(self, clip: VideoFileClip, target_size: tuple = (1080, 1920)) -> VideoFileClip:
-        return clip # resize on the download itself
-        """Resize clip to fit vertical 9:16 aspect ratio"""
-        target_w, target_h = target_size
-        clip_aspect = clip.w / clip.h
-        target_aspect = target_w / target_h
-
-        if clip_aspect > target_aspect:
-            new_clip = clip.resize(height=target_h)
-        else:
-            new_clip = clip.resize(width=target_w)
-
-        # Center crop
-        try:
-            new_clip = new_clip.crop(x_center=new_clip.w / 2, y_center=new_clip.h / 2, width=target_w, height=target_h)
-        except Exception:
-            x1 = (new_clip.w - target_w) // 2
-            y1 = (new_clip.h - target_h) // 2
-            new_clip = new_clip.crop(x1=x1, y1=y1, x2=x1 + target_w, y2=y1 + target_h)
-
-        return new_clip
-
     async def add_audio_to_video(self, video_path: str) -> str:
         """
         Add audio track to pre-rendered video (NO speedup - video is already correct duration)
@@ -990,7 +961,15 @@ class VideoRenderer:
         try:
             output_path = self.temp_dir / f"{uuid.uuid4().hex}.mp4"
 
-            video_clip.write_videofile(str(output_path), codec="libx264", audio_codec="aac", fps=25, verbose=False, logger=None)
+            video_clip.write_videofile(
+                str(output_path),
+                codec="libx264",
+                audio_codec="aac",
+                fps=25,
+                verbose=False,
+                logger=None,
+                ffmpeg_params=["-pix_fmt", "yuv420p"]
+            )
 
             video_clip.close()
             return str(output_path)
@@ -1011,7 +990,12 @@ class VideoRenderer:
             logger.debug(f"📹 Rendering video (no audio): {filename}")
 
             video_clip.write_videofile(
-                str(output_path), codec="libx264", fps=25, verbose=False, logger=None
+                str(output_path),
+                codec="libx264",
+                fps=25,
+                verbose=False,
+                logger=None,
+                ffmpeg_params=["-pix_fmt", "yuv420p"]
             )
 
             return str(output_path)