Update app.py

app.py

@@ -1,11 +1,22 @@
-###############################################################################
-#  Sozo Business Studio · AI transforms business data into compelling narratives
-#  (video branch now supports animated charts – PDF branch untouched)
-###############################################################################
+##############################################################################
+# Sozo Business Studio · AI transforms business data into compelling stories #
+#             (video branch-with-animation • PDF branch untouched)           #
+##############################################################################
+# DROP-IN REPLACEMENT — 07-Jul-2025
+#
+# ▸ Fixes
+#   1. Correct Gemini image-generation call (fallback placeholder kept)
+#   2. Narration text now strips scene labels & chart tags
+#   3. Animation initialises from blank frame and returns artists for blit
+#   4. Robust graceful-failure path keeps video & audio lengths aligned
+#
+# ────────────────────────────────────────────────────────────────────────────
+
 import os, re, json, hashlib, uuid, base64, io, tempfile, wave, requests, subprocess
 from pathlib import Path
+from typing import Tuple, Dict, List
 
-# ─── Third-party ──────────────────────────────────────────────────────────────
+# ─── Third-party ────────────────────────────────────────────────────────────
 import streamlit as st
 import pandas as pd
 import numpy as np
@@ -16,9 +27,10 @@ from matplotlib.animation import FuncAnimation, FFMpegWriter
 from fpdf import FPDF, HTMLMixin
 from markdown_it import MarkdownIt
 from PIL import Image
-import cv2  # video processing
+import cv2
 
-try:                                         # optional helper for bar-race
+try:
+    # optional helper for bar-race
     import bar_chart_race as bcr
     HAS_BCR = True
 except ImportError:
@@ -26,35 +38,39 @@ except ImportError:
 
 from langchain_experimental.agents import create_pandas_dataframe_agent
 from langchain_google_genai import ChatGoogleGenerativeAI
-from google import genai                              # ← original import path
+from google import genai
+from google.genai import types  # needed only for image generation call
 
-# ─────────────────────────────────────────────────────────────────────────────
+# ────────────────────────────────────────────────────────────────────────────
 # CONFIG & CONSTANTS
-# ─────────────────────────────────────────────────────────────────────────────
+# ────────────────────────────────────────────────────────────────────────────
 st.set_page_config(page_title="Sozo Business Studio", layout="wide")
 st.title("📊 Sozo Business Studio")
 st.caption("AI transforms business data into compelling narratives.")
 
-FPS, WIDTH, HEIGHT = 24, 1280, 720        # video parameters
+FPS, WIDTH, HEIGHT  = 24, 1280, 720               # video parameters
 MAX_CHARTS, VIDEO_SCENES = 5, 5
 
 API_KEY = os.getenv("GEMINI_API_KEY")
 if not API_KEY:
     st.error("⚠️ GEMINI_API_KEY is not set."); st.stop()
-GEM = genai.Client(api_key=API_KEY)       # ← still using Client pattern
 
-DG_KEY = os.getenv("DEEPGRAM_API_KEY")    # optional (narration)
+GEM  = genai.Client(api_key=API_KEY)               # keep original client usage
+
+DG_KEY = os.getenv("DEEPGRAM_API_KEY")             # optional (narration)
 
 st.session_state.setdefault("bundle", None)
+
 sha1_bytes = lambda b: hashlib.sha1(b).hexdigest()
 
-# ─────────────────────────────────────────────────────────────────────────────
+# ────────────────────────────────────────────────────────────────────────────
 # BASIC HELPERS
-# ───────────────────────────────────────────────────────��─────────────────────
-def load_dataframe_safely(buf: bytes, name: str):
+# ────────────────────────────────────────────────────────────────────────────
+def load_dataframe_safely(buf: bytes, name: str) -> Tuple[pd.DataFrame, str]:
+    """Attempt CSV/Excel load - return (df, err) tuple."""
     try:
         ext = Path(name).suffix.lower()
-        df  = pd.read_excel(io.BytesIO(buf)) if ext in (".xlsx", ".xls") else pd.read_csv(io.BytesIO(buf))
+        df = pd.read_excel(io.BytesIO(buf)) if ext in (".xlsx", ".xls") else pd.read_csv(io.BytesIO(buf))
         df.columns = df.columns.astype(str).str.strip()
         df = df.dropna(how="all")
         if df.empty or len(df.columns) == 0:
@@ -63,18 +79,22 @@ def load_dataframe_safely(buf: bytes, name: str):
     except Exception as e:
         return None, str(e)
 
-def arrow_df(df: pd.DataFrame):
+
+def arrow_df(df: pd.DataFrame) -> pd.DataFrame:
+    """Return a Streamlit-friendly df with nullable dtypes for Arrow."""
     safe = df.copy()
     for c in safe.columns:
         if safe[c].dtype.name in ("Int64", "Float64", "Boolean"):
             safe[c] = safe[c].astype(safe[c].dtype.name.lower())
     return safe
 
+
 @st.cache_data(show_spinner=False)
-def deepgram_tts(text: str):
+def deepgram_tts(text: str) -> Tuple[bytes, str]:
+    """Call Deepgram TTS, return (audio_bytes, mime) or (None, None)."""
     if not DG_KEY or not text:
         return None, None
-    text = re.sub(r"[^\w\s.,!?;:-]", "", text)[:1000]
+    text = re.sub(r"[^\w\s.,!?;:-]", "", text)[:1000]          # Deepgram max tokens
     try:
         r = requests.post(
             "https://api.deepgram.com/v1/speak",
@@ -88,7 +108,18 @@ def deepgram_tts(text: str):
     except Exception:
         return None, None
 
+
+def generate_silence(duration: float, out_path: Path) -> None:
+    """Generate a silent MP3 of exact duration using ffmpeg."""
+    subprocess.run(
+        ["ffmpeg", "-y", "-f", "lavfi", "-i", "anullsrc=r=44100:cl=mono",
+         "-t", f"{duration:.3f}", "-q:a", "9", str(out_path)],
+        check=True, capture_output=True
+    )
+
+
 def get_audio_duration(mp3_path: str) -> float:
+    """Return duration seconds via ffprobe; fallback 5.0."""
     try:
         out = subprocess.run(
             ["ffprobe", "-v", "error", "-show_entries", "format=duration",
@@ -99,29 +130,22 @@ 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
+
+def repl_tags(txt: str, mp: Dict[str, str], fn):
+    """Replace chart tags using map + fn()."""
     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)
-# ─────────────────────────────────────────────────────────────────────────────
-class PDF(FPDF, HTMLMixin): pass
-def build_pdf(md, charts):
+# ────────────────────────────────────────────────────────────────────────────
+class PDF(FPDF, HTMLMixin):
+    pass
+
+def build_pdf(md: str, charts: Dict[str, str]) -> bytes:
     html = MarkdownIt("commonmark", {"breaks": True}).enable("table").render(
         repl_tags(md.replace("•", "*"), charts, lambda p: f'<img src="{p}">')
     )
@@ -131,284 +155,228 @@ def build_pdf(md, charts):
     pdf.set_font("Arial", "", 11); pdf.write_html(html)
     return bytes(pdf.output(dest="S"))
 
-# ─────────────────────────────────────────────────────────────────────────────
+
+# ────────────────────────────────────────────────────────────────────────────
+# IMAGE GENERATION
+# ────────────────────────────────────────────────────────────────────────────
+def generate_image_from_prompt(prompt: str, style: str) -> Image.Image:
+    """
+    Use Gemini native image generation; fallback to placeholder.
+    Keeps default model name but gracefully tries preview model if needed.
+    """
+    model_name = "gemini-2.0-flash-exp-image-generation"   # ✳ keep original
+    full_prompt = (
+        "A professional, clean, illustrative image for a business presentation: "
+        f"{prompt}, in the style of {style}."
+    )
+
+    def _decode(parts):
+        for part in parts:
+            if getattr(part, "inline_data", None) is not None:
+                return Image.open(io.BytesIO(part.inline_data.data)).convert("RGB")
+        return None
+
+    try:
+        response = GEM.models.generate_content(
+            model=model_name,
+            contents=full_prompt,
+            config=types.GenerateContentConfig(response_modalities=["IMAGE"]),
+        )
+        img = _decode(response.candidates[0].content.parts)
+        if img:
+            return img
+    except Exception as e:
+        # try preview SKU once
+        try:
+            response = GEM.models.generate_content(
+                model="gemini-2.0-flash-preview-image-generation",
+                contents=full_prompt,
+                config=types.GenerateContentConfig(response_modalities=["IMAGE"]),
+            )
+            img = _decode(response.candidates[0].content.parts)
+            if img:
+                return img
+        except Exception:
+            st.warning(f"Illustrative image generation failed: {e}. Using placeholder.")
+
+    return Image.new("RGB", (WIDTH, HEIGHT), color=(230, 230, 230))
+
+
+# ────────────────────────────────────────────────────────────────────────────
+# NARRATION CLEAN-UP
+# ────────────────────────────────────────────────────────────────────────────
+re_scene = re.compile(r"^\s*scene\s*\d+[:.\- ]*", re.I)
+
+def clean_narration(text: str) -> str:
+    """Strip scene labels, chart tags, and excess whitespace."""
+    text = re_scene.sub("", text)
+    text = TAG_RE.sub("", text)
+    text = re.sub(r"\s{2,}", " ", text).strip()
+    return text
+
+
+# ────────────────────────────────────────────────────────────────────────────
 # 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
-    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)
+    frames = max(int(duration * fps), fps)                    # at least 1 s
+    video  = cv2.VideoWriter(str(out_path), cv2.VideoWriter_fourcc(*"mp4v"), fps, (WIDTH, HEIGHT))
+    blank  = np.full_like(img_cv2, 255)
     for i in range(frames):
-        alpha = i / (frames - 1) if frames > 1 else 1.0
+        alpha = i / frames
         frame = cv2.addWeighted(blank, 1 - alpha, img_cv2, alpha, 0)
         video.write(frame)
-    
     video.release()
     return str(out_path)
 
-def animate_chart(desc: str, df: pd.DataFrame, duration: float,
-                  out_path: Path, fps: int = FPS) -> str:
+
+def animate_chart(desc: str, df: pd.DataFrame, duration: float, out_path: Path, fps: int = FPS) -> str:
     """
-    desc  ->  'chart_type | explanation'
-    Valid chart_type: line, bar, scatter, pie, hist
-    Builds an accurate static figure, then animates a smooth reveal.
+    Build static figure then animate reveal (≤30 frames). Returns MP4 path.
+    Guaranteed to succeed; will raise to caller if fatal.
     """
-    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
-
-        # === Prepare aggregated data =================================================
-        if chart_type == "pie":
-            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_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
-            if len(nums) == 0:
-                raise ValueError("Need numeric columns for line/scatter chart")
-            plot_df = df[list(nums[:2])].dropna()
-
-        # === Build animated figure ===================================================
-        fig, ax = plt.subplots(figsize=(WIDTH / 100, HEIGHT / 100), dpi=100)
-        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":
-            # 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 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":
-            # 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":
-            # 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 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)
+    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
+
+    # === Prepare aggregated data ============================================
+    if chart_type == "pie":
+        cat = df.select_dtypes(exclude="number").columns[0]
+        num = df.select_dtypes(include="number").columns[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]
+    else:  # line / scatter
+        nums    = df.select_dtypes(include="number").columns[:2]
+        plot_df = df[list(nums)].sort_index()
+
+    # === Build figure =======================================================
+    fig, ax = plt.subplots(figsize=(WIDTH / 100, HEIGHT / 100), dpi=100)
+    frames  = max(10, min(30, int(duration * fps)))
+    artists = []
+
+    if chart_type == "pie":
+        wedges, _ = ax.pie(plot_df, labels=plot_df.index, startangle=90)
+        ax.set_title(title)
+
+        def init():
+            for w in wedges:
+                w.set_alpha(0)
+            return wedges
+
+        def update(i):
+            alpha = i / frames
+            for w in wedges:
+                w.set_alpha(alpha)
+            return wedges
+
+    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 init():
+            return bars
+
+        def update(i):
+            frac = i / frames
+            for b, h in zip(bars, plot_df.values):
+                b.set_height(h * frac)
+            return bars
+
+    elif chart_type == "hist":
+        n, bins, patches = ax.hist(plot_df, bins=20, color="#1f77b4", alpha=0)
+        ax.set_title(title)
+
+        def init():
+            for p in patches: p.set_alpha(0)
+            return patches
+
+        def update(i):
+            alpha = i / frames
+            for p in patches: p.set_alpha(alpha)
+            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 init():
+            pts.set_alpha(0); return [pts]
+
+        def update(i):
+            pts.set_alpha(i / frames)
+            return [pts]
+
+    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 init():
+            line.set_data([], [])
+            return [line]
+
+        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, init_func=init,
+        blit=True, interval=1000 / fps
+    )
+    anim.save(str(out_path), writer=FFMpegWriter(fps=fps, metadata={'artist': 'Sozo'}), dpi=144)
+    plt.close(fig)
+    return str(out_path)
 
-    except Exception as e:
-        # 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()
+
+def safe_animate_chart(desc: str, df: pd.DataFrame, duration: float, out_path: Path, fps: int = FPS) -> str:
+    """Wrapper that falls back to static-fade if chart animation fails."""
+    try:
+        return animate_chart(desc, df, duration, out_path, fps)
+    except Exception:
+        with plt.ioff():
+            df.plot(ax=plt.gca())
             tmp_png = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.png"
-            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."""
+            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)
+
+
+def concat_media(inputs: List[str], output: Path, kind: str = "video") -> None:
+    """FFmpeg safe concat for audio or video."""
     if not inputs:
-        raise ValueError("No input files provided")
-    
+        return
     lst = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.txt"
-    try:
-        with lst.open("w") as f:
-            for p in inputs:
-                if not Path(p).exists():
-                    raise FileNotFoundError(f"Input file not found: {p}")
+    with lst.open("w") as f:
+        for p in inputs:
+            if Path(p).exists():
                 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 (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"{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",
-            generation_config={
-                "response_mime_type": "image/png",
-                "max_output_tokens": 4096,
-            },
-        )
-        
-        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"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)
-# ─────────────────────────────────────────────────────────────────────────────
+    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)
+
+
+# ────────────────────────────────────────────────────────────────────────────
+# REPORT GENERATION (unchanged model names)
+# ────────────────────────────────────────────────────────────────────────────
 def generate_report_assets(key, buf, name, ctx):
     df, err = load_dataframe_safely(buf, name)
     if err:
-        st.error(err)
-        return None
+        st.error(err); return None
 
     llm = ChatGoogleGenerativeAI(
         model="gemini-2.0-flash", google_api_key=API_KEY, temperature=0.1
     )
 
-    # build context dict **after** df exists
     ctx_dict = {
-        "shape": df.shape,
+        "shape":   df.shape,
         "columns": list(df.columns),
         "user_ctx": ctx or "General business analysis",
     }
@@ -424,9 +392,10 @@ def generate_report_assets(key, buf, name, ctx):
 
     md = llm.invoke(report_prompt).content
 
-    # ------------------------------------------------------------------ charts
+    # ---------------------------------------------------------------- charts
     chart_descs = extract_chart_tags(md)[:MAX_CHARTS]
-    charts = {}
+    charts: Dict[str, str] = {}
+
     if chart_descs:
         agent = create_pandas_dataframe_agent(
             llm=llm, df=df, verbose=False, allow_dangerous_code=True
@@ -446,10 +415,8 @@ def generate_report_assets(key, buf, name, ctx):
                         plt.close("all")
 
     preview = repl_tags(
-        md,
-        charts,
-        lambda p: f'<img src="data:image/png;base64,'
-        f'{base64.b64encode(Path(p).read_bytes()).decode()}">'
+        md, charts,
+        lambda p: f'<img src="data:image/png;base64,{base64.b64encode(Path(p).read_bytes()).decode()}">'
     )
     pdf = build_pdf(md, charts)
 
@@ -461,10 +428,11 @@ def generate_report_assets(key, buf, name, ctx):
         "key": key,
     }
 
-# ─────────────────────────────────────────────────────────────────────────────
-# VIDEO GENERATION (animated charts – improved error handling)
-# ─────────────────────────────────────────────────────────────────────────────
-def generate_video_assets(key, buf, name, ctx, style, animate_charts=True):
+
+# ────────────────────────────────────────────────────────────────────────────
+# VIDEO GENERATION (animated charts)
+# ────────────────────────────────────────────────────────────────────────────
+def generate_video_assets(key, buf, name, ctx, style, animate_charts: bool = True):
     try:
         subprocess.run(["ffmpeg", "-version"], check=True, capture_output=True)
     except Exception:
@@ -473,15 +441,14 @@ def generate_video_assets(key, buf, name, ctx, style, animate_charts=True):
 
     df, err = load_dataframe_safely(buf, name)
     if err:
-        st.error(err)
-        return None
+        st.error(err); return None
 
     llm = ChatGoogleGenerativeAI(
         model="gemini-2.0-flash", google_api_key=API_KEY, temperature=0.2
     )
 
     ctx_dict = {
-        "shape": df.shape,
+        "shape":   df.shape,
         "columns": list(df.columns),
         "user_ctx": ctx or "General business analysis",
     }
@@ -489,139 +456,91 @@ 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 that flows naturally when spoken.\n"
-        '2. If a visual is helpful, add <generate_chart: "bar | monthly revenue"> '
-        "(chart_type first).\n"
+        "1. Provide 1–2 sentences of narration.\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)}"
     )
 
-    script = llm.invoke(story_prompt).content
-    scenes = [s.strip() for s in script.split("[SCENE_BREAK]") if s.strip()]
-
-    video_parts, audio_parts, temps = [], [], []
-    total_duration = 0
+    script  = llm.invoke(story_prompt).content
+    scenes  = [s.strip() for s in script.split("[SCENE_BREAK]") if s.strip()]
+    video_parts: List[str] = []
+    audio_parts: List[str] = []
+    temps: List[Path]      = []
 
     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)
-        # 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."
+        narrative  = clean_narration(repl_tags(scene, {}, lambda _: "")).strip()
 
-        # ---------------- audio -------------------------------------------
+        # ─────────────── audio ────────────────────────────
         audio_bytes, _ = deepgram_tts(narrative)
-        audio_path = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp3"
-        
+        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))
         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 ------------------------------------------
+            generate_silence(duration, audio_path)
+
+        audio_parts.append(str(audio_path)); temps.append(audio_path)
+
+        # ─────────────── visual ───────────────────────────
         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)
-            
-        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 ----------------------------------------------
-    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)
-
-        # 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}
-        
-    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
+        if chart_tags and animate_charts:
+            safe_animate_chart(chart_tags[0], df, duration, clip_path, FPS)
+        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)
+            animate_image_fade(
+                cv2.cvtColor(np.array(img.resize((WIDTH, HEIGHT))), cv2.COLOR_RGB2BGR),
+                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", "-shortest", str(final_vid)],
+        check=True, capture_output=True,
+    )
+
+    # cleanup tmp
+    for p in temps:
+        p.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}
+
 
-# ─────────────────────────────────────────────────────────────────────────────
-# ─────────────────────────────────────────────────────────────────────────────
+# ────────────────────────────────────────────────────────────────────────────
 # UI
-# ─────────────────────────────────────────────────────────────────────────────
+# ────────────────────────────────────────────────────────────────────────────
 mode = st.radio("Select Output Format:", ["Report (PDF)", "Video Narrative"], horizontal=True)
-
 video_style, animate_charts_flag = "professional illustration", True
+
 if mode == "Video Narrative":
     with st.sidebar:
         st.subheader("🎬 Video Options")
         video_style = st.selectbox(
             "Visual Style",
-            ["professional illustration", "minimalist infographic",
-             "photorealistic", "cinematic", "data visualization aesthetic"]
+            ["professional illustration", "minimalist infographic", "photorealistic",
+             "cinematic", "data visualization aesthetic"]
         )
         animate_charts_flag = st.toggle("Animate Charts", value=True)
         st.caption("Disable to use static slides with a simple fade-in.")
 
 upl = st.file_uploader("Upload CSV or Excel", type=["csv", "xlsx", "xls"])
+
 if upl:
     df_sample, _ = load_dataframe_safely(upl.getvalue(), upl.name)
     with st.expander("📊 Data Preview"):
@@ -632,39 +551,44 @@ ctx = st.text_area("Business context or specific instructions (optional)")
 if st.button("🚀 Generate", type="primary"):
     if not upl:
         st.warning("Please upload a file first."); st.stop()
+
     bkey = sha1_bytes(b"".join([
         upl.getvalue(), mode.encode(), ctx.encode(),
         video_style.encode(), str(animate_charts_flag).encode()
     ]))
+
     if mode == "Report (PDF)":
         with st.spinner("Generating report…"):
             st.session_state.bundle = generate_report_assets(bkey, upl.getvalue(), upl.name, ctx)
     else:
         st.session_state.bundle = generate_video_assets(
-            bkey, upl.getvalue(), upl.name, ctx,
-            video_style, animate_charts_flag
+            bkey, upl.getvalue(), upl.name, ctx, video_style, animate_charts_flag
         )
     st.rerun()
 
-# ─────────────────────────────────────────────────────────────────────────────
+# ────────────────────────────────────────────────────────────────────────────
 # OUTPUT
-# ─────────────────────────────────────────────────────────────────────────────
+# ────────────────────────────────────────────────────────────────────────────
 if st.session_state.get("bundle"):
     bundle = st.session_state.bundle
+
     if bundle.get("type") == "report":
         st.subheader("📄 Generated Report")
         with st.expander("View Report", expanded=True):
             st.markdown(bundle["preview"], unsafe_allow_html=True)
-            c1, c2 = st.columns(2)
-            with c1:
-                st.download_button("Download PDF", bundle["pdf"],
-                                   "business_report.pdf", "application/pdf",
-                                   use_container_width=True)
-            with c2:
-                if DG_KEY and st.button("🔊 Narrate Summary", use_container_width=True):
-                    txt = re.sub(r"<[^>]+>", "", bundle["report_md"])
-                    audio, mime = deepgram_tts(txt)
-                    st.audio(audio, format=mime) if audio else st.error("Narration failed.")
+
+        c1, c2 = st.columns(2)
+        with c1:
+            st.download_button(
+                "Download PDF", bundle["pdf"], "business_report.pdf",
+                "application/pdf", use_container_width=True
+            )
+        with c2:
+            if DG_KEY and st.button("🔊 Narrate Summary", use_container_width=True):
+                txt = re.sub(r"<[^>]+>", "", bundle["report_md"])
+                audio, mime = deepgram_tts(txt)
+                st.audio(audio, format=mime) if audio else st.error("Narration failed.")
+
     elif bundle.get("type") == "video":
         st.subheader("🎬 Generated Video Narrative")
         vp = bundle["video_path"]
@@ -672,7 +596,9 @@ if st.session_state.get("bundle"):
             with open(vp, "rb") as f:
                 st.video(f.read())
             with open(vp, "rb") as f:
-                st.download_button("Download Video", f,
-                                   f"sozo_narrative_{bundle['key'][:8]}.mp4", "video/mp4")
+                st.download_button(
+                    "Download Video", f,
+                    f"sozo_narrative_{bundle['key'][:8]}.mp4", "video/mp4"
+                )
         else:
             st.error("Video file missing – generation failed.")