Update streamlit_app.py

streamlit_app.py

@@ -1,53 +1,58 @@
 # streamlit_app.py
 import os
 import time
-import hashlib
+import json
+import string
 from glob import glob
 from pathlib import Path
-from tempfile import NamedTemporaryFile
+import hashlib
+from difflib import SequenceMatcher
 
-import ffmpeg
 import yt_dlp
+import ffmpeg
 import streamlit as st
 from dotenv import load_dotenv
 
 load_dotenv()
 
-# Require google.generativeai SDK
 try:
-    import google.generativeai as genai  # type: ignore
-except Exception as e:
-    st.error("Missing required dependency: google.generativeai. Install it and restart.")
-    raise
-
-# ensure SDK helpers exist
-upload_file = getattr(genai, "upload_file", None)
-get_file = getattr(genai, "get_file", None)
-delete_file = getattr(genai, "delete_file", None)
-if upload_file is None:
-    st.error("google.generativeai SDK installed but upload_file is not available in this version.")
-    raise RuntimeError("upload_file missing")
-
-st.set_page_config(page_title="Video → Story (GenAI)", layout="wide")
-DATA_DIR = Path("data")
-DATA_DIR.mkdir(exist_ok=True)
-
-# session defaults
-for k, v in {
-    "video_path": "",
-    "uploaded_file": None,
-    "processed_file": None,
-    "busy": False,
-    "file_hash": None,
-    "fast_mode": False,
-    "use_compression": True,
-}.items():
-    st.session_state.setdefault(k, v)
+    from phi.agent import Agent
+    from phi.model.google import Gemini
+    from phi.tools.duckduckgo import DuckDuckGo
+    HAS_PHI = True
+except Exception:
+    Agent = Gemini = DuckDuckGo = None
+    HAS_PHI = False
 
+try:
+    import google.generativeai as genai
+    from google.generativeai import upload_file, get_file  # type: ignore
+    HAS_GENAI = True
+except Exception:
+    genai = None
+    upload_file = get_file = None
+    HAS_GENAI = False
+
+st.set_page_config(page_title="Generate the story of videos", layout="wide")
+DATA_DIR = Path("./data")
+DATA_DIR.mkdir(exist_ok=True)
 
+# Session state defaults
+st.session_state.setdefault("videos", "")
+st.session_state.setdefault("loop_video", False)
+st.session_state.setdefault("uploaded_file", None)
+st.session_state.setdefault("processed_file", None)
+st.session_state.setdefault("busy", False)
+st.session_state.setdefault("last_loaded_path", "")
+st.session_state.setdefault("analysis_out", "")
+st.session_state.setdefault("last_error", "")
+st.session_state.setdefault("file_hash", None)
+st.session_state.setdefault("fast_mode", False)
+
+# Helpers
 def sanitize_filename(path_str: str):
-    return Path(path_str).name.lower().replace(" ", "_")
-
+    name = Path(path_str).name
+    return name.lower().translate(str.maketrans("", "", string.punctuation)).replace(" ", "_")
 
 def file_sha256(path: str, block_size: int = 65536) -> str:
     h = hashlib.sha256()
@@ -56,82 +61,159 @@ def file_sha256(path: str, block_size: int = 65536) -> str:
             h.update(chunk)
     return h.hexdigest()
 
-
-def safe_ffmpeg_run(cmd):
-    try:
-        cmd.run(overwrite_output=True, capture_stdout=True, capture_stderr=True)
-        return True, ""
-    except ffmpeg.Error as e:
-        try:
-            return False, e.stderr.decode(errors="ignore")
-        except Exception:
-            return False, str(e)
-
-
 def convert_video_to_mp4(video_path: str) -> str:
-    target = Path(video_path).with_suffix(".mp4")
-    if target.exists():
-        return str(target)
-    tmp = NamedTemporaryFile(prefix=target.stem + "_", suffix=".mp4", delete=False, dir=target.parent)
-    tmp.close()
-    ok, err = safe_ffmpeg_run(ffmpeg.input(video_path).output(str(tmp.name)))
-    if not ok:
-        raise RuntimeError(f"ffmpeg conversion failed: {err}")
-    os.replace(tmp.name, str(target))
-    if Path(video_path).suffix.lower() != ".mp4":
-        try:
-            Path(video_path).unlink(missing_ok=True)
-        except Exception:
-            pass
-    return str(target)
-
+    target_path = str(Path(video_path).with_suffix(".mp4"))
+    if os.path.exists(target_path):
+        return target_path
+    ffmpeg.input(video_path).output(target_path).run(overwrite_output=True, quiet=True)
+    try:
+        os.remove(video_path)
+    except Exception:
+        pass
+    return target_path
 
 def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str = "fast"):
-    tmp = NamedTemporaryFile(prefix=Path(target_path).stem + "_", suffix=".mp4", delete=False, dir=Path(target_path).parent)
-    tmp.close()
-    ok, err = safe_ffmpeg_run(ffmpeg.input(input_path).output(str(tmp.name), vcodec="libx264", crf=crf, preset=preset))
-    if not ok:
+    try:
+        ffmpeg.input(input_path).output(target_path, vcodec="libx264", crf=crf, preset=preset).run(overwrite_output=True, quiet=True)
+        return target_path
+    except Exception:
         return input_path
-    os.replace(tmp.name, target_path)
-    return target_path
-
 
 def download_video_ytdlp(url: str, save_dir: str, video_password: str = None) -> str:
     if not url:
         raise ValueError("No URL provided")
     outtmpl = str(Path(save_dir) / "%(id)s.%(ext)s")
-    opts = {"outtmpl": outtmpl, "format": "best"}
+    ydl_opts = {"outtmpl": outtmpl, "format": "best"}
     if video_password:
-        opts["videopassword"] = video_password
-    with yt_dlp.YoutubeDL(opts) as ydl:
+        ydl_opts["videopassword"] = video_password
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
         info = ydl.extract_info(url, download=True)
     video_id = info.get("id") if isinstance(info, dict) else None
     if video_id:
-        matches = glob(str(Path(save_dir) / f"{video_id}.*"))
+        matches = glob(os.path.join(save_dir, f"{video_id}.*"))
     else:
-        matches = sorted(glob(str(Path(save_dir) / "*")), key=os.path.getmtime, reverse=True)[:1]
+        matches = sorted(glob(os.path.join(save_dir, "*")), key=os.path.getmtime, reverse=True)[:1]
     if not matches:
         raise FileNotFoundError("Downloaded video not found")
     return convert_video_to_mp4(matches[0])
 
-
 def file_name_or_id(file_obj):
-    if not file_obj:
+    if file_obj is None:
         return None
     if isinstance(file_obj, dict):
-        for key in ("name", "id", "fileId", "file_id", "uri", "url"):
-            v = file_obj.get(key)
-            if v:
-                return str(v)
-    for attr in ("name", "id", "fileId", "file_id", "uri", "url"):
-        v = getattr(file_obj, attr, None)
-        if v:
-            return str(v)
-    return str(file_obj)
-
-
-def wait_for_processed(file_obj, timeout=600):
-    if get_file is None:
+        return file_obj.get("name") or file_obj.get("id")
+    return getattr(file_obj, "name", None) or getattr(file_obj, "id", None) or getattr(file_obj, "fileId", None)
+
+# Configure Google SDK if key present
+if os.getenv("GOOGLE_API_KEY") and HAS_GENAI:
+    try:
+        genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+    except Exception:
+        pass
+
+# UI: Sidebar inputs
+st.sidebar.header("Video Input")
+st.sidebar.text_input("Video URL", key="url", placeholder="https://")
+
+settings_exp = st.sidebar.expander("Settings", expanded=False)
+env_api_key = os.getenv("GOOGLE_API_KEY", "")
+API_KEY = settings_exp.text_input("Google API Key", value=env_api_key, placeholder="Set GOOGLE_API_KEY in .env or enter here", type="password")
+model_input = settings_exp.text_input("Gemini Model (short name)", "gemini-2.0-flash-lite")
+model_id = model_input.strip() or "gemini-2.0-flash-lite"
+model_arg = model_id if not model_id.startswith("models/") else model_id.split("/", 1)[1]
+analysis_prompt = settings_exp.text_area("Enter analysis", value="watch entire video and describe", height=120)
+settings_exp.text_input("Video Password (if needed)", key="video-password", placeholder="password", type="password")
+settings_exp.checkbox("Fast mode (skip compression, smaller model, fewer tokens)", key="fast_mode")
+
+if not API_KEY and not os.getenv("GOOGLE_API_KEY"):
+    settings_exp.warning("No Google API key provided; upload/generation disabled.", icon="⚠️")
+
+safety_settings = [
+    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "OFF"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "OFF"},
+]
+
+# Build Agent if available
+_agent = None
+if HAS_PHI and HAS_GENAI and (API_KEY or os.getenv("GOOGLE_API_KEY")):
+    try:
+        key_to_use = API_KEY if API_KEY else os.getenv("GOOGLE_API_KEY")
+        genai.configure(api_key=key_to_use)
+        _agent = Agent(name="Video AI summarizer", model=Gemini(id=model_id), tools=[DuckDuckGo()], markdown=True)
+    except Exception:
+        _agent = None
+
+def clear_all_video_state():
+    st.session_state.pop("uploaded_file", None)
+    st.session_state.pop("processed_file", None)
+    st.session_state["videos"] = ""
+    st.session_state["last_loaded_path"] = ""
+    st.session_state["analysis_out"] = ""
+    st.session_state["last_error"] = ""
+    st.session_state["file_hash"] = None
+    for f in glob(str(DATA_DIR / "*")):
+        try:
+            os.remove(f)
+        except Exception:
+            pass
+
+# Track URL changes
+if "last_url_value" not in st.session_state:
+    st.session_state["last_url_value"] = st.session_state.get("url", "")
+current_url = st.session_state.get("url", "")
+if current_url != st.session_state.get("last_url_value"):
+    clear_all_video_state()
+    st.session_state["last_url_value"] = current_url
+
+# Load video button
+if st.sidebar.button("Load Video", use_container_width=True):
+    try:
+        vpw = st.session_state.get("video-password", "")
+        path = download_video_ytdlp(st.session_state.get("url", ""), str(DATA_DIR), vpw)
+        st.session_state["videos"] = path
+        st.session_state["last_loaded_path"] = path
+        st.session_state.pop("uploaded_file", None)
+        st.session_state.pop("processed_file", None)
+        st.session_state["file_hash"] = file_sha256(path)
+    except Exception as e:
+        st.sidebar.error(f"Failed to load video: {e}")
+
+# Sidebar preview & options
+if st.session_state["videos"]:
+    try:
+        st.sidebar.video(st.session_state["videos"], loop=st.session_state.get("loop_video", False))
+    except Exception:
+        st.sidebar.write("Couldn't preview video")
+
+    with st.sidebar.expander("Options", expanded=False):
+        loop_checkbox = st.checkbox("Enable Loop", value=st.session_state.get("loop_video", False))
+        st.session_state["loop_video"] = loop_checkbox
+
+        if st.button("Clear Video(s)"):
+            clear_all_video_state()
+
+        try:
+            with open(st.session_state["videos"], "rb") as vf:
+                st.download_button("Download Video", data=vf, file_name=sanitize_filename(st.session_state["videos"]), mime="video/mp4", use_container_width=True)
+        except Exception:
+            st.sidebar.error("Failed to prepare download")
+
+    st.sidebar.write("Title:", Path(st.session_state["videos"]).name)
+
+# Upload helpers
+def upload_video_sdk(filepath: str):
+    key = API_KEY if API_KEY else os.getenv("GOOGLE_API_KEY")
+    if not key:
+        raise RuntimeError("No API key provided")
+    if not HAS_GENAI or upload_file is None:
+        raise RuntimeError("google.generativeai SDK not available; cannot upload")
+    genai.configure(api_key=key)
+    return upload_file(filepath)
+
+def wait_for_processed(file_obj, timeout=180):
+    if not HAS_GENAI or get_file is None:
         return file_obj
     start = time.time()
     name = file_name_or_id(file_obj)
@@ -139,10 +221,7 @@ def wait_for_processed(file_obj, timeout=600):
         return file_obj
     backoff = 1.0
     while True:
-        try:
-            obj = get_file(name)
-        except Exception:
-            obj = file_obj
+        obj = get_file(name)
         state = getattr(obj, "state", None)
         if not state or getattr(state, "name", None) != "PROCESSING":
             return obj
@@ -151,168 +230,197 @@ def wait_for_processed(file_obj, timeout=600):
         time.sleep(backoff)
         backoff = min(backoff * 2, 8.0)
 
-
-# UI
-st.sidebar.header("Input")
-st.sidebar.text_input("Video URL", key="url", placeholder="https://")
-settings = st.sidebar.expander("Settings", expanded=True)
-API_KEY_INPUT = settings.text_input("Google API Key (one-time)", value=os.getenv("GOOGLE_API_KEY", ""), type="password")
-MODEL = settings.text_input("Model", value="text-bison@001")
-settings.checkbox("Fast mode (skip compress)", key="fast_mode")
-settings.checkbox("Compress >50MB", value=True, key="use_compression")
-settings.number_input("Max output tokens", key="max_output_tokens", value=1024, min_value=128, max_value=8192, step=128)
-
-if st.sidebar.button("Load Video"):
-    try:
-        vpw = st.session_state.get("video-password", "")
-        p = download_video_ytdlp(st.session_state.get("url", ""), str(DATA_DIR), vpw)
-        st.session_state["video_path"] = p
-        st.session_state["file_hash"] = file_sha256(p)
-        st.session_state["uploaded_file"] = None
-        st.session_state["processed_file"] = None
-    except Exception as e:
-        st.sidebar.error(f"Failed to load video: {e}")
-
-if st.session_state["video_path"]:
-    try:
-        st.sidebar.video(st.session_state["video_path"])
-    except Exception:
-        st.sidebar.write("Can't preview")
-    with st.sidebar.expander("Actions"):
-        if st.button("Clear"):
-            for f in glob(str(DATA_DIR / "*")):
-                try:
-                    Path(f).unlink(missing_ok=True)
-                except Exception:
-                    pass
-            st.session_state["video_path"] = ""
-            st.session_state["uploaded_file"] = None
-            st.session_state["processed_file"] = None
-            st.session_state["file_hash"] = None
-    try:
-        with open(st.session_state["video_path"], "rb") as vf:
-            st.download_button("Download Video", data=vf, file_name=sanitize_filename(st.session_state["video_path"]))
-    except Exception:
-        pass
-
+# Robust prompt-echo removal
+def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_threshold: float = 0.68):
+    if not prompt or not text:
+        return text
+    a = " ".join(prompt.strip().lower().split())
+    b_full = text.strip()
+    b = " ".join(b_full[:check_len].lower().split())
+    ratio = SequenceMatcher(None, a, b).ratio()
+    if ratio >= ratio_threshold:
+        # remove the approximate prefix by length of prompt, but be conservative
+        cut = min(len(b_full), max(int(len(prompt) * 0.9), len(a)))
+        new_text = b_full[cut:].lstrip(" \n:-")
+        # If result is empty or too small, return original to avoid data loss
+        if len(new_text) >= 3:
+            return new_text
+    # also remove common placeholder prefixes
+    placeholders = ["enter analysis", "enter your analysis", "enter analysis here", "please enter analysis"]
+    low = b_full.strip().lower()
+    for ph in placeholders:
+        if low.startswith(ph):
+            return b_full[len(ph):].lstrip(" \n:-")
+    return text
+
+# Main UI layout
 col1, col2 = st.columns([1, 3])
 with col1:
-    if st.session_state["busy"]:
-        st.write("Working...")
-        if st.button("Cancel"):
-            st.session_state["busy"] = False
+    if st.session_state.get("busy"):
+        st.button("Generate the story", disabled=True)
     else:
-        gen_btn = st.button("Generate the story", type="primary")
-
+        generate_now = st.button("Generate the story", type="primary")
 with col2:
-    prompt_text = st.text_area("Analysis prompt", value="Summarize the video's main events vividly, 2-4 paragraphs.", height=200)
-
-def configure_sdk(api_key: str):
-    genai.configure(api_key=api_key)
-
-def responses_generate_via_sdk(model, prompt, file_name, max_tokens):
-    # SDK responses.generate: model + messages or input; include file via files param if available
-    messages = [{"role": "system", "content": "You are a helpful assistant."}, {"role": "user", "content": prompt}]
-    kwargs = {"model": model, "messages": messages, "max_output_tokens": int(max_tokens)}
-    if file_name:
-        kwargs["files"] = [{"name": file_name}]
-    return genai.responses.generate(**kwargs)
+    pass
 
-def extract_text(resp):
-    if resp is None:
-        return None
-    # SDK object: resp.output is list
-    out = []
-    out_items = getattr(resp, "output", None) or []
-    for it in out_items:
-        cont = getattr(it, "content", None) or []
-        if isinstance(cont, list):
-            for c in cont:
-                if isinstance(c, dict) and "text" in c:
-                    out.append(c["text"])
-                elif isinstance(c, str):
-                    out.append(c)
-        elif isinstance(cont, str):
-            out.append(cont)
-        txt = getattr(it, "text", None)
-        if isinstance(txt, str):
-            out.append(txt)
-    if out:
-        return "\n\n".join(out)
-    # fallback attributes
-    return getattr(resp, "output_text", None) or getattr(resp, "text", None)
-
-if 'gen_btn' in locals() and gen_btn:
-    if not st.session_state["video_path"]:
-        st.error("No video loaded")
+# Generation flow
+if (st.session_state.get("busy") is False) and ('generate_now' in locals() and generate_now):
+    if not st.session_state.get("videos"):
+        st.error("No video loaded. Use 'Load Video' in the sidebar.")
     else:
-        key = API_KEY_INPUT.strip() or None
-        if not key:
-            st.error("Set GOOGLE_API_KEY in .env or paste in Settings")
+        key_to_use = API_KEY if API_KEY else os.getenv("GOOGLE_API_KEY")
+        if not key_to_use:
+            st.error("Google API key not set.")
         else:
             try:
                 st.session_state["busy"] = True
-                configure_sdk(key)
-
-                # decide whether to upload
-                path = st.session_state["video_path"]
-                current_hash = file_sha256(path) if Path(path).exists() else None
-                need_upload = True
-                if st.session_state["processed_file"] and st.session_state.get("file_hash") == current_hash:
-                    need_upload = False
-
-                upload_path = path
-                compressed = None
-                if need_upload:
-                    size_mb = Path(path).stat().st_size / (1024 * 1024)
-                    if st.session_state.get("use_compression") and not st.session_state.get("fast_mode") and size_mb > 50:
-                        compressed = str(Path(path).with_name(Path(path).stem + "_compressed.mp4"))
-                        upload_path = compress_video(path, compressed, crf=28, preset="fast")
+                processed = st.session_state.get("processed_file")
+                # Use file hash to determine if we must re-upload
+                current_path = st.session_state.get("videos")
+                current_hash = None
+                try:
+                    current_hash = file_sha256(current_path) if current_path and os.path.exists(current_path) else None
+                except Exception:
+                    current_hash = None
+
+                reupload_needed = True
+                if processed and st.session_state.get("last_loaded_path") == current_path and st.session_state.get("file_hash") == current_hash:
+                    reupload_needed = False
+
+                if reupload_needed:
+                    if not HAS_GENAI:
+                        raise RuntimeError("google.generativeai SDK not available; install it.")
+                    local_path = current_path
+                    # Fast mode overrides compression behavior
+                    fast_mode = st.session_state.get("fast_mode", False)
+                    upload_path = local_path
+                    try:
+                        file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
+                    except Exception:
+                        file_size_mb = 0
+
+                    # Only compress if large and not in fast mode
+                    if not fast_mode and file_size_mb > 50:
+                        compressed_path = str(Path(local_path).with_name(Path(local_path).stem + "_compressed.mp4"))
+                        try:
+                            # Use faster preset when focusing on speed
+                            preset = "veryfast" if fast_mode else "fast"
+                            upload_path = compress_video(local_path, compressed_path, crf=28, preset=preset)
+                        except Exception:
+                            upload_path = local_path
+
                     with st.spinner("Uploading video..."):
-                        uploaded = upload_file(upload_path)
-                    processed = wait_for_processed(uploaded, timeout=600)
-                    st.session_state["uploaded_file"] = uploaded
-                    st.session_state["processed_file"] = processed
-                    st.session_state["file_hash"] = current_hash
+                        uploaded = upload_video_sdk(upload_path)
+                        processed = wait_for_processed(uploaded, timeout=180)
+                        st.session_state["uploaded_file"] = uploaded
+                        st.session_state["processed_file"] = processed
+                        st.session_state["last_loaded_path"] = current_path
+                        st.session_state["file_hash"] = current_hash
+
+                prompt_text = (analysis_prompt.strip() or "Describe this video in vivid detail.").strip()
+
+                out = ""
+                # Use lighter model/tokens in fast mode
+                if st.session_state.get("fast_mode"):
+                    model_used = model_arg if model_arg else "gemini-2.0-flash-lite"
+                    max_tokens = 512
                 else:
-                    uploaded = st.session_state["uploaded_file"]
-                    processed = st.session_state["processed_file"]
+                    model_used = model_arg
+                    max_tokens = 1024
 
-                fname = file_name_or_id(processed) or file_name_or_id(uploaded)
-                resp = responses_generate_via_sdk(MODEL, prompt_text, fname, st.session_state.get("max_output_tokens", 1024))
-                out = extract_text(resp)
+                if _agent:
+                    with st.spinner("Generating description via Agent..."):
+                        response = _agent.run(prompt_text, videos=[processed], safety_settings=safety_settings)
+                        out = getattr(response, "content", None) or getattr(response, "outputText", None) or str(response)
+                else:
+                    if not HAS_GENAI or genai is None:
+                        raise RuntimeError("Responses API not available; install google.generativeai SDK.")
+                    genai.configure(api_key=key_to_use)
+                    fname = file_name_or_id(processed)
+                    if not fname:
+                        raise RuntimeError("Uploaded file missing name/id")
+                    system_msg = {"role": "system", "content": prompt_text}
+                    user_msg = {"role": "user", "content": "Please summarize the attached video."}
+                    try:
+                        response = genai.responses.generate(
+                            model=model_used,
+                            messages=[system_msg, user_msg],
+                            files=[{"name": fname}],
+                            safety_settings=safety_settings,
+                            max_output_tokens=max_tokens,
+                        )
+                    except TypeError:
+                        response = genai.responses.generate(
+                            model=model_used,
+                            input=[{"text": prompt_text, "files": [{"name": fname}]}],
+                            safety_settings=safety_settings,
+                            max_output_tokens=max_tokens,
+                        )
+
+                    outputs = getattr(response, "output", None) or (response.get("output") if isinstance(response, dict) else None) or []
+                    if not outputs and isinstance(response, dict):
+                        outputs = response.get("output", [])
+
+                    text_pieces = []
+                    for item in outputs or []:
+                        contents = getattr(item, "content", None) or (item.get("content") if isinstance(item, dict) else None) or []
+                        for c in contents:
+                            ctype = getattr(c, "type", None) or (c.get("type") if isinstance(c, dict) else None)
+                            if ctype in ("output_text", "text") or ctype is None:
+                                txt = getattr(c, "text", None) or (c.get("text") if isinstance(c, dict) else None)
+                                if txt:
+                                    text_pieces.append(txt)
+
+                    if not text_pieces:
+                        top_text = getattr(response, "text", None) or (response.get("text") if isinstance(response, dict) else None)
+                        if top_text:
+                            text_pieces.append(top_text)
+
+                    # dedupe preserving order
+                    seen = set()
+                    filtered = []
+                    for t in text_pieces:
+                        if t not in seen:
+                            filtered.append(t)
+                            seen.add(t)
+                    out = "\n\n".join(filtered)
+
+                # Remove prompt echo robustly
                 if out:
+                    out = remove_prompt_echo(prompt_text, out)
+
+                    # fallback: trim if startswith prompt exactly (legacy)
+                    p = prompt_text
+                    if p and out.strip().lower().startswith(p.lower()):
+                        out = out.strip()[len(p):].lstrip(" \n:-")
+
+                    # strip placeholders
+                    placeholders = ["enter analysis", "enter your analysis", "enter analysis here", "please enter analysis"]
+                    low = out.strip().lower()
+                    for ph in placeholders:
+                        if low.startswith(ph):
+                            out = out.strip()[len(ph):].lstrip(" \n:-")
+                            break
+
                     out = out.strip()
-                st.session_state["analysis_out"] = out or ""
+
+                st.session_state["analysis_out"] = out
                 st.session_state["last_error"] = ""
                 st.subheader("Analysis Result")
-                st.markdown(out or "_(no text returned)_")
-                # cleanup compressed
-                if compressed:
-                    try:
-                        Path(compressed).unlink(missing_ok=True)
-                    except Exception:
-                        pass
+                st.markdown(out)
             except Exception as e:
                 st.session_state["last_error"] = str(e)
-                st.error(f"An error occurred while generating the story: {e}")
+                st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
             finally:
                 st.session_state["busy"] = False
 
+# Display cached analysis if available (avoid duplicate on same run)
 if st.session_state.get("analysis_out"):
-    st.subheader("Analysis Result")
-    st.markdown(st.session_state.get("analysis_out"))
+    just_loaded_same = (st.session_state.get("last_loaded_path") == st.session_state.get("videos"))
+    if not just_loaded_same:
+        st.subheader("Analysis Result")
+        st.markdown(st.session_state.get("analysis_out"))
 
 if st.session_state.get("last_error"):
-    with st.expander("Last Error"):
-        st.write(st.session_state.get("last_error"))
-
-with st.sidebar.expander("Manage uploads"):
-    if st.button("Delete local files"):
-        for f in glob(str(DATA_DIR / "*")):
-            try:
-                Path(f).unlink(missing_ok=True)
-            except Exception:
-                pass
-        st.session_state["video_path"] = ""
-        st.success("Local files removed")
+    with st.expander("Last Error", expanded=False):
+        st.write(st.session_state.get("last_error"))