Update streamlit_app.py

streamlit_app.py

@@ -1,4 +1,17 @@
 # streamlit_app.py
+"""
+Streamlit app for video captioning / analysis using Google GenAI Responses API.
+Removed phi-agent support. Uses google.generativeai SDK (Responses).
+Requires GOOGLE_API_KEY in environment or entered in UI.
+
+Features:
+- Download video via yt-dlp
+- Optional compression for files > 200 MB (configurable)
+- Upload video via google.generativeai.upload_file and wait for processing via get_file
+- Generate analysis via Responses.generate (or Responses.create legacy compatibility)
+- Basic UI for model selection, prompts, timeouts, and status/progress reporting
+"""
+
 import os
 import time
 import string
@@ -6,7 +19,6 @@ import hashlib
 import traceback
 from glob import glob
 from pathlib import Path
-from difflib import SequenceMatcher
 import json
 import logging
 
@@ -15,19 +27,7 @@ import ffmpeg
 import streamlit as st
 from dotenv import load_dotenv
 
-load_dotenv()
-
-# Optional phi integration (Agent wrapper)
-try:
-    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
-
-# google.generativeai SDK (try both legacy and newer patterns)
+# Google GenAI SDK
 try:
     import google.generativeai as genai
     genai_responses = getattr(genai, "responses", None) or getattr(genai, "Responses", None)
@@ -41,13 +41,18 @@ except Exception:
     get_file = None
     HAS_GENAI = False
 
+load_dotenv()
+
+# Logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("video_ai")
 
+# App config
 st.set_page_config(page_title="Generate the story of videos", layout="wide")
 DATA_DIR = Path("./data")
 DATA_DIR.mkdir(exist_ok=True)
 
+# Session defaults
 st.session_state.setdefault("videos", "")
 st.session_state.setdefault("loop_video", False)
 st.session_state.setdefault("uploaded_file", None)
@@ -64,6 +69,7 @@ st.session_state.setdefault("last_url_value", "")
 st.session_state.setdefault("processing_timeout", 900)
 st.session_state.setdefault("generation_timeout", 300)
 st.session_state.setdefault("preferred_model", "gemini-2.5-flash-lite")
+st.session_state.setdefault("compression_threshold_mb", 200)  # new threshold per plan
 
 MODEL_OPTIONS = [
     "gemini-2.5-flash",
@@ -73,6 +79,7 @@ MODEL_OPTIONS = [
     "custom",
 ]
 
+# Utilities
 def sanitize_filename(path_str: str):
     name = Path(path_str).name
     return name.lower().translate(str.maketrans("", "", string.punctuation)).replace(" ", "_")
@@ -95,13 +102,26 @@ def convert_video_to_mp4(video_path: str) -> str:
         pass
     return target_path
 
-def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str = "fast"):
+def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str = "fast", bitrate: str = None):
+    """
+    Compress video using ffmpeg; tune via crf or bitrate.
+    Returns target_path on success, else original input_path.
+    """
     try:
-        ffmpeg.input(input_path).output(
-            target_path, vcodec="libx264", crf=crf, preset=preset
-        ).run(overwrite_output=True, quiet=True)
-        return target_path
+        out = ffmpeg.input(input_path)
+        params = {"vcodec": "libx264", "crf": crf, "preset": preset}
+        if bitrate:
+            params["video_bitrate"] = bitrate
+            # ffmpeg-python uses keyword 'b' for bitrate if passed via output string; using bitrate via args below
+            stream = out.output(target_path, **{"vcodec": "libx264", "preset": preset}, video_bitrate=bitrate)
+        else:
+            stream = out.output(target_path, **params)
+        stream.run(overwrite_output=True, quiet=True)
+        if os.path.exists(target_path):
+            return target_path
+        return input_path
     except Exception:
+        logger.exception("Compression failed")
         return input_path
 
 def download_video_ytdlp(url: str, save_dir: str, video_password: str = None) -> str:
@@ -141,96 +161,38 @@ def configure_genai_if_needed():
         if genai is not None and hasattr(genai, "configure"):
             genai.configure(api_key=key)
     except Exception:
-        pass
+        logger.exception("Failed to configure genai")
     return True
 
-_agent = None
-def maybe_create_agent(model_id: str):
-    global _agent
+# Upload & processing helpers (using google.generativeai SDK functions upload_file/get_file)
+def upload_video_sdk(filepath: str, progress_callback=None):
+    """
+    Upload a local file using google.generativeai.upload_file.
+    Assumes genai.configure(api_key=...) was called.
+    """
     key = get_effective_api_key()
-    if not (HAS_PHI and HAS_GENAI and key):
-        _agent = None
-        return None
-    if _agent and st.session_state.get("last_model") == model_id:
-        return _agent
+    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")
+    # SDK upload_file typically takes path and returns file object
     try:
         if genai is not None and hasattr(genai, "configure"):
             genai.configure(api_key=key)
-        _agent = Agent(name="Video AI summarizer", model=Gemini(id=model_id), tools=[DuckDuckGo()], markdown=True)
-        st.session_state["last_model"] = model_id
     except Exception:
-        _agent = None
-    return _agent
-
-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
-
-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
-
-st.sidebar.header("Video Input")
-st.sidebar.text_input("Video URL", key="url", placeholder="https://")
-
-settings_exp = st.sidebar.expander("Settings", expanded=False)
-chosen = settings_exp.selectbox("Gemini model", MODEL_OPTIONS, index=MODEL_OPTIONS.index("gemini-2.5-flash-lite"))
-custom_model = ""
-if chosen == "custom":
-    custom_model = settings_exp.text_input("Custom model name", value=st.session_state.get("preferred_model", "gemini-2.5-flash-lite"))
-model_input_value = (custom_model.strip() if chosen == "custom" else chosen).strip()
-settings_exp.text_input("Google API Key", key="api_key", value=os.getenv("GOOGLE_API_KEY", ""), type="password")
-default_prompt = (
-    "Watch the video and provide a detailed behavioral report focusing on human actions, interactions, posture, movement, and apparent intent. Keep language professional. Include a list of observations for notable events."
-)
-analysis_prompt = settings_exp.text_area("Enter analysis", value=default_prompt, height=140)
-settings_exp.text_input("Video Password (if needed)", key="video-password", placeholder="password", type="password")
-
-settings_exp.number_input(
-    "Processing timeout (s)", min_value=60, max_value=3600,
-    value=st.session_state.get("processing_timeout", 900), step=30,
-    key="processing_timeout",
-)
-settings_exp.number_input(
-    "Generation timeout (s)", min_value=30, max_value=1800,
-    value=st.session_state.get("generation_timeout", 300), step=10,
-    key="generation_timeout",
-)
-
-key_source = "session" if st.session_state.get("api_key") else ".env" if os.getenv("GOOGLE_API_KEY") else "none"
-settings_exp.caption(f"Using API key from: **{key_source}**")
-if not get_effective_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"},
-]
+        pass
 
-def upload_video_sdk(filepath: str):
-    key = get_effective_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")
-    if genai is not None and hasattr(genai, "configure"):
-        genai.configure(api_key=key)
-    return upload_file(filepath)
+    # call upload_file and return its result
+    try:
+        return upload_file(filepath)
+    except Exception as e:
+        logger.exception("Upload failed")
+        raise
 
 def wait_for_processed(file_obj, timeout: int = None, progress_callback=None):
+    """
+    Poll get_file(name_or_id) until processing state changes away from 'PROCESSING' or timeout.
+    """
     if timeout is None:
         timeout = st.session_state.get("processing_timeout", 900)
     if not HAS_GENAI or get_file is None:
@@ -268,45 +230,7 @@ def wait_for_processed(file_obj, timeout: int = None, progress_callback=None):
         time.sleep(backoff)
         backoff = min(backoff * 2, 8.0)
 
-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:
-        cut = min(len(b_full), max(int(len(prompt) * 0.9), len(a)))
-        new_text = b_full[cut:].lstrip(" \n:-")
-        if len(new_text) >= 3:
-            return new_text
-    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
-
-def compress_video_if_large(local_path: str, threshold_mb: int = 50):
-    try:
-        file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
-    except Exception as e:
-        st.session_state["last_error"] = f"Failed to stat file before compression: {e}"
-        return local_path, False
-
-    if file_size_mb <= threshold_mb:
-        return local_path, False
-
-    compressed_path = str(Path(local_path).with_name(Path(local_path).stem + "_compressed.mp4"))
-    try:
-        result = compress_video(local_path, compressed_path, crf=28, preset="fast")
-        if result and os.path.exists(result):
-            return result, True
-        return local_path, False
-    except Exception as e:
-        st.session_state["last_error"] = f"Video compression failed: {e}\n{traceback.format_exc()}"
-        return local_path, False
-
+# Response normalization
 def _normalize_genai_response(response):
     if response is None:
         return ""
@@ -371,6 +295,7 @@ def _normalize_genai_response(response):
             seen.add(t)
     return "\n\n".join(filtered).strip()
 
+# Generation via Responses API (supports modern and legacy patterns)
 def generate_via_responses_api(prompt_text: str, processed, model_used: str, max_tokens: int = 1024, timeout: int = 300, progress_callback=None):
     key = get_effective_api_key()
     if not key:
@@ -387,8 +312,11 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
     user_msg = {"role": "user", "content": "Please summarize the attached video."}
     call_variants = []
 
-    call_variants.append({"method": "responses.generate", "payload": {"model": model_used, "messages": [system_msg, user_msg], "files": [{"name": fname}], "safety_settings": safety_settings, "max_output_tokens": max_tokens}})
-    call_variants.append({"method": "responses.generate_alt", "payload": {"model": model_used, "input": [{"text": prompt_text, "files": [{"name": fname}]}], "safety_settings": safety_settings, "max_output_tokens": max_tokens}})
+    # preferred modern call
+    call_variants.append({"method": "responses.generate", "payload": {"model": model_used, "messages": [system_msg, user_msg], "files": [{"name": fname}], "max_output_tokens": max_tokens}})
+    # alternate modern payload shape
+    call_variants.append({"method": "responses.generate_alt", "payload": {"model": model_used, "input": [{"text": prompt_text, "files": [{"name": fname}]}], "max_output_tokens": max_tokens}})
+    # legacy
     call_variants.append({"method": "legacy_responses_create", "payload": {"model": model_used, "input": prompt_text, "file": fname, "max_output_tokens": max_tokens}})
 
     def is_transient_error(e_text: str):
@@ -450,7 +378,96 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
                 time.sleep(backoff)
                 backoff = min(backoff * 2, 8.0)
 
-# UI layout
+# Prompt echo removal
+from difflib import SequenceMatcher
+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:
+        cut = min(len(b_full), max(int(len(prompt) * 0.9), len(a)))
+        new_text = b_full[cut:].lstrip(" \n:-")
+        if len(new_text) >= 3:
+            return new_text
+    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
+
+# UI
+current_url = st.session_state.get("url", "")
+if current_url != st.session_state.get("last_url_value"):
+    # clear per-plan
+    st.session_state["videos"] = ""
+    st.session_state["last_loaded_path"] = ""
+    st.session_state["uploaded_file"] = None
+    st.session_state["processed_file"] = None
+    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
+    st.session_state["last_url_value"] = current_url
+
+st.sidebar.header("Video Input")
+st.sidebar.text_input("Video URL", key="url", placeholder="https://")
+
+settings_exp = st.sidebar.expander("Settings", expanded=False)
+chosen = settings_exp.selectbox("Gemini model", MODEL_OPTIONS, index=MODEL_OPTIONS.index(st.session_state.get("preferred_model", "gemini-2.5-flash-lite")))
+custom_model = ""
+if chosen == "custom":
+    custom_model = settings_exp.text_input("Custom model name", value=st.session_state.get("preferred_model", "gemini-2.5-flash-lite"))
+model_input_value = (custom_model.strip() if chosen == "custom" else chosen).strip()
+
+settings_exp.text_input("Google API Key", key="api_key", value=os.getenv("GOOGLE_API_KEY", ""), type="password")
+
+default_prompt = (
+    "Watch the video and provide a detailed behavioral report focusing on human actions, interactions, posture, movement, and apparent intent. Keep language professional. Include a list of observations for notable events."
+)
+analysis_prompt = settings_exp.text_area("Enter analysis prompt", value=default_prompt, height=140)
+settings_exp.text_input("Video Password (if needed)", key="video-password", placeholder="password", type="password")
+
+settings_exp.number_input(
+    "Processing timeout (s)", min_value=60, max_value=3600,
+    value=st.session_state.get("processing_timeout", 900), step=30,
+    key="processing_timeout",
+)
+settings_exp.number_input(
+    "Generation timeout (s)", min_value=30, max_value=1800,
+    value=st.session_state.get("generation_timeout", 300), step=10,
+    key="generation_timeout",
+)
+
+# Compression threshold control (per plan: 200 MB)
+settings_exp.number_input(
+    "Compression threshold (MB)", min_value=10, max_value=2000,
+    value=st.session_state.get("compression_threshold_mb", 200), step=10,
+    key="compression_threshold_mb",
+)
+settings_exp.caption("Files ≤ threshold are uploaded unchanged. Files > threshold are compressed before upload (tunable).")
+
+key_source = "session" if st.session_state.get("api_key") else ".env" if os.getenv("GOOGLE_API_KEY") else "none"
+settings_exp.caption(f"Using API key from: **{key_source}**")
+if not get_effective_api_key():
+    settings_exp.warning("No Google API key provided; upload/generation disabled.", icon="⚠️")
+
+# Safety settings placeholder (kept minimal)
+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"},
+]
+
+# Buttons / UI layout
 col1, col2 = st.columns([1, 3])
 with col1:
     generate_now = st.button("Generate the story", type="primary", disabled=not bool(get_effective_api_key()))
@@ -483,7 +500,19 @@ if st.session_state["videos"]:
         st.session_state["loop_video"] = loop_checkbox
 
         if st.button("Clear Video(s)"):
-            clear_all_video_state()
+            # minimal clear
+            st.session_state["videos"] = ""
+            st.session_state["last_loaded_path"] = ""
+            st.session_state["uploaded_file"] = None
+            st.session_state["processed_file"] = None
+            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
 
         try:
             with open(st.session_state["videos"], "rb") as vf:
@@ -495,11 +524,14 @@ if st.session_state["videos"]:
     try:
         file_size_mb = os.path.getsize(st.session_state["videos"]) / (1024 * 1024)
         st.sidebar.caption(f"File size: {file_size_mb:.1f} MB")
-        if file_size_mb > 50:
+        if file_size_mb > st.session_state.get("compression_threshold_mb", 200):
             st.sidebar.warning("Large file detected — it will be compressed automatically before upload.", icon="⚠️")
+        else:
+            st.sidebar.info("File ≤ threshold — will be uploaded unchanged.")
     except Exception:
         pass
 
+# Generation flow
 if generate_now and not st.session_state.get("busy"):
     if not st.session_state.get("videos"):
         st.error("No video loaded. Use 'Load Video' in the sidebar.")
@@ -514,12 +546,12 @@ if generate_now and not st.session_state.get("busy"):
                     if HAS_GENAI and genai is not None:
                         genai.configure(api_key=key_to_use)
                 except Exception:
-                    pass
+                    logger.exception("genai configure failed")
 
                 model_id = model_input_value or st.session_state.get("preferred_model") or "gemini-2.5-flash-lite"
                 if st.session_state.get("last_model") != model_id:
                     st.session_state["last_model"] = ""
-                maybe_create_agent(model_id)
+                # no phi agent creation per plan
 
                 processed = st.session_state.get("processed_file")
                 current_path = st.session_state.get("videos")
@@ -536,7 +568,23 @@ if generate_now and not st.session_state.get("busy"):
                     if not HAS_GENAI:
                         raise RuntimeError("google.generativeai SDK not available; install it.")
                     local_path = current_path
-                    upload_path, compressed = compress_video_if_large(local_path)
+
+                    # Decide whether to compress based on threshold (per plan ≤ threshold upload unchanged)
+                    try:
+                        file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
+                    except Exception:
+                        file_size_mb = None
+
+                    compressed = False
+                    upload_path = local_path
+                    threshold_mb = st.session_state.get("compression_threshold_mb", 200)
+                    if file_size_mb is not None and file_size_mb > threshold_mb:
+                        # compress with conservative settings; allow user to tune via constants if desired
+                        compressed_path = str(Path(local_path).with_name(Path(local_path).stem + "_compressed.mp4"))
+                        with st.spinner("Compressing video before upload..."):
+                            upload_path = compress_video(local_path, compressed_path, crf=28, preset="fast")
+                        if upload_path != local_path:
+                            compressed = True
 
                     with st.spinner(f"Uploading video{' (compressed)' if compressed else ''}..."):
                         try:
@@ -574,52 +622,23 @@ if generate_now and not st.session_state.get("busy"):
                 max_tokens = 2048 if "2.5" in model_used else 1024
                 est_tokens = max_tokens
 
-                agent = maybe_create_agent(model_used)
-                debug_info = {"agent_attempted": False, "agent_ok": False, "agent_error": None, "agent_response_has_text": False}
-                if agent:
-                    debug_info["agent_attempted"] = True
-                    try:
-                        with st.spinner("Generating description via Agent..."):
-                            if not processed:
-                                raise RuntimeError("Processed file missing for agent generation")
-                            agent_response = agent.run(prompt_text, videos=[processed], safety_settings=safety_settings)
-                            agent_text = getattr(agent_response, "content", None) or getattr(agent_response, "outputText", None) or None
-                            if not agent_text:
-                                try:
-                                    if isinstance(agent_response, dict):
-                                        for k in ("content", "outputText", "text", "message"):
-                                            if k in agent_response and agent_response[k]:
-                                                agent_text = agent_response[k]
-                                                break
-                                except Exception:
-                                    pass
-                            if agent_text and str(agent_text).strip():
-                                out = str(agent_text).strip()
-                                debug_info["agent_ok"] = True
-                                debug_info["agent_response_has_text"] = True
-                            else:
-                                debug_info["agent_ok"] = False
-                    except Exception as ae:
-                        debug_info["agent_error"] = f"{ae}"
-                        debug_info["agent_traceback"] = traceback.format_exc()
-
-                if not out:
-                    try:
-                        gen_progress_placeholder = st.empty()
-                        gen_status = gen_progress_placeholder.text("Starting generation...")
-                        start_gen = time.time()
-                        def gen_progress_cb(stage, elapsed, info):
-                            try:
-                                gen_status.text(f"Stage: {stage} — elapsed: {elapsed}s — {info}")
-                            except Exception:
-                                pass
-                        out = generate_via_responses_api(prompt_text, processed, model_used, max_tokens=max_tokens, timeout=st.session_state.get("generation_timeout", 300), progress_callback=gen_progress_cb)
-                        gen_progress_placeholder.text(f"Generation complete in {int(time.time()-start_gen)}s")
-                    except Exception as e:
-                        tb = traceback.format_exc()
-                        st.session_state["last_error"] = f"Responses API error: {e}\n\nDebug: {debug_info}\n\nTraceback:\n{tb}"
-                        st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
-                        out = ""
+                # Generate via Responses API
+                try:
+                    gen_progress_placeholder = st.empty()
+                    gen_status = gen_progress_placeholder.text("Starting generation...")
+                    start_gen = time.time()
+                    def gen_progress_cb(stage, elapsed, info):
+                        try:
+                            gen_status.text(f"Stage: {stage} — elapsed: {elapsed}s — {info}")
+                        except Exception:
+                            pass
+                    out = generate_via_responses_api(prompt_text, processed, model_used, max_tokens=max_tokens, timeout=st.session_state.get("generation_timeout", 300), progress_callback=gen_progress_cb)
+                    gen_progress_placeholder.text(f"Generation complete in {int(time.time()-start_gen)}s")
+                except Exception as e:
+                    tb = traceback.format_exc()
+                    st.session_state["last_error"] = f"Responses API error: {e}\n\nTraceback:\n{tb}"
+                    st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
+                    out = ""
 
                 if out:
                     out = remove_prompt_echo(prompt_text, out)
@@ -642,17 +661,19 @@ if generate_now and not st.session_state.get("busy"):
 
             except Exception as e:
                 tb = traceback.format_exc()
-                st.session_state["last_error"] = f"{e}\n\nDebug: {locals().get('debug_info', {})}\n\nTraceback:\n{tb}"
+                st.session_state["last_error"] = f"{e}\n\nTraceback:\n{tb}"
                 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 existing analysis
 if 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"))
 
+# Last error expander
 if st.session_state.get("last_error"):
     with st.expander("Last Error", expanded=False):
         st.write(st.session_state.get("last_error"))