Update core/visual_engine.py

core/visual_engine.py

@@ -1,6 +1,6 @@
 # core/visual_engine.py
 from PIL import Image, ImageDraw, ImageFont, ImageOps
-import base64 # For Data URI conversion
+import base64
 
 # --- MONKEY PATCH ---
 try:
@@ -22,7 +22,7 @@ import io
 import time
 import random
 import logging
-import mimetypes # For Data URI
+import mimetypes
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -75,12 +75,8 @@ class VisualEngine:
         self.runway_api_key = None; self.USE_RUNWAYML = False; self.runway_client = None
         if RUNWAYML_SDK_IMPORTED and RunwayMLAPIClient:
             try:
-                if os.getenv("RUNWAYML_API_SECRET"):
-                    self.runway_client = RunwayMLAPIClient()
-                    logger.info("RunwayML Client initialized using RUNWAYML_API_SECRET env var.")
-                # else: # No explicit else, will be handled by set_runway_api_key if key provided later
-            except Exception as e_runway_init:
-                logger.error(f"Failed to initialize RunwayML client during __init__: {e_runway_init}", exc_info=True)
+                if os.getenv("RUNWAYML_API_SECRET"): self.runway_client = RunwayMLAPIClient(); logger.info("RunwayML Client initialized using RUNWAYML_API_SECRET env var.")
+            except Exception as e_runway_init: logger.error(f"Failed to initialize RunwayML client during __init__: {e_runway_init}", exc_info=True)
         
         logger.info("VisualEngine initialized.")
 
@@ -100,17 +96,10 @@ class VisualEngine:
             if RUNWAYML_SDK_IMPORTED and RunwayMLAPIClient:
                 if not self.runway_client:
                     try:
-                        if not os.getenv("RUNWAYML_API_SECRET"):
-                            logger.info("Setting RUNWAYML_API_SECRET environment variable from provided key for SDK.")
-                            os.environ["RUNWAYML_API_SECRET"] = k
-                        self.runway_client = RunwayMLAPIClient()
-                        self.USE_RUNWAYML = True
-                        logger.info("RunwayML Client initialized successfully via set_runway_api_key.")
-                    except Exception as e_client_init:
-                        logger.error(f"RunwayML Client initialization failed in set_runway_api_key: {e_client_init}", exc_info=True)
-                        self.USE_RUNWAYML = False
-                else: # Client already initialized
-                    self.USE_RUNWAYML = True; logger.info("RunwayML Client was already initialized.")
+                        if not os.getenv("RUNWAYML_API_SECRET"): os.environ["RUNWAYML_API_SECRET"] = k; logger.info("Setting RUNWAYML_API_SECRET env var from provided key.")
+                        self.runway_client = RunwayMLAPIClient(); self.USE_RUNWAYML = True; logger.info("RunwayML Client initialized successfully via set_runway_api_key.")
+                    except Exception as e_client_init: logger.error(f"RunwayML Client init failed in set_runway_api_key: {e_client_init}", exc_info=True); self.USE_RUNWAYML = False
+                else: self.USE_RUNWAYML = True; logger.info("RunwayML Client was already initialized.")
             else: logger.warning("RunwayML SDK not imported. API key set, but integration requires SDK."); self.USE_RUNWAYML = False
         else: self.USE_RUNWAYML = False; logger.info("RunwayML Disabled (no API key).")
 
@@ -128,76 +117,46 @@ class VisualEngine:
         except Exception as e: logger.error(f"Error converting {image_path} to data URI: {e}", exc_info=True); return None
 
     def _map_resolution_to_runway_ratio(self, width, height):
-        # Based on Gen-4 supported ratios: "1280:720", "720:1280", "1104:832", "832:1104", "960:960", "1584:672"
-        ratio_str = f"{width}:{height}"
-        supported_ratios = ["1280:720", "720:1280", "1104:832", "832:1104", "960:960", "1584:672"]
+        ratio_str = f"{width}:{height}"; supported_ratios = ["1280:720", "720:1280", "1104:832", "832:1104", "960:960", "1584:672"]
         if ratio_str in supported_ratios: return ratio_str
-        logger.warning(f"Resolution {ratio_str} not directly supported by Gen-4. Defaulting to 1280:720.")
-        return "1280:720"
+        logger.warning(f"Res {ratio_str} not directly Gen-4 supported. Default 1280:720."); return "1280:720"
 
     def _get_text_dimensions(self,text_content,font_obj):
-        # (Corrected version from previous, assuming font_obj.size exists or font_size_pil is fallback)
         default_char_height = getattr(font_obj, 'size', self.font_size_pil)
         if not text_content: return 0, default_char_height
         try:
-            if hasattr(font_obj,'getbbox'): # Pillow 8.0.0+
-                bbox=font_obj.getbbox(text_content);w=bbox[2]-bbox[0];h=bbox[3]-bbox[1]
-                return w, h if h > 0 else default_char_height
-            elif hasattr(font_obj,'getsize'): # Older Pillow
-                w,h=font_obj.getsize(text_content)
-                return w, h if h > 0 else default_char_height
-            else: # Fallback if no standard method (should not happen for ImageFont)
-                return int(len(text_content)*default_char_height*0.6),int(default_char_height*1.2)
-        except Exception as e:
-            logger.warning(f"Error in _get_text_dimensions for '{text_content[:20]}...': {e}")
-            return int(len(text_content)*self.font_size_pil*0.6),int(self.font_size_pil*1.2) # Fallback to global default
+            if hasattr(font_obj,'getbbox'): bbox=font_obj.getbbox(text_content);w=bbox[2]-bbox[0];h=bbox[3]-bbox[1]; return w, h if h > 0 else default_char_height
+            elif hasattr(font_obj,'getsize'): w,h=font_obj.getsize(text_content); return w, h if h > 0 else default_char_height
+            else: return int(len(text_content)*default_char_height*0.6),int(default_char_height*1.2)
+        except Exception as e: logger.warning(f"Error in _get_text_dimensions: {e}"); return int(len(text_content)*self.font_size_pil*0.6),int(self.font_size_pil*1.2)
 
     def _create_placeholder_image_content(self,text_description,filename,size=None):
-        # <<< THIS IS THE CORRECTED METHOD >>>
         if size is None: size = self.video_frame_size
         img=Image.new('RGB',size,color=(20,20,40));d=ImageDraw.Draw(img);padding=25;max_w=size[0]-(2*padding);lines=[];
         if not text_description: text_description="(Placeholder Image)"
         words=text_description.split();current_line=""
         for word_idx, word in enumerate(words):
-            # Add space correctly, not after the very last word of the text
             prospective_line_addition = word + (" " if word_idx < len(words) - 1 else "")
             test_line = current_line + prospective_line_addition
-            
             current_line_width, _ = self._get_text_dimensions(test_line, self.font)
-            if current_line_width == 0 and test_line.strip(): # Estimate if Pillow returns 0
-                current_line_width = len(test_line) * (self.font_size_pil * 0.6)
-
-            if current_line_width <= max_w:
-                current_line = test_line
-            else: # Word doesn't fit
-                if current_line.strip(): # Add previous line if it had content
-                    lines.append(current_line.strip())
-                current_line = prospective_line_addition # Start new line with current word (plus its space if not last)
-                # If the word itself is too long for a line, it will just be one long line.
-                # Pillow's d.text will handle overflow if text anchor isn't 'lt' (left-top).
-                # For centered text, it might go off-canvas; more complex word splitting needed for that.
-        
-        if current_line.strip(): # Add any remaining part
-            lines.append(current_line.strip())
-
+            if current_line_width == 0 and test_line.strip(): current_line_width = len(test_line) * (self.font_size_pil * 0.6)
+            if current_line_width <= max_w: current_line = test_line
+            else:
+                if current_line.strip(): lines.append(current_line.strip())
+                current_line = prospective_line_addition
+        if current_line.strip(): lines.append(current_line.strip())
         if not lines and text_description:
             avg_char_width, _ = self._get_text_dimensions("W", self.font)
-            if avg_char_width == 0: avg_char_width = self.font_size_pil * 0.6 # Estimate
+            if avg_char_width == 0: avg_char_width = self.font_size_pil * 0.6
             chars_per_line = int(max_w / avg_char_width) if avg_char_width > 0 else 20
             lines.append(text_description[:chars_per_line] + ("..." if len(text_description) > chars_per_line else ""))
-        elif not lines:
-            lines.append("(Placeholder Error)")
-
+        elif not lines: lines.append("(Placeholder Error)")
         _,single_line_h=self._get_text_dimensions("Ay",self.font); single_line_h = single_line_h if single_line_h > 0 else self.font_size_pil + 2
         max_lines_to_display=min(len(lines),(size[1]-(2*padding))//(single_line_h+2)) if single_line_h > 0 else 1
         if max_lines_to_display <=0: max_lines_to_display = 1
-        
-        y_text_start = padding + (size[1]-(2*padding) - max_lines_to_display*(single_line_h+2))/2.0
-        y_text = y_text_start
-
+        y_text_start = padding + (size[1]-(2*padding) - max_lines_to_display*(single_line_h+2))/2.0; y_text = y_text_start
         for i in range(max_lines_to_display):
-            line_content=lines[i]
-            line_w,_=self._get_text_dimensions(line_content,self.font)
+            line_content=lines[i]; line_w,_=self._get_text_dimensions(line_content,self.font)
             if line_w == 0 and line_content.strip(): line_w = len(line_content) * (self.font_size_pil * 0.6)
             x_text=(size[0]-line_w)/2.0
             try: d.text((x_text,y_text),line_content,font=self.font,fill=(200,200,180))
@@ -211,20 +170,44 @@ class VisualEngine:
         try:img.save(filepath);return filepath
         except Exception as e:logger.error(f"Saving placeholder image {filepath}: {e}", exc_info=True);return None
 
-    def _search_pexels_image(self, q, ofnb):
-        # (Keep as before)
-        if not self.USE_PEXELS or not self.pexels_api_key: return None; h={"Authorization":self.pexels_api_key};p={"query":q,"per_page":1,"orientation":"landscape","size":"large2x"}
-        pfn=ofnb.replace(".png",f"_pexels_{random.randint(1000,9999)}.jpg").replace(".mp4",f"_pexels_{random.randint(1000,9999)}.jpg");fp=os.path.join(self.output_dir,pfn)
-        try: logger.info(f"Pexels search: '{q}'");eq=" ".join(q.split()[:5]);p["query"]=eq;r=requests.get("https://api.pexels.com/v1/search",headers=h,params=p,timeout=20)
-        r.raise_for_status();d=r.json()
-        if d.get("photos") and len(d["photos"])>0:pu=d["photos"][0]["src"]["large2x"];ir=requests.get(pu,timeout=60);ir.raise_for_status();id_img=Image.open(io.BytesIO(ir.content))
-        if id_img.mode!='RGB':id_img=id_img.convert('RGB');id_img.save(fp);logger.info(f"Pexels saved: {fp}");return fp # Fixed id to id_img
-        else: id_img.save(fp);logger.info(f"Pexels saved (was RGB): {fp}");return fp # Save even if already RGB
-        else: logger.info(f"No Pexels for: '{eq}'") # This else was misplaced
-        except Exception as e:logger.error(f"Pexels error ('{q}'): {e}",exc_info=True);return None # Fixed indent
+    def _search_pexels_image(self, query, output_filename_base):
+        # <<< CORRECTED METHOD >>>
+        if not self.USE_PEXELS or not self.pexels_api_key: return None
+        headers = {"Authorization": self.pexels_api_key}
+        params = {"query": query, "per_page": 1, "orientation": "landscape", "size": "large2x"}
+        pexels_filename = output_filename_base.replace(".png", f"_pexels_{random.randint(1000,9999)}.jpg").replace(".mp4", f"_pexels_{random.randint(1000,9999)}.jpg")
+        filepath = os.path.join(self.output_dir, pexels_filename)
+        try:
+            logger.info(f"Pexels search: '{query}'")
+            effective_query = " ".join(query.split()[:5])
+            params["query"] = effective_query
+            response = requests.get("https://api.pexels.com/v1/search", headers=headers, params=params, timeout=20)
+            response.raise_for_status()
+            data = response.json()
+            if data.get("photos") and len(data["photos"]) > 0:
+                photo_url = data["photos"][0]["src"]["large2x"]
+                image_response = requests.get(photo_url, timeout=60)
+                image_response.raise_for_status()
+                img_data = Image.open(io.BytesIO(image_response.content))
+                if img_data.mode != 'RGB':
+                    img_data = img_data.convert('RGB')
+                img_data.save(filepath)
+                logger.info(f"Pexels image saved: {filepath}")
+                return filepath
+            else:
+                logger.info(f"No photos found on Pexels for query: '{effective_query}'")
+                return None # Added explicit return
+        except requests.exceptions.RequestException as e_req:
+            logger.error(f"Pexels request error for query '{query}': {e_req}", exc_info=True)
+        except json.JSONDecodeError as e_json:
+            logger.error(f"Pexels JSON decode error for query '{query}': {e_json}", exc_info=True)
+        except IOError as e_io:
+            logger.error(f"Pexels image save error for query '{query}': {e_io}", exc_info=True)
+        except Exception as e:
+            logger.error(f"Unexpected Pexels error for query '{query}': {e}", exc_info=True)
+        return None # Ensure None is returned on any exception
 
     def _generate_video_clip_with_runwayml(self, text_prompt_for_motion, input_image_path, scene_identifier_filename_base, target_duration_seconds=5):
-        # (Updated RunwayML integration)
         if not self.USE_RUNWAYML or not self.runway_client: logger.warning("RunwayML not enabled/client not init. Skip video."); return None
         if not input_image_path or not os.path.exists(input_image_path): logger.error(f"Runway Gen-4 needs input image. Path invalid: {input_image_path}"); return None
         image_data_uri = self._image_to_data_uri(input_image_path)
@@ -237,7 +220,7 @@ class VisualEngine:
         try:
             task = self.runway_client.image_to_video.create(model='gen4_turbo', prompt_image=image_data_uri, prompt_text=text_prompt_for_motion, duration=runway_duration, ratio=runway_ratio_str)
             logger.info(f"Runway Gen-4 task ID: {task.id}. Polling...")
-            poll_interval=10; max_polls=36 # Max 6 mins
+            poll_interval=10; max_polls=36
             for _ in range(max_polls):
                 time.sleep(poll_interval); task_details = self.runway_client.tasks.retrieve(id=task.id)
                 logger.info(f"Runway task {task.id} status: {task_details.status}")
@@ -258,7 +241,7 @@ class VisualEngine:
         except AttributeError as ae: logger.error(f"RunwayML SDK AttributeError: {ae}. SDK/methods might differ.", exc_info=True); return None
         except Exception as e: logger.error(f"Runway Gen-4 API error: {e}", exc_info=True); return None
 
-    def _create_placeholder_video_content(self, td, fn, dur=4, sz=None): # Generic placeholder if input_image not available
+    def _create_placeholder_video_content(self, td, fn, dur=4, sz=None):
         if sz is None: sz = self.video_frame_size; fp = os.path.join(self.output_dir, fn); tc = None
         try: tc = TextClip(td, fontsize=50, color='white', font=self.video_overlay_font, bg_color='black', size=sz, method='caption').set_duration(dur); tc.write_videofile(fp, fps=24, codec='libx264', preset='ultrafast', logger=None, threads=2); logger.info(f"Generic placeholder video: {fp}"); return fp
         except Exception as e: logger.error(f"Generic placeholder video error {fp}: {e}", exc_info=True); return None
@@ -268,15 +251,13 @@ class VisualEngine:
     def generate_scene_asset(self, image_generation_prompt_text, motion_prompt_text_for_video,
                              scene_data, scene_identifier_filename_base,
                              generate_as_video_clip=False, runway_target_duration=5):
-        # (Logic mostly as before, ensuring base image is robustly generated first)
         base_name, _ = os.path.splitext(scene_identifier_filename_base)
         asset_info = {'path': None, 'type': 'none', 'error': True, 'prompt_used': image_generation_prompt_text, 'error_message': 'Asset generation init failed'}
         input_image_for_runway_path = None
         base_image_filename = base_name + ("_base_for_video.png" if generate_as_video_clip else ".png")
         base_image_filepath = os.path.join(self.output_dir, base_image_filename)
         
-        # Attempt base image generation
-        if self.USE_AI_IMAGE_GENERATION and self.openai_api_key: # DALL-E
+        if self.USE_AI_IMAGE_GENERATION and self.openai_api_key:
             max_r, att_n = 2,0;
             for att_n in range(max_r):
                 try:logger.info(f"Att {att_n+1} DALL-E (base img): {image_generation_prompt_text[:70]}...");cl=openai.OpenAI(api_key=self.openai_api_key,timeout=90.0);r=cl.images.generate(model=self.dalle_model,prompt=image_generation_prompt_text,n=1,size=self.image_size_dalle3,quality="hd",response_format="url",style="vivid");iu=r.data[0].url;rp=getattr(r.data[0],'revised_prompt',None);
@@ -286,17 +267,17 @@ class VisualEngine:
                 except Exception as e:logger.error(f"DALL-E base img error:{e}",exc_info=True);asset_info['error_message']=str(e);break
             if asset_info['error']:logger.warning(f"DALL-E failed after {att_n+1} attempts for base img.")
         
-        if asset_info['error'] and self.USE_PEXELS: # Pexels Fallback
+        if asset_info['error'] and self.USE_PEXELS:
             logger.info("Trying Pexels for base img.");pqt=scene_data.get('pexels_search_query_감독',f"{scene_data.get('emotional_beat','')} {scene_data.get('setting_description','')}");pp=self._search_pexels_image(pqt,base_image_filename);
             if pp:input_image_for_runway_path=pp;asset_info={'path':pp,'type':'image','error':False,'prompt_used':f"Pexels:{pqt}"}
             else:current_em=asset_info.get('error_message',"");asset_info['error_message']=(current_em+" Pexels failed for base.").strip()
 
-        if asset_info['error']: # Placeholder Fallback
+        if asset_info['error']:
             logger.warning("Base img (DALL-E/Pexels) failed. Using placeholder.");ppt=asset_info.get('prompt_used',image_generation_prompt_text);php=self._create_placeholder_image_content(f"[Base Placeholder]{ppt[:70]}...",base_image_filename);
             if php:input_image_for_runway_path=php;asset_info={'path':php,'type':'image','error':False,'prompt_used':ppt}
             else:current_em=asset_info.get('error_message',"");asset_info['error_message']=(current_em+" Base placeholder failed.").strip()
 
-        if generate_as_video_clip: # Now attempt RunwayML if requested
+        if generate_as_video_clip:
             if not input_image_for_runway_path:logger.error("RunwayML video: base img failed.");asset_info['error']=True;asset_info['error_message']=(asset_info.get('error_message',"")+" Base img miss, Runway abort.").strip();asset_info['type']='none';return asset_info
             if self.USE_RUNWAYML:
                 logger.info(f"Runway Gen-4 video for {base_name} using base: {input_image_for_runway_path}")
@@ -304,10 +285,9 @@ class VisualEngine:
                 if video_path and os.path.exists(video_path):asset_info={'path':video_path,'type':'video','error':False,'prompt_used':motion_prompt_text_for_video,'base_image_path':input_image_for_runway_path}
                 else:logger.warning(f"RunwayML video failed for {base_name}. Fallback to base img.");asset_info['error']=True;asset_info['error_message']=(asset_info.get('error_message',"Base img ok.")+" RunwayML video fail; use base img.").strip();asset_info['path']=input_image_for_runway_path;asset_info['type']='image';asset_info['prompt_used']=image_generation_prompt_text
             else:logger.warning("RunwayML selected but disabled. Use base img.");asset_info['error']=True;asset_info['error_message']=(asset_info.get('error_message',"Base img ok.")+" RunwayML disabled; use base img.").strip();asset_info['path']=input_image_for_runway_path;asset_info['type']='image';asset_info['prompt_used']=image_generation_prompt_text
-        return asset_info # Return image info if not video, or video result
+        return asset_info
 
     def generate_narration_audio(self, text_to_narrate, output_filename="narration_overall.mp3"):
-        # (Keep as before)
         if not self.USE_ELEVENLABS or not self.elevenlabs_client or not text_to_narrate: logger.info("11L skip."); return None; afp=os.path.join(self.output_dir,output_filename)
         try: logger.info(f"11L audio (Voice:{self.elevenlabs_voice_id}): {text_to_narrate[:70]}..."); asm=None
         if hasattr(self.elevenlabs_client,'text_to_speech')and hasattr(self.elevenlabs_client.text_to_speech,'stream'):asm=self.elevenlabs_client.text_to_speech.stream;logger.info("Using 11L .text_to_speech.stream()")
@@ -327,21 +307,16 @@ class VisualEngine:
         logger.info(f"11L audio (stream): {afp}");return afp
         except Exception as e:logger.error(f"11L audio error: {e}",exc_info=True);return None
 
-
     def assemble_animatic_from_assets(self, asset_data_list, overall_narration_path=None, output_filename="final_video.mp4", fps=24):
-        # (Keep as in the version that has the robust image processing, C-contiguous array, and debug image saves)
         if not asset_data_list: logger.warning("No assets for animatic."); return None
         processed_clips = []; narration_clip = None; final_clip = None
         logger.info(f"Assembling from {len(asset_data_list)} assets. Frame: {self.video_frame_size}.")
-
         for i, asset_info in enumerate(asset_data_list):
             asset_path, asset_type, scene_dur = asset_info.get('path'), asset_info.get('type'), asset_info.get('duration', 4.5)
             scene_num, key_action = asset_info.get('scene_num', i + 1), asset_info.get('key_action', '')
             logger.info(f"S{scene_num}: Path='{asset_path}', Type='{asset_type}', Dur='{scene_dur}'s")
-
             if not (asset_path and os.path.exists(asset_path)): logger.warning(f"S{scene_num}: Not found '{asset_path}'. Skip."); continue
             if scene_dur <= 0: logger.warning(f"S{scene_num}: Invalid duration ({scene_dur}s). Skip."); continue
-
             current_scene_mvpy_clip = None
             try:
                 if asset_type == 'image':
@@ -372,7 +347,7 @@ class VisualEngine:
                             else:
                                 if scene_dur/src_clip.duration > 1.5 and src_clip.duration>0.1:tmp_clip=src_clip.loop(duration=scene_dur)
                                 else:tmp_clip=src_clip.set_duration(src_clip.duration);logger.info(f"S{scene_num} Video clip ({src_clip.duration:.2f}s) shorter than target ({scene_dur:.2f}s).")
-                        current_scene_mvpy_clip=tmp_clip.set_duration(scene_dur) # Ensure target duration for concatenation
+                        current_scene_mvpy_clip=tmp_clip.set_duration(scene_dur)
                         if current_scene_mvpy_clip.size!=list(self.video_frame_size):current_scene_mvpy_clip=current_scene_mvpy_clip.resize(self.video_frame_size)
                     except Exception as e:logger.error(f"S{scene_num} Video load error '{asset_path}':{e}",exc_info=True);continue
                     finally:
@@ -418,7 +393,7 @@ class VisualEngine:
         except Exception as e:logger.error(f"Video write error:{e}",exc_info=True);return None
         finally:
             logger.debug("Closing all MoviePy clips in `assemble_animatic_from_assets` finally block.")
-            all_clips_to_close = processed_clips + ([narration_clip] if narration_clip else []) + ([final_clip] if final_clip else []) # Corrected variable name
+            all_clips_to_close = processed_clips + ([narration_clip] if narration_clip else []) + ([final_clip] if final_clip else [])
             for clip_obj_to_close in all_clips_to_close:
                 if clip_obj_to_close and hasattr(clip_obj_to_close, 'close'):
                     try: clip_obj_to_close.close()