Update app.py

app.py

@@ -1,518 +1,378 @@
-# app.py
-import streamlit as st
-from core.gemini_handler import GeminiHandler
-from core.visual_engine import VisualEngine
-from core.prompt_engineering import (
-    create_cinematic_treatment_prompt,
-    construct_dalle_prompt,
-    construct_text_to_video_prompt, # Import new function
-    create_narration_script_prompt_enhanced,
-    create_scene_regeneration_prompt,
-    create_visual_regeneration_prompt
-)
+# core/visual_engine.py
+from PIL import Image, ImageDraw, ImageFont, ImageOps
+# --- MONKEY PATCH FOR Image.ANTIALIAS ---
+try:
+    if hasattr(Image, 'Resampling') and hasattr(Image.Resampling, 'LANCZOS'): # Pillow 9+
+        if not hasattr(Image, 'ANTIALIAS'): Image.ANTIALIAS = Image.Resampling.LANCZOS
+    elif hasattr(Image, 'LANCZOS'): # Pillow 8
+         if not hasattr(Image, 'ANTIALIAS'): Image.ANTIALIAS = Image.LANCZOS
+    elif not hasattr(Image, 'ANTIALIAS'):
+             print("WARNING: Pillow version lacks common Resampling attributes or ANTIALIAS. Video effects might fail.")
+except Exception as e_mp: print(f"WARNING: ANTIALIAS monkey-patch error: {e_mp}")
+# --- END MONKEY PATCH ---
+
+from moviepy.editor import (ImageClip, VideoFileClip, concatenate_videoclips, TextClip,
+                            CompositeVideoClip, AudioFileClip)
+import moviepy.video.fx.all as vfx
+import numpy as np
 import os
+import openai
+import requests
+import io
+import time
+import random
 import logging
 
-# --- Configuration & Initialization ---
-st.set_page_config(page_title="CineGen AI Ultra+", layout="wide", initial_sidebar_state="expanded")
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+# --- ElevenLabs Client Import ---
+ELEVENLABS_CLIENT_IMPORTED = False; ElevenLabsAPIClient = None; Voice = None; VoiceSettings = None
+try:
+    from elevenlabs.client import ElevenLabs as ImportedElevenLabsClient
+    from elevenlabs import Voice as ImportedVoice, VoiceSettings as ImportedVoiceSettings
+    ElevenLabsAPIClient = ImportedElevenLabsClient; Voice = ImportedVoice; VoiceSettings = ImportedVoiceSettings
+    ELEVENLABS_CLIENT_IMPORTED = True; logger.info("ElevenLabs client components imported.")
+except Exception as e_eleven: logger.warning(f"ElevenLabs client import failed: {e_eleven}. Audio disabled.")
+
+# --- RunwayML Client Import (Placeholder) ---
+RUNWAYML_SDK_IMPORTED = False; RunwayMLClient = None
+try:
+    logger.info("RunwayML SDK import is a placeholder.")
+except ImportError: logger.warning("RunwayML SDK (placeholder) not found. RunwayML disabled.")
+except Exception as e_runway_sdk: logger.warning(f"Error importing RunwayML SDK (placeholder): {e_runway_sdk}. RunwayML disabled.")
+
+
+class VisualEngine:
+    def __init__(self, output_dir="temp_cinegen_media", default_elevenlabs_voice_id="Rachel"):
+        self.output_dir = output_dir
+        os.makedirs(self.output_dir, exist_ok=True)
+        self.font_filename = "DejaVuSans-Bold.ttf"
+        font_paths_to_try = [
+            self.font_filename,
+            f"/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
+            f"/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
+            f"/System/Library/Fonts/Supplemental/Arial.ttf", f"C:/Windows/Fonts/arial.ttf",
+            f"/usr/local/share/fonts/truetype/mycustomfonts/arial.ttf"
+        ]
+        self.font_path_pil = next((p for p in font_paths_to_try if os.path.exists(p)), None)
+        self.font_size_pil = 20
+        self.video_overlay_font_size = 30
+        self.video_overlay_font_color = 'white'
+        self.video_overlay_font = 'DejaVu-Sans-Bold'
 
-# --- Global Definitions for New Features ---
-SHOT_TYPES_OPTIONS = [
-    "Director's Choice", "Establishing Shot", "Long Shot", "Full Shot",
-    "Medium Long Shot (Cowboy)", "Medium Shot", "Medium Close-up",
-    "Close-up", "Extreme Close-up", "Point of View (POV)",
-    "Over the Shoulder", "Tracking Shot", "Dolly Zoom", "Crane Shot",
-    "Aerial Shot", "Static Shot", "Dutch Angle", "Whip Pan"
-]
-DEFAULT_SCENE_DURATION_SECS = 5
-DEFAULT_SHOT_TYPE = "Director's Choice"
-ASSET_TYPE_OPTIONS = ["Auto (Director's Choice)", "Image", "Video Clip"] # For user selection
-
-
-# --- Global State Variables & API Key Setup ---
-def load_api_key(key_name_streamlit, key_name_env, service_name):
-    key = None; secrets_available = hasattr(st, 'secrets')
-    try:
-        if secrets_available and key_name_streamlit in st.secrets:
-            key = st.secrets[key_name_streamlit]
-            if key: logger.info(f"{service_name} API Key found in Streamlit secrets.")
-    except Exception as e: logger.warning(f"Could not access st.secrets for {key_name_streamlit}: {e}")
-    if not key and key_name_env in os.environ:
-        key = os.environ[key_name_env]
-        if key: logger.info(f"{service_name} API Key found in environment variable.")
-    if not key: logger.warning(f"{service_name} API Key NOT FOUND. Related features may be disabled or use fallbacks.")
-    return key
-
-if 'services_initialized' not in st.session_state:
-    logger.info("Initializing services and API keys for the first time this session...")
-    st.session_state.GEMINI_API_KEY = load_api_key("GEMINI_API_KEY", "GEMINI_API_KEY", "Gemini")
-    st.session_state.OPENAI_API_KEY = load_api_key("OPENAI_API_KEY", "OPENAI_API_KEY", "OpenAI/DALL-E")
-    st.session_state.ELEVENLABS_API_KEY = load_api_key("ELEVENLABS_API_KEY", "ELEVENLABS_API_KEY", "ElevenLabs")
-    st.session_state.PEXELS_API_KEY = load_api_key("PEXELS_API_KEY", "PEXELS_API_KEY", "Pexels")
-    st.session_state.ELEVENLABS_VOICE_ID_CONFIG = load_api_key("ELEVENLABS_VOICE_ID", "ELEVENLABS_VOICE_ID", "ElevenLabs Voice ID")
-    st.session_state.RUNWAY_API_KEY = load_api_key("RUNWAY_API_KEY", "RUNWAY_API_KEY", "RunwayML") # Load Runway Key
-
-    if not st.session_state.GEMINI_API_KEY:
-        st.error("CRITICAL: Gemini API Key is essential and missing!"); logger.critical("Gemini API Key missing. Halting."); st.stop()
-
-    try:
-        st.session_state.gemini_handler = GeminiHandler(api_key=st.session_state.GEMINI_API_KEY)
-        logger.info("GeminiHandler initialized successfully.")
-    except Exception as e: st.error(f"Failed to init GeminiHandler: {e}"); logger.critical(f"GeminiHandler init failed: {e}", exc_info=True); st.stop()
-
-    try:
-        default_voice_id = "Rachel"
-        configured_voice_id = st.session_state.ELEVENLABS_VOICE_ID_CONFIG or default_voice_id
-        st.session_state.visual_engine = VisualEngine(
-            output_dir="temp_cinegen_media",
-            default_elevenlabs_voice_id=configured_voice_id
-        )
-        st.session_state.visual_engine.set_openai_api_key(st.session_state.OPENAI_API_KEY)
-        st.session_state.visual_engine.set_elevenlabs_api_key(st.session_state.ELEVENLABS_API_KEY, voice_id_from_secret=st.session_state.ELEVENLABS_VOICE_ID_CONFIG)
-        st.session_state.visual_engine.set_pexels_api_key(st.session_state.PEXELS_API_KEY)
-        st.session_state.visual_engine.set_runway_api_key(st.session_state.RUNWAY_API_KEY) # Set Runway Key
-        logger.info("VisualEngine initialized and API keys set (or attempted).")
-    except Exception as e:
-        st.error(f"Failed to init VisualEngine or set its API keys: {e}"); logger.critical(f"VisualEngine init/key setting failed: {e}", exc_info=True)
-        st.warning("VisualEngine critical setup issue. Some features will be disabled.")
-    st.session_state.services_initialized = True; logger.info("Service initialization sequence complete.")
-
-# Initialize other session state variables
-# <<< MODIFIED START >>> : Renamed generated_visual_paths to generated_scene_assets
-for key, default_val in [
-    ('story_treatment_scenes', []), ('scene_prompts', []), ('generated_scene_assets', []), # Stores dicts: {'path':..., 'type':...}
-    ('video_path', None), ('character_definitions', {}), ('global_style_additions', ""),
-    ('overall_narration_audio_path', None), ('narration_script_display', "")
-]:
-    if key not in st.session_state: st.session_state[key] = default_val
-
-def initialize_new_project():
-    st.session_state.story_treatment_scenes = []
-    st.session_state.scene_prompts = [] # Stores DALL-E or Text-to-Video prompts
-    st.session_state.generated_scene_assets = [] # Stores dicts {'path': ..., 'type': ..., 'error': ...}
-    st.session_state.video_path, st.session_state.overall_narration_audio_path, st.session_state.narration_script_display = None, None, ""
-    logger.info("New project initialized.")
-# <<< MODIFIED END >>>
-
-# <<< MODIFIED START >>> : Updated function to use generate_scene_asset
-def generate_asset_for_scene_core(scene_index, scene_data, version=1, user_selected_asset_type="Auto (Director's Choice)"):
-    """
-    Generates a visual asset (image or video clip) for a scene.
-    Returns True on success, False on failure.
-    """
-    # Determine asset type: user override > Gemini suggestion > default to image
-    final_asset_type_decision = "image" # Default
-    gemini_suggested_type = scene_data.get('suggested_asset_type_감독', 'image').lower()
-
-    if user_selected_asset_type == "Image":
-        final_asset_type_decision = "image"
-    elif user_selected_asset_type == "Video Clip":
-        final_asset_type_decision = "video_clip"
-    elif user_selected_asset_type == "Auto (Director's Choice)":
-        final_asset_type_decision = gemini_suggested_type if gemini_suggested_type == "video_clip" else "image"
-
-    generate_as_video = (final_asset_type_decision == "video_clip")
-    prompt_text_for_visual = ""
-
-    if generate_as_video:
-        # Construct prompt for text-to-video (e.g., RunwayML)
-        prompt_text_for_visual = construct_text_to_video_prompt(scene_data, st.session_state.character_definitions, st.session_state.global_style_additions)
-        # Note: seed_image_path could be an enhancement if DALL-E image is generated first
-    else:
-        # Construct prompt for DALL-E (image)
-        prompt_text_for_visual = construct_dalle_prompt(scene_data, st.session_state.character_definitions, st.session_state.global_style_additions)
-
-    if not prompt_text_for_visual:
-        logger.error(f"Visual prompt construction failed for scene {scene_data.get('scene_number', scene_index+1)} (Type: {final_asset_type_decision})")
-        return False
-
-    # Ensure session state lists are long enough
-    while len(st.session_state.scene_prompts) <= scene_index: st.session_state.scene_prompts.append("")
-    while len(st.session_state.generated_scene_assets) <= scene_index: st.session_state.generated_scene_assets.append(None)
-
-    st.session_state.scene_prompts[scene_index] = prompt_text_for_visual
-
-    # Filename base (extension will be added by visual_engine)
-    filename_base = f"scene_{scene_data.get('scene_number', scene_index+1)}_asset_v{version}"
-    runway_duration = scene_data.get('video_clip_duration_estimate_secs_감독', DEFAULT_SCENE_DURATION_SECS)
-    if runway_duration <= 0 : runway_duration = DEFAULT_SCENE_DURATION_SECS # Ensure positive duration
-
-    asset_result = st.session_state.visual_engine.generate_scene_asset(
-        image_prompt_text=prompt_text_for_visual, # This is generic, used for DALL-E or T2V
-        scene_data=scene_data,
-        scene_identifier_filename_base=filename_base,
-        generate_as_video_clip=generate_as_video,
-        runway_target_duration=runway_duration
-        # input_image_for_runway=None # TODO: Could be an enhancement
-    )
-
-    st.session_state.generated_scene_assets[scene_index] = asset_result # Store the whole dict
-
-    if asset_result and not asset_result['error'] and asset_result.get('path') and os.path.exists(asset_result['path']):
-        logger.info(f"Asset ({asset_result.get('type')}) generated for Scene {scene_data.get('scene_number', scene_index+1)}: {os.path.basename(asset_result['path'])}")
-        return True
-    else:
-        err_msg = asset_result.get('error_message', 'Unknown error') if asset_result else 'Asset result is None'
-        logger.warning(f"Asset generation FAILED for Scene {scene_data.get('scene_number', scene_index+1)}. Type attempted: {final_asset_type_decision}. Path was: {asset_result.get('path') if asset_result else 'N/A'}. Error: {err_msg}")
-        # Store a failure state
-        st.session_state.generated_scene_assets[scene_index] = {'path': None, 'type': 'none', 'error': True, 'error_message': err_msg, 'prompt_used': prompt_text_for_visual}
-        return False
-# <<< MODIFIED END >>>
-
-# --- UI Sidebar ---
-with st.sidebar:
-    st.title("🎬 CineGen AI Ultra+")
-    st.markdown("### Creative Seed")
-    user_idea = st.text_area("Core Story Idea / Theme:", "A lone wanderer searches for a mythical oasis in a vast, post-apocalyptic desert, haunted by mirages and mechanical scavengers.", height=120, key="user_idea_main_v5")
-    genre = st.selectbox("Primary Genre:", ["Cyberpunk", "Sci-Fi", "Fantasy", "Noir", "Thriller", "Western", "Post-Apocalyptic", "Historical Drama", "Surreal"], index=6, key="genre_main_v5")
-    mood = st.selectbox("Overall Mood:", ["Hopeful yet Desperate", "Mysterious & Eerie", "Gritty & Tense", "Epic & Awe-Inspiring", "Melancholy & Reflective", "Whimsical & Lighthearted"], index=0, key="mood_main_v5")
-    num_scenes = st.slider("Number of Key Scenes:", 1, 10, 2, key="num_scenes_main_v5")
-    creative_guidance_options = {"Standard Director": "standard", "Artistic Visionary": "more_artistic", "Experimental Storyteller": "experimental_narrative"}
-    selected_creative_guidance_key = st.selectbox("AI Creative Director Style:", options=list(creative_guidance_options.keys()), key="creative_guidance_select_v5")
-    actual_creative_guidance = creative_guidance_options[selected_creative_guidance_key]
-
-    if st.button("🌌 Generate Cinematic Treatment", type="primary", key="generate_treatment_btn_v5", use_container_width=True):
-        initialize_new_project()
-        if not user_idea.strip(): st.warning("Please provide a story idea.")
-        else:
-            with st.status("AI Director is envisioning your masterpiece...", expanded=True) as status:
+        try:
+            self.font = ImageFont.truetype(self.font_path_pil, self.font_size_pil) if self.font_path_pil else ImageFont.load_default()
+            if self.font_path_pil: logger.info(f"Pillow font loaded: {self.font_path_pil}.")
+            else: logger.warning("Using default Pillow font."); self.font_size_pil = 10
+        except IOError as e_font: logger.error(f"Pillow font loading IOError: {e_font}. Using default."); self.font = ImageFont.load_default(); self.font_size_pil = 10
+
+        self.openai_api_key = None; self.USE_AI_IMAGE_GENERATION = False
+        self.dalle_model = "dall-e-3"; self.image_size_dalle3 = "1792x1024"
+        self.video_frame_size = (1280, 720)
+        self.elevenlabs_api_key = None; self.USE_ELEVENLABS = False; self.elevenlabs_client = None
+        self.elevenlabs_voice_id = default_elevenlabs_voice_id
+        if VoiceSettings and ELEVENLABS_CLIENT_IMPORTED: self.elevenlabs_voice_settings = VoiceSettings(stability=0.60, similarity_boost=0.80, style=0.15, use_speaker_boost=True)
+        else: self.elevenlabs_voice_settings = None
+        self.pexels_api_key = None; self.USE_PEXELS = False
+        self.runway_api_key = None; self.USE_RUNWAYML = False; self.runway_client = None
+        logger.info("VisualEngine initialized.")
+
+    def set_openai_api_key(self,k): self.openai_api_key=k; self.USE_AI_IMAGE_GENERATION=bool(k); logger.info(f"DALL-E ({self.dalle_model}) {'Ready.' if k else 'Disabled.'}")
+    def set_elevenlabs_api_key(self,api_key, voice_id_from_secret=None):
+        self.elevenlabs_api_key=api_key
+        if voice_id_from_secret: self.elevenlabs_voice_id = voice_id_from_secret
+        if api_key and ELEVENLABS_CLIENT_IMPORTED and ElevenLabsAPIClient:
+            try: self.elevenlabs_client = ElevenLabsAPIClient(api_key=api_key); self.USE_ELEVENLABS=bool(self.elevenlabs_client); logger.info(f"ElevenLabs Client {'Ready' if self.USE_ELEVENLABS else 'Failed Init'} (Voice ID: {self.elevenlabs_voice_id}).")
+            except Exception as e: logger.error(f"ElevenLabs client init error: {e}. Disabled.", exc_info=True); self.USE_ELEVENLABS=False
+        else: self.USE_ELEVENLABS=False; logger.info("ElevenLabs Disabled (no key or SDK).")
+    def set_pexels_api_key(self,k): self.pexels_api_key=k; self.USE_PEXELS=bool(k); logger.info(f"Pexels Search {'Ready.' if k else 'Disabled.'}")
+    def set_runway_api_key(self, k):
+        self.runway_api_key = k
+        if k and RUNWAYML_SDK_IMPORTED and RunwayMLClient:
+            try: self.USE_RUNWAYML = True; logger.info(f"RunwayML Client (Placeholder SDK) {'Ready.' if self.USE_RUNWAYML else 'Failed Init.'}")
+            except Exception as e: logger.error(f"RunwayML client (Placeholder SDK) init error: {e}. Disabled.", exc_info=True); self.USE_RUNWAYML = False
+        elif k: self.USE_RUNWAYML = True; logger.info("RunwayML API Key set (direct API or placeholder).")
+        else: self.USE_RUNWAYML = False; logger.info("RunwayML Disabled (no API key).")
+
+    def _get_text_dimensions(self, text_content, font_obj):
+        default_line_height = getattr(font_obj, 'size', self.font_size_pil)
+        if not text_content: return 0, default_line_height
+        try:
+            if hasattr(font_obj, 'getbbox'):
+                bbox = font_obj.getbbox(text_content); width = bbox[2] - bbox[0]; height = bbox[3] - bbox[1]
+                return width, height if height > 0 else default_line_height
+            elif hasattr(font_obj, 'getsize'):
+                width, height = font_obj.getsize(text_content)
+                return width, height if height > 0 else default_line_height
+            else: return int(len(text_content) * default_line_height * 0.6), int(default_line_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)
+
+    def _create_placeholder_image_content(self, text_description, filename, size=None):
+        if size is None: size = self.video_frame_size
+        img = Image.new('RGB', size, color=(20, 20, 40)); draw = ImageDraw.Draw(img)
+        padding = 25; max_text_width = size[0] - (2 * padding); lines = []
+        if not text_description: text_description = "(Placeholder: No text description provided)"
+        words = text_description.split(); current_line = ""
+        for word in words:
+            test_line = current_line + word + " "; line_width_test, _ = self._get_text_dimensions(test_line.strip(), self.font)
+            if line_width_test <= max_text_width: current_line = test_line
+            else:
+                if current_line.strip(): lines.append(current_line.strip())
+                word_width, _ = self._get_text_dimensions(word, self.font)
+                if word_width > max_text_width:
+                    avg_char_w = self._get_text_dimensions("A", self.font)[0] or 10
+                    chars_that_fit = int(max_text_width / avg_char_w)
+                    lines.append(word[:chars_that_fit-3] + "..." if len(word) > chars_that_fit else word) # Corrected line
+                    current_line = ""
+                else: current_line = word + " "
+        if current_line.strip(): lines.append(current_line.strip())
+        if not lines and text_description:
+            avg_char_w = self._get_text_dimensions("A", self.font)[0] or 10; chars_that_fit = int(max_text_width / avg_char_w)
+            lines.append(text_description[:chars_that_fit-3] + "..." if len(text_description) > chars_that_fit else text_description)
+        elif not lines: lines.append("(Placeholder Text Error)")
+        _, single_line_height = self._get_text_dimensions("Ay", self.font); single_line_height = single_line_height if single_line_height > 0 else (self.font_size_pil + 2)
+        line_spacing = 2; max_lines_to_display = min(len(lines), (size[1]-(2*padding))//(single_line_height+line_spacing)) if single_line_height > 0 else 1
+        if max_lines_to_display <= 0: max_lines_to_display = 1
+        total_text_block_height = max_lines_to_display * single_line_height + (max_lines_to_display-1)*line_spacing
+        y_text_start = padding + (size[1]-(2*padding)-total_text_block_height)/2.0; current_y = y_text_start
+        for i in range(max_lines_to_display):
+            line_content = lines[i]; line_width_actual, _ = self._get_text_dimensions(line_content, self.font)
+            x_text = max(padding, (size[0]-line_width_actual)/2.0)
+            draw.text((x_text, current_y), line_content, font=self.font, fill=(200,200,180)); current_y += single_line_height + line_spacing
+            if i==6 and max_lines_to_display > 7 and len(lines) > max_lines_to_display:
+                ellipsis_width, _ = self._get_text_dimensions("...",self.font); x_ellipsis = max(padding, (size[0]-ellipsis_width)/2.0)
+                draw.text((x_ellipsis, current_y), "...", font=self.font, fill=(200,200,180)); break
+        filepath = os.path.join(self.output_dir, filename)
+        try: img.save(filepath); return filepath
+        except Exception as e: logger.error(f"Error saving placeholder image {filepath}: {e}", exc_info=True); return None
+
+    def _search_pexels_image(self, query, output_filename_base):
+        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"}
+        base_name, _ = os.path.splitext(output_filename_base)
+        pexels_filename = base_name + f"_pexels_{random.randint(1000,9999)}.jpg" # Use base_name
+        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() # This line and subsequent ones are now correctly in the try block
+            if data.get("photos") and len(data["photos"]) > 0:
+                photo_details = data["photos"][0]
+                photo_url = photo_details["src"]["large2x"]
+                logger.info(f"Downloading Pexels image from: {photo_url}")
+                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':
+                    logger.debug(f"Pexels image mode is {img_data.mode}, converting to RGB.")
+                    img_data = img_data.convert('RGB')
+                img_data.save(filepath)
+                logger.info(f"Pexels image saved successfully: {filepath}")
+                return filepath
+            else:
+                logger.info(f"No photos found on Pexels for query: '{effective_query}'")
+                return None
+        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 Exception as e: logger.error(f"General Pexels error for query '{query}': {e}", exc_info=True)
+        return None
+
+    def _generate_video_clip_with_runwayml(self, pt, iip, sifnb, tds=5): # Renamed for clarity
+        if not self.USE_RUNWAYML or not self.runway_api_key: logger.warning("RunwayML disabled."); return None
+        if not iip or not os.path.exists(iip): logger.error(f"Runway Gen-4 needs input image. Path invalid: {iip}"); return None
+        runway_dur = 10 if tds > 7 else 5
+        ovfn = sifnb.replace(".png", f"_runway_gen4_d{runway_dur}s.mp4") # sifnb should be base name
+        ovfp = os.path.join(self.output_dir, ovfn)
+        logger.info(f"Runway Gen-4 (Placeholder) img: {os.path.basename(iip)}, motion: '{pt[:100]}...', dur: {runway_dur}s")
+        logger.warning("Using PLACEHOLDER video for Runway Gen-4.")
+        img_clip=None; txt_c=None; final_ph_clip=None
+        try:
+            img_clip = ImageClip(iip).set_duration(runway_dur)
+            txt = f"Runway Gen-4 Placeholder\nInput: {os.path.basename(iip)}\nMotion: {pt[:50]}..."
+            txt_c = TextClip(txt, fontsize=24,color='white',font=self.video_overlay_font,bg_color='rgba(0,0,0,0.5)',size=(self.video_frame_size[0]*0.8,None),method='caption').set_duration(runway_dur).set_position('center')
+            final_ph_clip = CompositeVideoClip([img_clip, txt_c], size=img_clip.size)
+            final_ph_clip.write_videofile(ovfp,fps=24,codec='libx264',preset='ultrafast',logger=None,threads=2)
+            logger.info(f"Runway Gen-4 placeholder video: {ovfp}"); return ovfp
+        except Exception as e: logger.error(f"Runway Gen-4 placeholder error: {e}",exc_info=True); return None
+        finally:
+            if img_clip and hasattr(img_clip,'close'): img_clip.close()
+            if txt_c and hasattr(txt_c,'close'): txt_c.close()
+            if final_ph_clip and hasattr(final_ph_clip,'close'): final_ph_clip.close()
+
+    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 error {fp}: {e}",exc_info=True); return None
+        finally:
+            if tc and hasattr(tc,'close'): tc.close()
+
+    def generate_scene_asset(self, image_generation_prompt_text, motion_prompt_text_for_video,
+                             scene_data, scene_identifier_filename_base, # This is base_name, no ext
+                             generate_as_video_clip=False, runway_target_duration=5):
+        base_name = scene_identifier_filename_base # Already a base name
+        asset_info = {'path': None, 'type': 'none', 'error': True, 'prompt_used': image_generation_prompt_text, 'error_message': 'Generation not attempted'}
+        input_image_for_runway_path = None
+        image_filename_for_base = base_name + "_base_image.png" # Specific name for base image file
+        temp_image_asset_info = {'error': True, 'prompt_used': image_generation_prompt_text, 'error_message': 'Base image generation not attempted'}
+
+        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:
-                    status.write("Phase 1: Gemini crafting cinematic treatment... 📜"); logger.info("Phase 1: Cinematic Treatment Gen.")
-                    treatment_prompt = create_cinematic_treatment_prompt(user_idea, genre, mood, num_scenes, actual_creative_guidance)
-                    treatment_result_json_raw = st.session_state.gemini_handler.generate_story_breakdown(treatment_prompt) # Expect list of dicts
-                    if not isinstance(treatment_result_json_raw, list) or not treatment_result_json_raw: raise ValueError("Gemini returned invalid scene list format.")
-
-                    processed_scenes = []
-                    for scene_data_from_gemini in treatment_result_json_raw:
-                        scene_data_from_gemini['user_shot_type'] = scene_data_from_gemini.get('PROACTIVE_camera_work_감독', DEFAULT_SHOT_TYPE) # Default from Gemini's suggestion
-                        scene_data_from_gemini['user_scene_duration_secs'] = scene_data_from_gemini.get('video_clip_duration_estimate_secs_감독', DEFAULT_SCENE_DURATION_SECS)
-                        if scene_data_from_gemini['user_scene_duration_secs'] <=0: scene_data_from_gemini['user_scene_duration_secs'] = DEFAULT_SCENE_DURATION_SECS
-                        scene_data_from_gemini['user_selected_asset_type'] = "Auto (Director's Choice)" # Default for UI
-                        processed_scenes.append(scene_data_from_gemini)
-                    st.session_state.story_treatment_scenes = processed_scenes
-
-                    num_gen_scenes = len(st.session_state.story_treatment_scenes)
-                    # <<< MODIFIED START >>>
-                    st.session_state.scene_prompts = [""]*num_gen_scenes
-                    st.session_state.generated_scene_assets = [None]*num_gen_scenes # Initialize list for asset dicts
-                    # <<< MODIFIED END >>>
-                    logger.info(f"Phase 1 complete. {num_gen_scenes} scenes."); status.update(label="Treatment complete! ✅ Generating visuals...", state="running")
-
-                    status.write("Phase 2: Creating visual assets (Image/Video)... 🖼️🎬"); logger.info("Phase 2: Visual Asset Gen.")
-                    visual_successes = 0
-                    for i, sc_data in enumerate(st.session_state.story_treatment_scenes):
-                        sc_num_log = sc_data.get('scene_number', i+1)
-                        status.write(f"  Asset for Scene {sc_num_log}..."); logger.info(f"  Processing asset for Scene {sc_num_log}.")
-                        # <<< MODIFIED START >>> : Calling new function
-                        if generate_asset_for_scene_core(i, sc_data, version=1): # Default to 'Auto' asset type for initial gen
-                            visual_successes += 1
-                        # <<< MODIFIED END >>>
-
-                    current_status_label_ph2 = "Visual assets ready! "
-                    next_step_state = "running"
-                    if visual_successes == 0 and num_gen_scenes > 0:
-                        logger.error("Visual asset gen failed for all scenes."); current_status_label_ph2 = "Asset gen FAILED for all scenes."; next_step_state="error";
-                        status.update(label=current_status_label_ph2, state=next_step_state, expanded=True); st.stop()
-                    elif visual_successes < num_gen_scenes:
-                        logger.warning(f"Assets partially generated ({visual_successes}/{num_gen_scenes})."); current_status_label_ph2 = f"Assets partially generated ({visual_successes}/{num_gen_scenes}). "
-                    status.update(label=f"{current_status_label_ph2}Generating narration script...", state=next_step_state)
-                    if next_step_state == "error": st.stop()
-
-                    status.write("Phase 3: Generating narration script..."); logger.info("Phase 3: Narration Script Gen.")
-                    voice_style_for_prompt = st.session_state.get("selected_voice_style_for_generation", "cinematic_trailer")
-                    narr_prompt = create_narration_script_prompt_enhanced(st.session_state.story_treatment_scenes, mood, genre, voice_style_for_prompt)
-                    st.session_state.narration_script_display = st.session_state.gemini_handler.generate_image_prompt(narr_prompt) # This generates a string
-                    logger.info("Narration script generated."); status.update(label="Narration script ready! Synthesizing voice...", state="running")
-
-                    status.write("Phase 4: Synthesizing voice (ElevenLabs)... 🔊"); logger.info("Phase 4: Voice Synthesis.")
-                    st.session_state.overall_narration_audio_path = st.session_state.visual_engine.generate_narration_audio(st.session_state.narration_script_display)
-
-                    final_label = "All components ready! Storyboard below. 🚀"
-                    final_state_val = "complete"
-                    if not st.session_state.overall_narration_audio_path:
-                        final_label = f"{current_status_label_ph2}Storyboard ready (Voiceover skipped or failed)."
-                        logger.warning("Voiceover was skipped or failed.")
-                    else: logger.info("Voiceover generated successfully.")
-                    status.update(label=final_label, state=final_state_val, expanded=False)
-
-                except ValueError as ve: logger.error(f"ValueError: {ve}", exc_info=True); status.update(label=f"Input or Gemini response error: {ve}", state="error", expanded=True);
-                except Exception as e: logger.error(f"Unhandled Exception: {e}", exc_info=True); status.update(label=f"An unexpected error occurred: {e}", state="error", expanded=True);
-
-    st.markdown("---"); st.markdown("### Fine-Tuning Options")
-    # ... (Character, Global Style, Voice expanders - no changes needed here for this fix) ...
-    with st.expander("Define Characters", expanded=False):
-        char_name = st.text_input("Character Name", key="char_name_adv_ultra_v5"); char_desc = st.text_area("Visual Description", key="char_desc_adv_ultra_v5", height=100, placeholder="e.g., Jax: rugged male astronaut...")
-        if st.button("Save Character", key="add_char_adv_ultra_v5"):
-            if char_name and char_desc: st.session_state.character_definitions[char_name.strip().lower()] = char_desc.strip(); st.success(f"Char '{char_name.strip()}' saved.")
-            else: st.warning("Name and description needed.")
-        if st.session_state.character_definitions: st.caption("Current Characters:"); [st.markdown(f"**{k.title()}:** _{v}_") for k,v in st.session_state.character_definitions.items()]
-
-    with st.expander("Global Style Overrides", expanded=False):
-        presets = { "Default (Director's Choice)": "", "Hyper-Realistic Gritty Noir": "hyper-realistic gritty neo-noir, extreme detail, deep dynamic shadows, complex reflections on wet surfaces, cinematic film grain, desaturated palette with isolated vibrant neon accents (e.g. red, cyan), anamorphic lens distortion, atmospheric haze.", "Surreal Dreamscape Fantasy": "surreal dreamscape, epic fantasy elements, painterly with photorealistic details, impossible architecture, bioluminescent flora, otherworldly color palette (e.g., magenta skies, turquoise rivers), style of Roger Dean meets Zdzisław Beksiński.", "Vintage Analog Sci-Fi": "70s/80s analog sci-fi film aesthetic, tangible practical effects look, subtle light leaks, lens flares, warm filmic tones mixed with cool blues, detailed retro-futuristic technology with chunky buttons and CRT screens."}
-        sel_preset = st.selectbox("Base Style Preset:", options=list(presets.keys()), key="style_preset_adv_ultra_v5")
-        custom_kw = st.text_area("Additional Custom Style Keywords:", key="custom_style_adv_ultra_v5", height=80, placeholder="e.g., 'Dutch angle'")
-        cur_style = st.session_state.global_style_additions
-        if st.button("Apply Global Styles", key="apply_styles_adv_ultra_v5"):
-            final_s = presets[sel_preset];
-            if custom_kw.strip(): final_s = f"{final_s}, {custom_kw.strip()}" if final_s else custom_kw.strip()
-            st.session_state.global_style_additions = final_s.strip(); cur_style = final_s.strip()
-            if cur_style: st.success("Global styles applied!")
-            else: st.info("Global style additions cleared.")
-        if cur_style: st.caption(f"Active global styles: \"{cur_style}\"")
-
-    with st.expander("Voice & Narration Style", expanded=False):
-        default_voice_from_engine = "Rachel"
-        if hasattr(st.session_state, 'visual_engine') and st.session_state.visual_engine:
-            default_voice_from_engine = st.session_state.visual_engine.elevenlabs_voice_id
-
-        user_voice_id_override = st.text_input(
-            "ElevenLabs Voice ID (optional override):",
-            value=default_voice_from_engine,
-            key="el_voice_id_override_v5",
-            help=f"Defaulting to '{default_voice_from_engine}' from secrets/config. Enter a specific Voice ID from your ElevenLabs account to override."
-        )
-        prompt_v_styles = {"Cinematic Trailer": "cinematic_trailer", "Neutral Documentary": "documentary_neutral", "Character Introspection": "introspective_character"}
-        sel_prompt_v_style_key = st.selectbox("Narration Script Style:", list(prompt_v_styles.keys()), key="narr_style_sel_v5", index=0)
-
-        if st.button("Set Narrator Voice & Style", key="set_voice_btn_ultra_v5"):
-            final_voice_id_to_use = user_voice_id_override.strip()
-            if not final_voice_id_to_use:
-                final_voice_id_to_use = st.session_state.get("ELEVENLABS_VOICE_ID_CONFIG", "Rachel")
-
-            if hasattr(st.session_state, 'visual_engine'):
-                st.session_state.visual_engine.elevenlabs_voice_id = final_voice_id_to_use
-            st.session_state.selected_voice_style_for_generation = prompt_v_styles[sel_prompt_v_style_key]
-            st.success(f"Narrator Voice ID set to: {final_voice_id_to_use}. Script Style: {sel_prompt_v_style_key}")
-            logger.info(f"User updated ElevenLabs Voice ID to: {final_voice_id_to_use}, Script Style: {sel_prompt_v_style_key}")
-
-
-# --- Main Content Area ---
-st.header("🎬 Cinematic Storyboard & Treatment")
-if st.session_state.narration_script_display:
-    with st.expander("📜 View Full Narration Script", expanded=False): st.markdown(f"> _{st.session_state.narration_script_display}_")
-
-if not st.session_state.story_treatment_scenes: st.info("Use the sidebar to generate your cinematic treatment.")
-else:
-    for i_main, scene_content_display in enumerate(st.session_state.story_treatment_scenes):
-        scene_n = scene_content_display.get('scene_number', i_main + 1); scene_t = scene_content_display.get('scene_title', 'Untitled')
-        key_base = f"s{scene_n}_{''.join(filter(str.isalnum, scene_t[:10]))}_v5_{i_main}"
-        if "director_note" in scene_content_display and scene_content_display['director_note']: st.info(f"🎬 Director Note S{scene_n}: {scene_content_display['director_note']}")
-        st.subheader(f"SCENE {scene_n}: {scene_t.upper()}"); col_d, col_v = st.columns([0.45, 0.55])
-
-        with col_d: # Treatment and Controls Column
-            with st.expander("📝 Scene Treatment & Controls", expanded=True):
-                # Display scene textual details (emotional_beat, setting, etc.)
-                st.markdown(f"**Beat:** {scene_content_display.get('emotional_beat', 'N/A')}")
-                st.markdown(f"**Setting:** {scene_content_display.get('setting_description', 'N/A')}")
-                st.markdown(f"**Chars:** {', '.join(scene_content_display.get('characters_involved', ['N/A']))}")
-                st.markdown(f"**Focus Moment:** _{scene_content_display.get('character_focus_moment', 'N/A')}_")
-                st.markdown(f"**Plot Beat:** {scene_content_display.get('key_plot_beat', 'N/A')}")
-                st.markdown(f"**Dialogue Hook:** `\"{scene_content_display.get('suggested_dialogue_hook', '...')}\"`")
-                st.markdown("---")
-                st.markdown(f"**Dir. Visual Style:** _{scene_content_display.get('PROACTIVE_visual_style_감독', 'N/A')}_")
-                st.markdown(f"**Dir. Camera:** _{scene_content_display.get('PROACTIVE_camera_work_감독', 'N/A')}_")
-                st.markdown(f"**Dir. Sound:** _{scene_content_display.get('PROACTIVE_sound_design_감독', 'N/A')}_")
-                st.markdown("---")
-                st.markdown("##### Shot, Pacing & Asset Controls")
-
-                # User Shot Type (Camera Angle)
-                current_shot_type = st.session_state.story_treatment_scenes[i_main].get('user_shot_type', DEFAULT_SHOT_TYPE)
-                try: shot_type_index = SHOT_TYPES_OPTIONS.index(current_shot_type)
-                except ValueError: shot_type_index = SHOT_TYPES_OPTIONS.index(DEFAULT_SHOT_TYPE)
-                new_shot_type = st.selectbox("Dominant Shot Type:", options=SHOT_TYPES_OPTIONS, index=shot_type_index, key=f"shot_type_widget_{key_base}")
-                if new_shot_type != current_shot_type:
-                    st.session_state.story_treatment_scenes[i_main]['user_shot_type'] = new_shot_type
-                    # Consider if a re-run is needed or if DALL-E prompt should be updated based on this
-
-                # User Scene Duration
-                current_duration = st.session_state.story_treatment_scenes[i_main].get('user_scene_duration_secs', DEFAULT_SCENE_DURATION_SECS)
-                new_duration = st.number_input("Scene Duration (seconds):", min_value=1, max_value=300, value=current_duration, step=1, key=f"duration_widget_{key_base}")
-                if new_duration != current_duration:
-                    st.session_state.story_treatment_scenes[i_main]['user_scene_duration_secs'] = new_duration
-
-                # <<< MODIFIED START >>> : User Asset Type Selection
-                current_user_asset_type = st.session_state.story_treatment_scenes[i_main].get('user_selected_asset_type', "Auto (Director's Choice)")
-                try: asset_type_idx = ASSET_TYPE_OPTIONS.index(current_user_asset_type)
-                except ValueError: asset_type_idx = 0 # Default to Auto
-                new_user_asset_type = st.selectbox("Asset Type Override:", ASSET_TYPE_OPTIONS, index=asset_type_idx, key=f"asset_type_sel_{key_base}",
-                                                   help="Choose 'Image' or 'Video Clip'. 'Auto' uses Gemini's suggestion.")
-                if new_user_asset_type != current_user_asset_type:
-                    st.session_state.story_treatment_scenes[i_main]['user_selected_asset_type'] = new_user_asset_type
-                    # This change will be picked up by regeneration buttons
-                # <<< MODIFIED END >>>
-
-                st.markdown("---")
-                # Display generated prompt for the asset
-                current_prompt_for_asset = st.session_state.scene_prompts[i_main] if i_main < len(st.session_state.scene_prompts) else None
-                if current_prompt_for_asset:
-                     with st.popover("👁️ View Asset Generation Prompt"):
-                        st.markdown(f"**Prompt used for current asset:**"); st.code(current_prompt_for_asset, language='text')
-
-                pexels_q = scene_content_display.get('pexels_search_query_감독', None)
-                if pexels_q: st.caption(f"Pexels Fallback Query: `{pexels_q}`")
-
-        with col_v: # Visuals Column
-            # <<< MODIFIED START >>> : Display logic for different asset types
-            current_asset_data = st.session_state.generated_scene_assets[i_main] if i_main < len(st.session_state.generated_scene_assets) else None
-            if current_asset_data and not current_asset_data.get('error') and current_asset_data.get('path') and os.path.exists(current_asset_data['path']):
-                asset_path = current_asset_data['path']
-                asset_type = current_asset_data.get('type', 'image') # Default to image if type missing
+                    img_fp_dalle = os.path.join(self.output_dir, image_filename_for_base)
+                    logger.info(f"Attempt {att_n+1} DALL-E (base img): {image_generation_prompt_text[:100]}...")
+                    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)
+                    if rp: logger.info(f"DALL-E revised: {rp[:100]}...")
+                    ir = requests.get(iu, timeout=120); 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(img_fp_dalle); logger.info(f"DALL-E base image: {img_fp_dalle}");
+                    input_image_for_runway_path = img_fp_dalle
+                    temp_image_asset_info = {'path': img_fp_dalle, 'type': 'image', 'error': False, 'prompt_used': image_generation_prompt_text, 'revised_prompt': rp}
+                    break
+                except openai.RateLimitError as e: logger.warning(f"OpenAI Rate Limit {att_n+1}: {e}. Retry..."); time.sleep(5*(att_n+1)); temp_image_asset_info['error_message']=str(e)
+                except Exception as e: logger.error(f"DALL-E error: {e}", exc_info=True); temp_image_asset_info['error_message']=str(e); break
+            if temp_image_asset_info['error']: logger.warning(f"DALL-E failed after {att_n+1} attempts for base image.")
+        
+        if temp_image_asset_info['error'] and self.USE_PEXELS:
+            pqt = scene_data.get('pexels_search_query_감독', f"{scene_data.get('emotional_beat','')} {scene_data.get('setting_description','')}")
+            pp = self._search_pexels_image(pqt, image_filename_for_base) # Use base name for pexels
+            if pp: input_image_for_runway_path = pp; temp_image_asset_info = {'path': pp, 'type': 'image', 'error': False, 'prompt_used': f"Pexels: {pqt}"}
+            else: current_em = temp_image_asset_info.get('error_message',""); temp_image_asset_info['error_message']=(current_em + " Pexels failed.").strip()
+
+        if temp_image_asset_info['error']:
+            logger.warning("Base image (DALL-E/Pexels) failed. Placeholder base image.")
+            ppt = temp_image_asset_info.get('prompt_used', image_generation_prompt_text)
+            php = self._create_placeholder_image_content(f"[Base Img Placeholder] {ppt[:100]}...", image_filename_for_base)
+            if php: input_image_for_runway_path = php; temp_image_asset_info = {'path': php, 'type': 'image', 'error': False, 'prompt_used': ppt}
+            else: current_em=temp_image_asset_info.get('error_message',"");temp_image_asset_info['error_message']=(current_em + " Base placeholder failed.").strip()
+        
+        if generate_as_video_clip:
+            if self.USE_RUNWAYML and input_image_for_runway_path:
+                video_path = self._generate_video_clip_with_runwayml(motion_prompt_text_for_video, input_image_for_runway_path, base_name, runway_target_duration) # Pass base_name
+                if video_path and os.path.exists(video_path):
+                    return {'path': video_path, 'type': 'video', 'error': False, 'prompt_used': motion_prompt_text_for_video, 'base_image_path': input_image_for_runway_path}
+                else: asset_info = temp_image_asset_info; asset_info['error'] = True; asset_info['error_message'] = "RunwayML video gen failed; using base image."; asset_info['type'] = 'image'; return asset_info
+            elif not self.USE_RUNWAYML: asset_info = temp_image_asset_info; asset_info['error_message'] = "RunwayML disabled; using base image."; asset_info['type'] = 'image'; return asset_info
+            else: asset_info = temp_image_asset_info; asset_info['error_message'] = (asset_info.get('error_message',"") + " Base image failed, Runway video not attempted.").strip(); asset_info['type'] = 'image'; return asset_info
+        else: return temp_image_asset_info
+
+    def generate_narration_audio(self, ttn, ofn="narration_overall.mp3"):
+        if not self.USE_ELEVENLABS or not self.elevenlabs_client or not ttn: logger.info("11L skip."); return None; afp=os.path.join(self.output_dir,ofn)
+        try: logger.info(f"11L audio (Voice:{self.elevenlabs_voice_id}): {ttn[: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()")
+        elif hasattr(self.elevenlabs_client,'generate_stream'):asm=self.elevenlabs_client.generate_stream;logger.info("Using 11L .generate_stream()")
+        elif hasattr(self.elevenlabs_client,'generate'):logger.info("Using 11L .generate()");vp=Voice(voice_id=str(self.elevenlabs_voice_id),settings=self.elevenlabs_voice_settings)if Voice and self.elevenlabs_voice_settings else str(self.elevenlabs_voice_id);ab=self.elevenlabs_client.generate(text=ttn,voice=vp,model="eleven_multilingual_v2");
+        with open(afp,"wb")as f:f.write(ab);logger.info(f"11L audio (non-stream): {afp}");return afp
+        else:logger.error("No 11L audio method.");return None
+        if asm:vps={"voice_id":str(self.elevenlabs_voice_id)}
+        if self.elevenlabs_voice_settings:
+            if hasattr(self.elevenlabs_voice_settings,'model_dump'):vps["voice_settings"]=self.elevenlabs_voice_settings.model_dump()
+            elif hasattr(self.elevenlabs_voice_settings,'dict'):vps["voice_settings"]=self.elevenlabs_voice_settings.dict()
+            else:vps["voice_settings"]=self.elevenlabs_voice_settings
+        adi=asm(text=ttn,model_id="eleven_multilingual_v2",**vps)
+        with open(afp,"wb")as f:
+            for c in adi:
+                if c:f.write(c)
+        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):
+        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':
-                    st.image(asset_path, caption=f"Scene {scene_n} ({asset_type}): {scene_t}")
+                    pil_img = Image.open(asset_path); logger.debug(f"S{scene_num}: Loaded img. Mode:{pil_img.mode}, Size:{pil_img.size}")
+                    img_rgba = pil_img.convert('RGBA') if pil_img.mode != 'RGBA' else pil_img.copy()
+                    thumb = img_rgba.copy(); rf = Image.Resampling.LANCZOS if hasattr(Image.Resampling,'LANCZOS') else Image.BILINEAR; thumb.thumbnail(self.video_frame_size,rf)
+                    cv_rgba = Image.new('RGBA',self.video_frame_size,(0,0,0,0)); xo,yo=(self.video_frame_size[0]-thumb.width)//2,(self.video_frame_size[1]-thumb.height)//2
+                    cv_rgba.paste(thumb,(xo,yo),thumb)
+                    final_rgb_pil = Image.new("RGB",self.video_frame_size,(0,0,0)); final_rgb_pil.paste(cv_rgba,mask=cv_rgba.split()[3])
+                    dbg_path = os.path.join(self.output_dir,f"debug_PRE_NUMPY_S{scene_num}.png"); final_rgb_pil.save(dbg_path); logger.info(f"DEBUG: Saved PRE_NUMPY_S{scene_num} to {dbg_path}")
+                    frame_np = np.array(final_rgb_pil,dtype=np.uint8);
+                    if not frame_np.flags['C_CONTIGUOUS']: frame_np=np.ascontiguousarray(frame_np,dtype=np.uint8)
+                    logger.debug(f"S{scene_num}: NumPy for MoviePy. Shape:{frame_np.shape}, DType:{frame_np.dtype}, C-Contig:{frame_np.flags['C_CONTIGUOUS']}")
+                    if frame_np.size==0 or frame_np.ndim!=3 or frame_np.shape[2]!=3: logger.error(f"S{scene_num}: Invalid NumPy. Skip."); continue
+                    clip_base = ImageClip(frame_np,transparent=False).set_duration(scene_dur)
+                    mvpy_dbg_path=os.path.join(self.output_dir,f"debug_MOVIEPY_FRAME_S{scene_num}.png"); clip_base.save_frame(mvpy_dbg_path,t=0.1); logger.info(f"DEBUG: Saved MOVIEPY_FRAME_S{scene_num} to {mvpy_dbg_path}")
+                    clip_fx = clip_base
+                    try: es=random.uniform(1.03,1.08); clip_fx=clip_base.fx(vfx.resize,lambda t:1+(es-1)*(t/scene_dur) if scene_dur>0 else 1).set_position('center')
+                    except Exception as e: logger.error(f"S{scene_num} Ken Burns error: {e}",exc_info=False)
+                    current_scene_mvpy_clip = clip_fx
                 elif asset_type == 'video':
+                    src_clip=None
                     try:
-                        with open(asset_path, 'rb') as vf: video_bytes = vf.read()
-                        st.video(video_bytes, format="video/mp4", start_time=0)
-                        st.caption(f"Scene {scene_n} ({asset_type}): {scene_t}")
-                    except Exception as e_vid:
-                        st.error(f"Error displaying video {asset_path}: {e_vid}")
-                        logger.error(f"Error displaying video {asset_path}: {e_vid}", exc_info=True)
-                else:
-                    st.warning(f"Unknown asset type '{asset_type}' for Scene {scene_n}.")
-            else: # No asset, or error during generation
-                if st.session_state.story_treatment_scenes: # Check if treatment exists
-                    error_msg = current_asset_data.get('error_message', 'Visual pending or failed.') if current_asset_data else 'Visual pending or failed.'
-                    st.caption(error_msg)
-            # <<< MODIFIED END >>>
-
-            with st.popover(f"✏️ Edit Scene {scene_n} Treatment"):
-                fb_script = st.text_area("Changes to treatment:", key=f"treat_fb_{key_base}", height=150)
-                if st.button(f"🔄 Update Scene {scene_n} Treatment", key=f"regen_treat_btn_{key_base}"):
-                    if fb_script:
-                        with st.status(f"Updating Scene {scene_n} Treatment & Asset...", expanded=True) as s_treat_regen:
-                            # Preserve user's shot type, duration, and asset type choices
-                            user_shot_type = st.session_state.story_treatment_scenes[i_main]['user_shot_type']
-                            user_duration = st.session_state.story_treatment_scenes[i_main]['user_scene_duration_secs']
-                            user_asset_type_choice = st.session_state.story_treatment_scenes[i_main]['user_selected_asset_type']
-
-                            prompt_text = create_scene_regeneration_prompt(scene_content_display, fb_script, st.session_state.story_treatment_scenes)
-                            try:
-                                updated_sc_data_from_gemini = st.session_state.gemini_handler.regenerate_scene_script_details(prompt_text)
-                                # Merge, but prioritize user's UI choices for duration/shot/asset type
-                                updated_sc_data = {**updated_sc_data_from_gemini} # Start with Gemini's new script
-                                updated_sc_data['user_shot_type'] = user_shot_type
-                                updated_sc_data['user_scene_duration_secs'] = user_duration
-                                updated_sc_data['user_selected_asset_type'] = user_asset_type_choice
-                                # Gemini might re-suggest asset type/duration, but user's direct settings take precedence for next gen
-                                # We can log if Gemini's suggestion differs from user's explicit choice.
-                                if updated_sc_data.get('suggested_asset_type_감독') != user_asset_type_choice and user_asset_type_choice != "Auto (Director's Choice)":
-                                    logger.info(f"Scene {scene_n}: User asset choice '{user_asset_type_choice}' overrides Gemini suggestion '{updated_sc_data.get('suggested_asset_type_감독')}'.")
-
-
-                                st.session_state.story_treatment_scenes[i_main] = updated_sc_data
-                                s_treat_regen.update(label="Treatment updated! Regenerating asset...", state="running")
-
-                                v_num = 1
-                                if current_asset_data and current_asset_data.get('path') and os.path.exists(current_asset_data['path']):
-                                    try: b,_=os.path.splitext(os.path.basename(current_asset_data['path'])); v_num = int(b.split('_v')[-1])+1 if '_v' in b else 2
-                                    except: v_num = 2
-                                else: v_num = 1
-                                # <<< MODIFIED START >>> : Call new function, pass user_selected_asset_type
-                                if generate_asset_for_scene_core(i_main, updated_sc_data, version=v_num, user_selected_asset_type=user_asset_type_choice):
-                                    s_treat_regen.update(label="Treatment & Asset Updated! 🎉", state="complete", expanded=False)
-                                else: s_treat_regen.update(label="Treatment updated, asset failed.", state="complete", expanded=False)
-                                # <<< MODIFIED END >>>
-                                st.rerun()
-                            except Exception as e_regen: s_treat_regen.update(label=f"Error: {e_regen}", state="error"); logger.error(f"Scene treatment regen error: {e_regen}", exc_info=True)
-                    else: st.warning("Please provide feedback.")
-
-            with st.popover(f"🎨 Edit Scene {scene_n} Visual Prompt"):
-                prompt_to_edit = st.session_state.scene_prompts[i_main] if i_main < len(st.session_state.scene_prompts) else "No prompt generated yet."
-                st.caption("Current Asset Generation Prompt:"); st.code(prompt_to_edit, language='text')
-                fb_visual = st.text_area("Changes for asset generation prompt:", key=f"visual_fb_{key_base}", height=150)
-                if st.button(f"🔄 Update Scene {scene_n} Asset", key=f"regen_visual_btn_{key_base}"):
-                    if fb_visual:
-                        with st.status(f"Refining prompt & asset for Scene {scene_n}...", expanded=True) as s_visual_regen:
-                            user_asset_type_choice = st.session_state.story_treatment_scenes[i_main]['user_selected_asset_type']
-                            is_video_prompt = (user_asset_type_choice == "Video Clip") or \
-                                              (user_asset_type_choice == "Auto (Director's Choice)" and \
-                                               scene_content_display.get('suggested_asset_type_감독') == 'video_clip')
-
-                            # Note: Visual regeneration prompt is primarily for DALL-E (images).
-                            # For video, we might need a different refinement strategy or just regenerate with the same prompt construction.
-                            # For simplicity here, if it's a video, we'll regenerate the prompt using standard construction.
-                            # If it's an image, we use Gemini to refine the DALL-E prompt.
-                            new_asset_gen_prompt = ""
-                            if not is_video_prompt : # Refining an image prompt
-                                ref_req_prompt_for_gemini = create_visual_regeneration_prompt(prompt_to_edit, fb_visual, scene_content_display,
-                                    st.session_state.character_definitions, st.session_state.global_style_additions)
-                                try:
-                                    new_asset_gen_prompt = st.session_state.gemini_handler.refine_image_prompt_from_feedback(ref_req_prompt_for_gemini)
-                                    st.session_state.scene_prompts[i_main] = new_asset_gen_prompt
-                                    s_visual_regen.update(label="Image prompt refined by Gemini! Regenerating asset...", state="running")
-                                except Exception as e_gemini_refine:
-                                    s_visual_regen.update(label=f"Error refining prompt: {e_gemini_refine}", state="error");
-                                    logger.error(f"Visual prompt refinement error: {e_gemini_refine}", exc_info=True)
-                                    continue # Skip asset generation if prompt refinement failed
-                            else: # For video, or auto choosing video, reconstruct the prompt
-                                new_asset_gen_prompt = construct_text_to_video_prompt(scene_content_display, st.session_state.character_definitions, st.session_state.global_style_additions)
-                                st.session_state.scene_prompts[i_main] = new_asset_gen_prompt
-                                s_visual_regen.update(label="Video prompt reconstructed! Regenerating asset...", state="running")
-
-
-                            v_num = 1
-                            if current_asset_data and current_asset_data.get('path') and os.path.exists(current_asset_data['path']):
-                                try: b,_=os.path.splitext(os.path.basename(current_asset_data['path'])); v_num = int(b.split('_v')[-1])+1 if '_v' in b else 2
-                                except: v_num=2
-                            else: v_num = 1
-
-                            # <<< MODIFIED START >>> : Call new function
-                            # Pass the current scene_content_display as its prompt might have changed.
-                            # User asset type choice from the scene data for consistency
-                            if generate_asset_for_scene_core(i_main, st.session_state.story_treatment_scenes[i_main], version=v_num, user_selected_asset_type=user_asset_type_choice):
-                                s_visual_regen.update(label="Asset Updated! 🎉", state="complete", expanded=False)
-                            else: s_visual_regen.update(label="Prompt updated, asset regeneration failed.", state="complete", expanded=False)
-                            # <<< MODIFIED END >>>
-                            st.rerun()
-                    else: st.warning("Please provide feedback.")
-        st.markdown("---")
-
-    # Video Assembly Button
-    # <<< MODIFIED START >>> : Check generated_scene_assets and use its data
-    if st.session_state.story_treatment_scenes and any(asset_info and not asset_info.get('error') and asset_info.get('path') for asset_info in st.session_state.generated_scene_assets if asset_info is not None):
-        if st.button("🎬 Assemble Narrated Cinematic Animatic", key="assemble_ultra_video_btn_v5", type="primary", use_container_width=True):
-            with st.status("Assembling Ultra Animatic...", expanded=True) as status_vid:
-                assets_for_video_assembly = []
-                for i_v, sc_c in enumerate(st.session_state.story_treatment_scenes):
-                    asset_info = st.session_state.generated_scene_assets[i_v] if i_v < len(st.session_state.generated_scene_assets) else None
-                    if asset_info and not asset_info.get('error') and asset_info.get('path') and os.path.exists(asset_info['path']):
-                        assets_for_video_assembly.append({
-                            'path': asset_info['path'],
-                            'type': asset_info.get('type', 'image'), # Default to image if type missing
-                            'scene_num': sc_c.get('scene_number', i_v + 1),
-                            'key_action': sc_c.get('key_plot_beat', ''),
-                            'duration': sc_c.get('user_scene_duration_secs', DEFAULT_SCENE_DURATION_SECS) # Use user-set duration
-                        })
-                        status_vid.write(f"Adding Scene {sc_c.get('scene_number', i_v + 1)} ({asset_info.get('type')}).")
-                    else:
-                        logger.warning(f"Skipping Scene {sc_c.get('scene_number', i_v+1)} for video: No valid asset.")
-
-                if assets_for_video_assembly:
-                    status_vid.write("Calling video engine...");
-                    st.session_state.video_path = st.session_state.visual_engine.assemble_animatic_from_assets( # Changed method name
-                        asset_data_list=assets_for_video_assembly, # Pass the list of asset dicts
-                        overall_narration_path=st.session_state.overall_narration_audio_path,
-                        output_filename="cinegen_ultra_animatic.mp4",
-                        fps=24
-                    )
-                    if st.session_state.video_path and os.path.exists(st.session_state.video_path):
-                        status_vid.update(label="Ultra animatic assembled! 🎉", state="complete", expanded=False); st.balloons()
-                    else:
-                        status_vid.update(label="Video assembly failed. Check logs.", state="error", expanded=False); logger.error("Video assembly returned None or file does not exist.")
-                else:
-                    status_vid.update(label="No valid assets for video assembly.", state="error", expanded=False); logger.warning("No valid assets found for video assembly.")
-    elif st.session_state.story_treatment_scenes: st.info("Generate visual assets before assembling video.")
-    # <<< MODIFIED END >>>
-
-    if st.session_state.video_path and os.path.exists(st.session_state.video_path):
-        st.header("🎬 Generated Cinematic Animatic");
+                        src_clip=VideoFileClip(asset_path,target_resolution=(self.video_frame_size[1],self.video_frame_size[0])if self.video_frame_size else None, audio=False)
+                        tmp_clip=src_clip
+                        if src_clip.duration!=scene_dur:
+                            if src_clip.duration>scene_dur:tmp_clip=src_clip.subclip(0,scene_dur)
+                            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)
+                        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:
+                        if src_clip and src_clip is not current_scene_mvpy_clip and hasattr(src_clip,'close'):src_clip.close()
+                else: logger.warning(f"S{scene_num} Unknown asset type '{asset_type}'. Skip."); continue
+                if current_scene_mvpy_clip and key_action:
+                    try:
+                        to_dur=min(current_scene_mvpy_clip.duration-0.5,current_scene_mvpy_clip.duration*0.8)if current_scene_mvpy_clip.duration>0.5 else current_scene_mvpy_clip.duration
+                        to_start=0.25
+                        txt_c=TextClip(f"Scene {scene_num}\n{key_action}",fontsize=self.video_overlay_font_size,color=self.video_overlay_font_color,font=self.video_overlay_font,bg_color='rgba(10,10,20,0.7)',method='caption',align='West',size=(self.video_frame_size[0]*0.9,None),kerning=-1,stroke_color='black',stroke_width=1.5).set_duration(to_dur).set_start(to_start).set_position(('center',0.92),relative=True)
+                        current_scene_mvpy_clip=CompositeVideoClip([current_scene_mvpy_clip,txt_c],size=self.video_frame_size,use_bgclip=True)
+                    except Exception as e:logger.error(f"S{scene_num} TextClip error:{e}. No text.",exc_info=True)
+                if current_scene_mvpy_clip:processed_clips.append(current_scene_mvpy_clip);logger.info(f"S{scene_num} Processed. Dur:{current_scene_mvpy_clip.duration:.2f}s.")
+            except Exception as e:logger.error(f"MAJOR Error S{scene_num} ({asset_path}):{e}",exc_info=True)
+            finally:
+                if current_scene_mvpy_clip and hasattr(current_scene_mvpy_clip,'close'):
+                    try: current_scene_mvpy_clip.close()
+                    except: pass
+
+        if not processed_clips:logger.warning("No clips processed. Abort.");return None
+        td=0.75
         try:
-            with open(st.session_state.video_path, 'rb') as vf_obj: video_bytes = vf_obj.read()
-            st.video(video_bytes, format="video/mp4")
-            st.download_button(label="Download Ultra Animatic", data=video_bytes, file_name=os.path.basename(st.session_state.video_path), mime="video/mp4", use_container_width=True, key="download_ultra_video_btn_v5" )
-        except Exception as e: st.error(f"Error displaying video: {e}"); logger.error(f"Error displaying video: {e}", exc_info=True)
-
-# --- Footer ---
-st.sidebar.markdown("---"); st.sidebar.caption("CineGen AI Ultra+ | Visionary Cinematic Pre-Production")
+            logger.info(f"Concatenating {len(processed_clips)} clips.");
+            if len(processed_clips)>1:final_clip=concatenate_videoclips(processed_clips,padding=-td if td>0 else 0,method="compose")
+            elif processed_clips:final_clip=processed_clips[0]
+            if not final_clip:logger.error("Concatenation failed.");return None
+            logger.info(f"Concatenated dur:{final_clip.duration:.2f}s")
+            if td>0 and final_clip.duration>0:
+                if final_clip.duration>td*2:final_clip=final_clip.fx(vfx.fadein,td).fx(vfx.fadeout,td)
+                else:final_clip=final_clip.fx(vfx.fadein,min(td,final_clip.duration/2.0))
+            if overall_narration_path and os.path.exists(overall_narration_path) and final_clip.duration>0:
+                try:narration_clip=AudioFileClip(overall_narration_path);final_clip=final_clip.set_audio(narration_clip);logger.info("Narration added.")
+                except Exception as e:logger.error(f"Narration add error:{e}",exc_info=True)
+            elif final_clip.duration<=0:logger.warning("Video no duration. No audio.")
+            if final_clip and final_clip.duration>0:
+                op=os.path.join(self.output_dir,output_filename);logger.info(f"Writing video:{op} (Dur:{final_clip.duration:.2f}s)")
+                final_clip.write_videofile(op,fps=fps,codec='libx264',preset='medium',audio_codec='aac',temp_audiofile=os.path.join(self.output_dir,f'temp-audio-{os.urandom(4).hex()}.m4a'),remove_temp=True,threads=os.cpu_count()or 2,logger='bar',bitrate="5000k",ffmpeg_params=["-pix_fmt", "yuv420p"])
+                logger.info(f"Video created:{op}");return op
+            else:logger.error("Final clip invalid. No write.");return None
+        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.")
+            clips_to_close = processed_clips + ([narration_clip] if narration_clip else []) + ([final_clip] if final_clip else [])
+            for clip_obj in clips_to_close:
+                if clip_obj and hasattr(clip_obj, 'close'):
+                    try: clip_obj.close()
+                    except Exception as e_close: logger.warning(f"Ignoring error while closing a clip: {e_close}")