Update app.py

app.py

@@ -99,11 +99,23 @@ def get_audio_duration(mp3_path: str) -> float:
     except Exception:
         return 5.0
 
-TAG_RE = re.compile(r'[<\[]\s*generate_?chart\s*[:=]?\s*["\']?(?P<d>[^>\]\'"”’]+?)["\']?\s*[>\]]', re.I)
+TAG_RE = re.compile(r'[<\[]\s*generate_?chart\s*[:=]?\s*["\']?(?P<d>[^>\]\'""']+?)["\']?\s*[>\]]', re.I)
 extract_chart_tags = lambda t: list(dict.fromkeys(m.group("d").strip() for m in TAG_RE.finditer(t or "")))
 def repl_tags(txt: str, mp: dict, fn):  # fn replaces tag text
     return TAG_RE.sub(lambda m: fn(mp[m.group("d").strip()]) if m.group("d").strip() in mp else m.group(0), txt)
 
+def clean_narrator_text(text: str) -> str:
+    """Clean text for narrator by removing scene numbers and chart descriptions."""
+    # Remove scene numbers (e.g., "Scene 1:", "1.", etc.)
+    text = re.sub(r'(?i)(?:^|\n)\s*(?:scene\s*\d+[:.]?\s*|^\d+\.?\s*)', '', text)
+    # Remove chart generation tags completely
+    text = TAG_RE.sub('', text)
+    # Remove common chart descriptions and references
+    text = re.sub(r'(?i)(?:the\s+)?chart\s+(?:shows|displays|illustrates|demonstrates)[^.]*\.?', '', text)
+    text = re.sub(r'(?i)(?:as\s+)?(?:shown|displayed|illustrated|demonstrated)\s+(?:in\s+)?(?:the\s+)?(?:chart|graph|figure)[^.]*\.?', '', text)
+    # Clean up extra whitespace
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
 
 # ─────────────────────────────────────────────────────────────────────────────
 # PDF GENERATION (UNCHANGED)
@@ -123,13 +135,20 @@ def build_pdf(md, charts):
 # GENERIC ANIMATION HELPERS (VIDEO PATH ONLY)
 # ─────────────────────────────────────────────────────────────────────────────
 def animate_image_fade(img_cv2: np.ndarray, duration: float, out_path: Path, fps: int = FPS) -> str:
+    """Animate image with fade-in effect."""
     frames = max(int(duration * fps), fps)       # at least 1 second
-    video  = cv2.VideoWriter(str(out_path), cv2.VideoWriter_fourcc(*"mp4v"), fps, (WIDTH, HEIGHT))
-    blank  = np.full_like(img_cv2, 255)
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    video = cv2.VideoWriter(str(out_path), fourcc, fps, (WIDTH, HEIGHT))
+    
+    if video is None or not video.isOpened():
+        raise RuntimeError(f"Failed to create video writer for {out_path}")
+    
+    blank = np.full_like(img_cv2, 255)
     for i in range(frames):
-        alpha = i / frames
+        alpha = i / (frames - 1) if frames > 1 else 1.0
         frame = cv2.addWeighted(blank, 1 - alpha, img_cv2, alpha, 0)
         video.write(frame)
+    
     video.release()
     return str(out_path)
 
@@ -138,113 +157,241 @@ def animate_chart(desc: str, df: pd.DataFrame, duration: float,
     """
     desc  ->  'chart_type | explanation'
     Valid chart_type: line, bar, scatter, pie, hist
-    Builds an accurate static figure, then animates a quick reveal (≤30 frames).
+    Builds an accurate static figure, then animates a smooth reveal.
     """
     try:
         chart_type, *rest = [s.strip().lower() for s in desc.split("|", 1)]
         chart_type = chart_type or "line"
-        title      = rest[0] if rest else desc
+        title = rest[0] if rest else desc
 
         # === Prepare aggregated data =================================================
         if chart_type == "pie":
-            cat = df.select_dtypes(exclude="number").columns[0]
-            num = df.select_dtypes(include="number").columns[0]
+            cat_cols = df.select_dtypes(exclude="number").columns
+            num_cols = df.select_dtypes(include="number").columns
+            if len(cat_cols) == 0 or len(num_cols) == 0:
+                raise ValueError("Need categorical and numeric columns for pie chart")
+            cat = cat_cols[0]
+            num = num_cols[0]
             plot_df = df.groupby(cat)[num].sum().sort_values(ascending=False).head(8)
         elif chart_type in ("bar", "hist"):
-            num = df.select_dtypes(include="number").columns[0]
-            plot_df = df[num]
+            num_cols = df.select_dtypes(include="number").columns
+            if len(num_cols) == 0:
+                raise ValueError("Need numeric columns for bar/hist chart")
+            num = num_cols[0]
+            if chart_type == "bar":
+                # For bar chart, group by index or first categorical column
+                cat_cols = df.select_dtypes(exclude="number").columns
+                if len(cat_cols) > 0:
+                    plot_df = df.groupby(cat_cols[0])[num].sum().sort_values(ascending=False).head(15)
+                else:
+                    plot_df = df[num].head(15)
+            else:  # hist
+                plot_df = df[num].dropna()
         else:  # line / scatter
-            nums = df.select_dtypes(include="number").columns[:2]
-            plot_df = df[list(nums)].sort_index()
+            nums = df.select_dtypes(include="number").columns
+            if len(nums) == 0:
+                raise ValueError("Need numeric columns for line/scatter chart")
+            plot_df = df[list(nums[:2])].dropna()
 
-        # === Build figure ============================================================
+        # === Build animated figure ===================================================
         fig, ax = plt.subplots(figsize=(WIDTH / 100, HEIGHT / 100), dpi=100)
-        frames  = max(10, min(30, int(duration * fps)))
+        fig.patch.set_facecolor('white')
+        ax.set_facecolor('white')
+        
+        frames = max(24, min(60, int(duration * fps)))  # 1-2.5 seconds of animation
 
         if chart_type == "pie":
-            wedges, _ = ax.pie(plot_df, labels=plot_df.index, startangle=90)
-            ax.set_title(title)
-            for w in wedges: w.set_alpha(0)      # start invisible
-            def update(i):
-                alpha = i / frames
-                for w in wedges: w.set_alpha(alpha)
+            # Start with all wedges at 0 size, grow to full size
+            def update(frame):
+                ax.clear()
+                ax.set_facecolor('white')
+                progress = frame / (frames - 1) if frames > 1 else 1.0
+                sizes = plot_df.values * progress
+                if progress > 0:
+                    wedges, texts = ax.pie(sizes, labels=plot_df.index, startangle=90, autopct='%1.1f%%')
+                ax.set_title(title, fontsize=16, pad=20)
+                return ax.patches
 
         elif chart_type == "bar":
-            bars = ax.bar(plot_df.index, np.zeros_like(plot_df.values), color="#1f77b4")
-            ax.set_ylim(0, plot_df.max()*1.1); ax.set_title(title)
-            def update(i):
-                frac = i / frames
-                for b, h in zip(bars, plot_df.values):
-                    b.set_height(h * frac)
+            # Bars grow from 0 to full height
+            final_heights = plot_df.values if hasattr(plot_df, 'values') else plot_df
+            x_pos = np.arange(len(final_heights))
+            def update(frame):
+                ax.clear()
+                ax.set_facecolor('white')
+                progress = frame / (frames - 1) if frames > 1 else 1.0
+                heights = final_heights * progress
+                bars = ax.bar(x_pos, heights, color="#1f77b4", alpha=0.8)
+                ax.set_ylim(0, max(final_heights) * 1.1)
+                ax.set_title(title, fontsize=16, pad=20)
+                ax.set_xticks(x_pos)
+                ax.set_xticklabels(plot_df.index if hasattr(plot_df, 'index') else range(len(final_heights)), rotation=45)
+                ax.grid(True, alpha=0.3)
+                return bars
 
         elif chart_type == "hist":
-            n, bins, patches = ax.hist(plot_df, bins=20, color="#1f77b4", alpha=0)
-            ax.set_title(title)
-            def update(i):
-                alpha = i / frames
-                for p in patches: p.set_alpha(alpha)
+            # Histogram bars fade in
+            def update(frame):
+                ax.clear()
+                ax.set_facecolor('white')
+                progress = frame / (frames - 1) if frames > 1 else 1.0
+                n, bins, patches = ax.hist(plot_df, bins=min(20, len(plot_df)//5), color="#1f77b4", alpha=progress*0.8)
+                ax.set_title(title, fontsize=16, pad=20)
+                ax.grid(True, alpha=0.3)
+                return patches
 
         elif chart_type == "scatter":
-            pts = ax.scatter(plot_df.iloc[:,0], plot_df.iloc[:,1], s=10, alpha=0)
-            ax.set_title(title); ax.grid(alpha=0.3)
-            def update(i): pts.set_alpha(i / frames)
+            # Points appear progressively
+            x_data = plot_df.iloc[:, 0]
+            y_data = plot_df.iloc[:, 1] if plot_df.shape[1] > 1 else plot_df.iloc[:, 0]
+            def update(frame):
+                ax.clear()
+                ax.set_facecolor('white')
+                progress = frame / (frames - 1) if frames > 1 else 1.0
+                n_points = max(1, int(len(x_data) * progress))
+                ax.scatter(x_data[:n_points], y_data[:n_points], s=50, alpha=0.7, color="#1f77b4")
+                ax.set_xlim(x_data.min() * 0.9, x_data.max() * 1.1)
+                ax.set_ylim(y_data.min() * 0.9, y_data.max() * 1.1)
+                ax.set_title(title, fontsize=16, pad=20)
+                ax.grid(True, alpha=0.3)
+                return ax.collections
 
         else:  # line
-            line, = ax.plot([], [], lw=2)
-            x_full = plot_df.iloc[:,0] if chart_type == "line" and plot_df.shape[1] > 1 else np.arange(len(plot_df))
-            y_full = plot_df.iloc[:,1] if plot_df.shape[1] > 1 else plot_df.iloc[:,0]
-            ax.set_xlim(x_full.min(), x_full.max()); ax.set_ylim(y_full.min(), y_full.max())
-            ax.set_title(title); ax.grid(alpha=0.3)
-            def update(i):
-                k = max(2, int(len(x_full) * i / frames))
-                line.set_data(x_full[:k], y_full.iloc[:k])
-                return line,
-
-        anim = FuncAnimation(fig, update, frames=frames, blit=False)
-        anim.save(str(out_path),
-                  writer=FFMpegWriter(fps=fps, metadata={'artist':'Sozo'}), dpi=144)
+            # Line draws progressively
+            x_data = plot_df.iloc[:, 0] if plot_df.shape[1] > 1 else np.arange(len(plot_df))
+            y_data = plot_df.iloc[:, 1] if plot_df.shape[1] > 1 else plot_df.iloc[:, 0]
+            def update(frame):
+                ax.clear()
+                ax.set_facecolor('white')
+                progress = frame / (frames - 1) if frames > 1 else 1.0
+                n_points = max(2, int(len(x_data) * progress))
+                ax.plot(x_data[:n_points], y_data[:n_points], lw=3, color="#1f77b4", marker='o', markersize=4)
+                ax.set_xlim(x_data.min(), x_data.max())
+                ax.set_ylim(y_data.min() * 0.9, y_data.max() * 1.1)
+                ax.set_title(title, fontsize=16, pad=20)
+                ax.grid(True, alpha=0.3)
+                return ax.lines
+
+        # Create animation
+        plt.tight_layout()
+        anim = FuncAnimation(fig, update, frames=frames, interval=1000/fps, blit=False, repeat=False)
+        
+        # Save with proper writer
+        writer = FFMpegWriter(fps=fps, metadata={'artist': 'Sozo'}, bitrate=1800)
+        anim.save(str(out_path), writer=writer, dpi=100)
+        
         plt.close(fig)
         return str(out_path)
 
     except Exception as e:
-        # graceful fallback: fade-in static auto-plot
-        with plt.ioff():
-            df.plot(ax=plt.gca())
+        # Graceful fallback: create a static chart and animate it with fade-in
+        try:
+            plt.figure(figsize=(WIDTH / 100, HEIGHT / 100), dpi=100)
+            plt.style.use('default')
+            
+            # Create a simple plot based on data
+            if not df.empty:
+                numeric_cols = df.select_dtypes(include='number').columns
+                if len(numeric_cols) > 0:
+                    if len(numeric_cols) == 1:
+                        df[numeric_cols[0]].plot(kind='line', title=title or "Data Overview")
+                    else:
+                        df[numeric_cols[:2]].plot(kind='line', title=title or "Data Overview")
+                else:
+                    # If no numeric columns, show value counts of first column
+                    df.iloc[:, 0].value_counts().head(10).plot(kind='bar', title=title or "Data Overview")
+            
+            plt.tight_layout()
             tmp_png = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.png"
-            plt.savefig(tmp_png, bbox_inches="tight"); plt.close()
-        img = cv2.resize(cv2.imread(str(tmp_png)), (WIDTH, HEIGHT))
-        return animate_image_fade(img, duration, out_path, fps)
+            plt.savefig(tmp_png, bbox_inches="tight", facecolor='white', dpi=100)
+            plt.close()
+            
+            # Convert to video with fade-in
+            img = cv2.imread(str(tmp_png))
+            if img is None:
+                raise RuntimeError("Failed to load generated chart image")
+            img = cv2.resize(img, (WIDTH, HEIGHT))
+            result = animate_image_fade(img, duration, out_path, fps)
+            tmp_png.unlink(missing_ok=True)
+            return result
+            
+        except Exception as fallback_error:
+            # Ultimate fallback: create placeholder
+            plt.close('all')
+            placeholder_img = np.full((HEIGHT, WIDTH, 3), 200, dtype=np.uint8)
+            # Add text to placeholder
+            cv2.putText(placeholder_img, "Chart Placeholder", (WIDTH//2-100, HEIGHT//2), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 1, (100, 100, 100), 2)
+            return animate_image_fade(placeholder_img, duration, out_path, fps)
 
 def concat_media(inputs, output, kind="video"):
+    """Concatenate video or audio files."""
+    if not inputs:
+        raise ValueError("No input files provided")
+    
     lst = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.txt"
-    with lst.open("w") as f:
-        for p in inputs:
-            f.write(f"file '{Path(p).resolve()}'\n")
-    subprocess.run(
-        ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", str(lst),
-         "-c:v" if kind == "video" else "-c:a", "copy", str(output)],
-        check=True, capture_output=True
-    )
-    lst.unlink(missing_ok=True)
+    try:
+        with lst.open("w") as f:
+            for p in inputs:
+                if not Path(p).exists():
+                    raise FileNotFoundError(f"Input file not found: {p}")
+                f.write(f"file '{Path(p).resolve()}'\n")
+        
+        cmd = ["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", str(lst)]
+        if kind == "video":
+            cmd.extend(["-c:v", "libx264", "-c:a", "aac"])
+        else:
+            cmd.extend(["-c:a", "copy"])
+        cmd.append(str(output))
+        
+        subprocess.run(cmd, check=True, capture_output=True)
+    finally:
+        lst.unlink(missing_ok=True)
 
 # ─────────────────────────────────────────────────────────────────────────────
-# IMAGE GENERATION (keeps original Client.generate_content call)
+# IMAGE GENERATION (FIXED - using correct API pattern)
 # ─────────────────────────────────────────────────────────────────────────────
 def generate_image_from_prompt(prompt, style):
+    """Generate image using Gemini API with proper error handling."""
     try:
+        # Clean prompt text
+        clean_prompt = clean_narrator_text(prompt)
+        if not clean_prompt:
+            clean_prompt = "Professional business presentation slide"
+        
         full_prompt = (f"A professional, clean, illustrative image for a business presentation: "
-                       f"{prompt}, in the style of {style}.")
+                      f"{clean_prompt}, in the style of {style}. High quality, clear, business appropriate.")
+        
         response = GEM.generate_content(
-            contents=full_prompt,
-            model="gemini-2.0-flash-exp-image-generation",
-            generation_config={"response_mime_type": "image/png"},
+            contents=[full_prompt],
+            model="gemini-2.0-flash-exp",
+            generation_config={
+                "response_mime_type": "image/png",
+                "max_output_tokens": 4096,
+            },
         )
-        img_bytes = response.parts[0].blob.data
-        return Image.open(io.BytesIO(img_bytes)).convert("RGB")
+        
+        if response and response.candidates and len(response.candidates) > 0:
+            candidate = response.candidates[0]
+            if candidate.content and candidate.content.parts:
+                for part in candidate.content.parts:
+                    if hasattr(part, 'blob') and part.blob:
+                        img_bytes = part.blob.data
+                        return Image.open(io.BytesIO(img_bytes)).convert("RGB")
+        
+        # If we get here, the API call succeeded but didn't return image data
+        st.warning("Image generation succeeded but no image data returned. Using placeholder.")
+        return create_placeholder_image()
+        
     except Exception as e:
-        st.warning(f"Illustrative image generation failed: {e}. Using placeholder.")
-        return Image.new("RGB", (WIDTH, HEIGHT), color=(230, 230, 230))
+        st.warning(f"Image generation failed: {str(e)[:100]}... Using placeholder.")
+        return create_placeholder_image()
 
+def create_placeholder_image():
+    """Create a professional-looking placeholder image."""
+    img = Image.new("RGB", (WIDTH, HEIGHT), color=(240, 240, 245))
+    # This would require PIL's ImageDraw, but keeping it simple
+    return img
 
 # ─────────────────────────────────────────────────────────────────────────────
 # REPORT GENERATION (unchanged models – prompt now local)
@@ -314,9 +461,8 @@ def generate_report_assets(key, buf, name, ctx):
         "key": key,
     }
 
-
 # ─────────────────────────────────────────────────────────────────────────────
-# VIDEO GENERATION (animated charts – prompt now local)
+# VIDEO GENERATION (animated charts – improved error handling)
 # ─────────────────────────────────────────────────────────────────────────────
 def generate_video_assets(key, buf, name, ctx, style, animate_charts=True):
     try:
@@ -343,10 +489,11 @@ def generate_video_assets(key, buf, name, ctx, style, animate_charts=True):
     story_prompt = (
         f"Create a script for a short business video with exactly {VIDEO_SCENES} scenes.\n"
         "For each scene:\n"
-        "1. Provide 1–2 sentences of narration.\n"
+        "1. Provide 1–2 sentences of narration that flows naturally when spoken.\n"
         '2. If a visual is helpful, add <generate_chart: "bar | monthly revenue"> '
         "(chart_type first).\n"
         "3. Separate scenes with [SCENE_BREAK].\n"
+        "Focus on clear, concise narration suitable for voice synthesis.\n"
         f"Data Context: {json.dumps(ctx_dict, indent=2)}"
     )
 
@@ -354,71 +501,109 @@ def generate_video_assets(key, buf, name, ctx, style, animate_charts=True):
     scenes = [s.strip() for s in script.split("[SCENE_BREAK]") if s.strip()]
 
     video_parts, audio_parts, temps = [], [], []
+    total_duration = 0
 
     for idx, scene in enumerate(scenes[:VIDEO_SCENES]):
         st.progress((idx + 1) / VIDEO_SCENES, text=f"Processing Scene {idx+1}/{VIDEO_SCENES}…")
 
         chart_tags = extract_chart_tags(scene)
-        narrative = repl_tags(scene, {}, lambda _: "").strip()
+        # Clean narrative text for TTS
+        narrative = clean_narrator_text(scene)
+        
+        if not narrative:
+            narrative = f"Scene {idx + 1} presents key business insights from our data analysis."
 
         # ---------------- audio -------------------------------------------
         audio_bytes, _ = deepgram_tts(narrative)
         audio_path = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp3"
+        
         if audio_bytes:
             audio_path.write_bytes(audio_bytes)
-        duration = get_audio_duration(str(audio_path)) if audio_bytes else 5.0
+            duration = get_audio_duration(str(audio_path))
+        else:
+            # Create silent audio as fallback
+            duration = 5.0
+            # Create a short silent audio file
+            silent_audio = np.zeros(int(duration * 22050), dtype=np.int16)
+            with wave.open(str(audio_path), 'w') as wav_file:
+                wav_file.setnchannels(1)
+                wav_file.setsampwidth(2)
+                wav_file.setframerate(22050)
+                wav_file.writeframes(silent_audio.tobytes())
+        
         audio_parts.append(str(audio_path))
         temps.append(audio_path)
+        total_duration += duration
 
         # ---------------- visual ------------------------------------------
-        if chart_tags and animate_charts:
-            clip_path = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp4"
-            animate_chart(chart_tags[0], df, duration, clip_path, FPS)
+        clip_path = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp4"
+        
+        try:
+            if chart_tags and animate_charts:
+                animate_chart(chart_tags[0], df, duration, clip_path, FPS)
+            else:
+                # Generate image and animate it
+                img = generate_image_from_prompt(narrative, style)
+                img_resized = img.resize((WIDTH, HEIGHT))
+                img_cv2 = cv2.cvtColor(np.array(img_resized), cv2.COLOR_RGB2BGR)
+                animate_image_fade(img_cv2, duration, clip_path, FPS)
+            
             video_parts.append(str(clip_path))
             temps.append(clip_path)
-        else:
-            img = generate_image_from_prompt(narrative, style)
-            png_tmp = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.png"
-            img.save(png_tmp)
-            temps.append(png_tmp)
-            clip_path = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp4"
-            animate_image_fade(
-                cv2.cvtColor(np.array(img.resize((WIDTH, HEIGHT))), cv2.COLOR_RGB2BGR),
-                duration,
-                clip_path,
-                FPS,
-            )
+            
+        except Exception as e:
+            st.warning(f"Scene {idx+1} visual generation failed: {str(e)[:50]}... Using placeholder.")
+            # Create placeholder video
+            placeholder_img = np.full((HEIGHT, WIDTH, 3), 200, dtype=np.uint8)
+            cv2.putText(placeholder_img, f"Scene {idx+1}", (WIDTH//2-50, HEIGHT//2), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 1, (100, 100, 100), 2)
+            animate_image_fade(placeholder_img, duration, clip_path, FPS)
             video_parts.append(str(clip_path))
             temps.append(clip_path)
 
     # -------------- concatenate ----------------------------------------------
-    silent_vid = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp4"
-    concat_media(video_parts, silent_vid, "video")
-    audio_mix = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp3"
-    concat_media(audio_parts, audio_mix, "audio")
-
-    final_vid = Path(tempfile.gettempdir()) / f"{key}.mp4"
-    subprocess.run(
-        [
-            "ffmpeg",
-            "-y",
-            "-i",
-            str(silent_vid),
-            "-i",
-            str(audio_mix),
-            "-c:v",
-            "copy",
-            "-c:a",
-            "aac",
+    try:
+        if not video_parts or not audio_parts:
+            st.error("No video or audio parts generated.")
+            return None
+            
+        silent_vid = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp4"
+        concat_media(video_parts, silent_vid, "video")
+        
+        audio_mix = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp3"
+        concat_media(audio_parts, audio_mix, "audio")
+
+        final_vid = Path(tempfile.gettempdir()) / f"{key}.mp4"
+        
+        # Combine video and audio
+        subprocess.run([
+            "ffmpeg", "-y",
+            "-i", str(silent_vid),
+            "-i", str(audio_mix),
+            "-c:v", "libx264",
+            "-c:a", "aac",
             "-shortest",
+            "-b:v", "1000k",
+            "-b:a", "128k",
             str(final_vid),
-        ],
-        check=True,
-        capture_output=True,
-    )
+        ], check=True, capture_output=True)
+
+        # Clean up temp files
+        for temp_file in temps:
+            Path(temp_file).unlink(missing_ok=True)
+        silent_vid.unlink(missing_ok=True)
+        audio_mix.unlink(missing_ok=True)
 
-    return {"type": "video", "video_path": str(final_vid), "key": key}
+        return {"type": "video", "video_path": str(final_vid), "key": key}
+        
+    except Exception as e:
+        st.error(f"Video generation failed during final assembly: {str(e)}")
+        # Still try to return something if possible
+        if video_parts:
+            return {"type": "video", "video_path": str(video_parts[0]), "key": key}
+        return None
 
+# ─────────────────────────────────────────────────────────────────────────────
 # ─────────────────────────────────────────────────────────────────────────────
 # UI
 # ─────────────────────────────────────────────────────────────────────────────