Update streamlit_app.py

streamlit_app.py

@@ -1,39 +1,51 @@
 #!/usr/bin/env python3
-import os
+# -*- coding: utf-8 -*-
+
+"""
+Video‑analysis Streamlit app.
+
+Features
+--------
+* Download videos from direct links, Twitter, or any site supported by yt‑dlp.
+* Convert to MP4 (ffmpeg) and compress if larger than a user‑defined threshold.
+* Send the video (base64‑encoded) + a custom prompt to Gemini‑Flash models.
+* Simple sidebar UI with clear‑video handling.
+"""
+
 import base64
 import hashlib
+import os
 import string
 import traceback
 from pathlib import Path
 from typing import List, Tuple, Optional
 
-import requests
-import streamlit as st
 import ffmpeg
 import google.generativeai as genai
+import requests
+import streamlit as st
 import yt_dlp
 
 # ----------------------------------------------------------------------
-# Optional imports – give a clear message if missing
+# Optional dependency – Twitter scraper
 # ----------------------------------------------------------------------
 try:
     import snscrape.modules.twitter as sntwitter
 except ImportError:  # pragma: no cover
     st.error(
-        "The package `snscrape` is required for Twitter video extraction. "
-        "Install it with `pip install snscrape`."
+        "Package `snscrape` is required for Twitter extraction. "
+        "Install with `pip install snscrape`."
     )
     st.stop()
 
 # ----------------------------------------------------------------------
-# Configuration & defaults
+# Constants & defaults
 # ----------------------------------------------------------------------
 DATA_DIR = Path("./data")
 DATA_DIR.mkdir(exist_ok=True)
 
-# Use the newest Gemini model that consumes the fewest tokens
 MODEL_OPTIONS = [
-    "gemini-2.5-flash-lite",   # default, cheapest‑token version
+    "gemini-2.5-flash-lite",
     "gemini-2.5-flash",
     "gemini-2.0-flash-lite",
     "gemini-2.0-flash",
@@ -47,207 +59,201 @@ DEFAULT_PROMPT = (
     "Include a list of observations for notable events."
 )
 
-# Session‑state defaults (kept in one dict for readability)
-DEFAULT_SESSION_STATE = {
+# ----------------------------------------------------------------------
+# Session‑state defaults
+# ----------------------------------------------------------------------
+DEFAULT_STATE = {
     "url": "",
-    "videos": "",
-    "loop_video": False,
-    "analysis_out": "",
-    "busy": False,
-    "last_error": "",
-    "api_key": os.getenv("GOOGLE_API_KEY", "AIzaSyBiAW2GQLid0HGe9Vs_ReKwkwsSVNegNzs"),
+    "video_path": "",
     "model_input": DEFAULT_MODEL,
     "prompt": DEFAULT_PROMPT,
+    "api_key": os.getenv("GOOGLE_API_KEY", ""),
     "video_password": "",
-    "processing_timeout": 900,
-    "generation_timeout": 300,
-    "compress_threshold_mb": 200,
+    "compress_mb": 200,
+    "busy": False,
+    "last_error": "",
+    "analysis_out": "",
+    "raw_output": "",          # full Gemini response before stripping
+    "last_error_detail": "",  # traceback + raw output for debugging    
 }
-for k, v in DEFAULT_SESSION_STATE.items():
+for k, v in DEFAULT_STATE.items():
     st.session_state.setdefault(k, v)
 
 # ----------------------------------------------------------------------
 # Helper utilities
 # ----------------------------------------------------------------------
-from difflib import SequenceMatcher  # imported once for clarity
-
-
-def sanitize_filename(p: str) -> str:
-    """Return a lower‑case, punctuation‑free filename."""
-    name = Path(p).name.lower()
+def _sanitize_filename(url: str) -> str:
+    """Lower‑case, punctuation‑free filename derived from a URL."""
+    name = Path(url).name.lower()
     return name.translate(str.maketrans("", "", string.punctuation)).replace(" ", "_")
 
 
-def file_sha256(p: str, block: int = 65536) -> Optional[str]:
-    """SHA‑256 hash of a file; returns None on error."""
+def _file_sha256(path: Path) -> Optional[str]:
+    """Return SHA‑256 hex digest or None on failure."""
     try:
         h = hashlib.sha256()
-        with open(p, "rb") as f:
-            for chunk in iter(lambda: f.read(block), b""):
+        with path.open("rb") as f:
+            for chunk in iter(lambda: f.read(65536), b""):
                 h.update(chunk)
         return h.hexdigest()
     except Exception:
         return None
 
 
-def convert_to_mp4(src: str) -> str:
-    """Convert *src* to MP4 with ffmpeg; returns the MP4 path."""
-    dst = str(Path(src).with_suffix(".mp4"))
-    if os.path.exists(dst):
+def _convert_to_mp4(src: Path) -> Path:
+    """Convert *src* to MP4 with ffmpeg; return the MP4 path."""
+    dst = src.with_suffix(".mp4")
+    if dst.exists():
         return dst
     try:
-        ffmpeg.input(src).output(dst).overwrite_output().run(
+        ffmpeg.input(str(src)).output(str(dst)).overwrite_output().run(
             capture_stdout=True, capture_stderr=True
         )
     except ffmpeg.Error as e:
         raise RuntimeError(f"ffmpeg conversion failed: {e.stderr.decode()}") from e
 
-    # Delete source only if conversion succeeded and output is non‑empty
-    if os.path.exists(dst) and os.path.getsize(dst) > 0:
-        os.remove(src)
+    if dst.exists() and dst.stat().st_size > 0:
+        src.unlink()
     return dst
 
 
-def compress_video(inp: str, out: str, crf: int = 28, preset: str = "fast") -> str:
-    """Compress *inp* to *out* using libx264."""
+def _compress_video(inp: Path, crf: int = 28, preset: str = "fast") -> Path:
+    """Compress *inp* using libx264; return the compressed file."""
+    out = inp.with_name(f"{inp.stem}_compressed.mp4")
     try:
-        ffmpeg.input(inp).output(
-            out, vcodec="libx264", crf=crf, preset=preset
+        ffmpeg.input(str(inp)).output(
+            str(out), vcodec="libx264", crf=crf, preset=preset
         ).overwrite_output().run(capture_stdout=True, capture_stderr=True)
     except ffmpeg.Error as e:
         raise RuntimeError(f"ffmpeg compression failed: {e.stderr.decode()}") from e
-    return out if os.path.exists(out) else inp
+    return out if out.exists() else inp
 
 
-def maybe_compress(path: str, limit_mb: int) -> Tuple[str, bool]:
-    """Compress *path* if its size exceeds *limit_mb*.
-    Returns (final_path, was_compressed)."""
-    size_mb = os.path.getsize(path) / (1024 * 1024)
+def _maybe_compress(path: Path, limit_mb: int) -> Tuple[Path, bool]:
+    """Compress *path* if larger than *limit_mb*."""
+    size_mb = path.stat().st_size / (1024 * 1024)
     if size_mb <= limit_mb:
         return path, False
-    out = str(Path(path).with_name(f"{Path(path).stem}_compressed.mp4"))
-    return compress_video(path, out), True
+    return _compress_video(path), True
 
 
-def strip_prompt_echo(prompt: str, text: str, threshold: float = 0.68) -> str:
-    """Remove the prompt if the model repeats it at the start of *text*."""
-    if not prompt or not text:
-        return text
-    clean_prompt = " ".join(prompt.lower().split())
-    snippet = " ".join(text.lower().split()[:600])
+def _download_direct(url: str, dst: Path) -> Path:
+    """HTTP GET for a raw video file."""
+    r = requests.get(url, stream=True, timeout=30)
+    r.raise_for_status()
+    out = dst / _sanitize_filename(url.split("/")[-1])
+    with out.open("wb") as f:
+        for chunk in r.iter_content(chunk_size=8192):
+            if chunk:
+                f.write(chunk)
+    return out
 
-    if SequenceMatcher(None, clean_prompt, snippet).ratio() > threshold:
-        cut = max(len(clean_prompt), int(len(prompt) * 0.9))
-        return text[cut:].lstrip(" \n:-")
-    return text
 
+def _download_with_yt_dlp(url: str, dst: Path, password: str = "") -> Path:
+    """Fallback downloader using yt‑dlp."""
+    tmpl = str(dst / "%(id)s.%(ext)s")
+    opts = {"outtmpl": tmpl, "format": "best"}
+    if password:
+        opts["videopassword"] = password
 
-def generate_inline(
-    video_path: str, prompt: str, model_id: str, timeout: int
-) -> str:
-    """Encode *video_path* as base64 and call Gemini."""
-    with open(video_path, "rb") as f:
-        b64 = base64.b64encode(f.read()).decode()
+    try:
+        with yt_dlp.YoutubeDL(opts) as ydl:
+            info = ydl.extract_info(url, download=True)
+    except Exception as e:
+        raise RuntimeError(
+            f"yt‑dlp could not download the URL. Details: {e}"
+        ) from e
 
-    video_part = {"inline_data": {"mime_type": "video/mp4", "data": b64}}
-    contents = [prompt, video_part]
+    # Predictable filename from yt‑dlp info dict
+    if isinstance(info, dict) and "id" in info:
+        candidate = dst / f"{info['id']}.{info.get('ext', 'mp4')}"
+        if candidate.exists():
+            return _convert_to_mp4(candidate)
 
-    model = genai.GenerativeModel(model_name=model_id)
-    resp = model.generate_content(
-        contents,
-        generation_config={"max_output_tokens": 1024},
-        request_options={"timeout": timeout},
-    )
-    return getattr(resp, "text", str(resp))
+    # Fallback: newest file in the folder
+    files = list(dst.iterdir())
+    if not files:
+        raise RuntimeError("yt‑dlp did not produce any files.")
+    newest = max(files, key=lambda p: p.stat().st_mtime)
+    return _convert_to_mp4(newest)
 
 
-def download_video(url: str, dst_dir: str, password: str = "") -> str:
+def download_video(url: str, dst: Path, password: str = "") -> Path:
     """
-    Download a video from *url*.
-    1️⃣ Direct video file → HTTP GET.
-    2️⃣ Twitter status → scrape for video URL.
-    3️⃣ Fallback → yt‑dlp (YouTube, archive.org, etc.).
-    Returns the path to an MP4 file.
+    Download a video from *url* and return an MP4 path.
+
+    Strategy
+    ---------
+    1. Direct video URL → HTTP GET.
+    2. Twitter status → scrape for embedded video URLs.
+    3. yt‑dlp fallback for everything else.
     """
     video_exts = (".mp4", ".mov", ".webm", ".mkv", ".avi", ".flv")
-    dst_dir = Path(dst_dir)
 
-    # --------------------------------------------------------------
-    # 1️⃣ Direct video file
-    # --------------------------------------------------------------
+    # 1️⃣ Direct file
     if url.lower().endswith(video_exts):
-        try:
-            r = requests.get(url, stream=True, timeout=30)
-            r.raise_for_status()
-            filename = sanitize_filename(url.split("/")[-1])
-            out_path = dst_dir / filename
-            with open(out_path, "wb") as f:
-                for chunk in r.iter_content(chunk_size=8192):
-                    if chunk:
-                        f.write(chunk)
-            return str(out_path)
-        except Exception as e:
-            raise RuntimeError(f"Direct download failed: {e}") from e
+        return _download_direct(url, dst)
 
-    # --------------------------------------------------------------
-    # 2️⃣ Twitter status
-    # --------------------------------------------------------------
+    # 2️⃣ Twitter
     if "twitter.com" in url and "/status/" in url:
-        try:
-            tweet_id = url.split("/")[-1].split("?")[0]
-            for tweet in sntwitter.TwitterTweetScraper(tweet_id).get_items():
-                if getattr(tweet, "media", None):
-                    for m in tweet.media:
-                        if getattr(m, "video_url", None):
-                            return download_video(m.video_url, str(dst_dir))
-                for u in getattr(tweet, "urls", []):
-                    if u.expandedUrl.lower().endswith(video_exts):
-                        return download_video(u.expandedUrl, str(dst_dir))
-            raise RuntimeError("No video found in the tweet.")
-        except Exception as e:
-            raise RuntimeError(f"Twitter scrape failed: {e}") from e
+        tweet_id = url.split("/")[-1].split("?")[0]
+        for tweet in sntwitter.TwitterTweetScraper(tweet_id).get_items():
+            for m in getattr(tweet, "media", []):
+                if getattr(m, "video_url", None):
+                    return download_video(m.video_url, dst)
+            for u in getattr(tweet, "urls", []):
+                if u.expandedUrl.lower().endswith(video_exts):
+                    return download_video(u.expandedUrl, dst)
+        raise RuntimeError("No video found in the tweet.")
+
+    # 3️⃣ yt‑dlp
+    return _download_with_yt_dlp(url, dst, password)
+
+
+def _encode_video_b64(path: Path) -> str:
+    """Read *path* and return a base64‑encoded string."""
+    return base64.b64encode(path.read_bytes()).decode()
+
+
+def generate_report(
+    video_path: Path,
+    prompt: str,
+    model_id: str,
+    timeout: int,
+) -> str:
+    """Send video + prompt to Gemini and return the text response."""
+    b64 = _encode_video_b64(video_path)
+    video_part = {"inline_data": {"mime_type": "video/mp4", "data": b64}}
+    model = genai.GenerativeModel(model_name=model_id)
 
-    # --------------------------------------------------------------
-    # 3️⃣ yt‑dlp fallback
-    # --------------------------------------------------------------
-    tmpl = str(dst_dir / "%(id)s.%(ext)s")
-    opts = {"outtmpl": tmpl, "format": "best"}
-    if password:
-        opts["videopassword"] = password
+    resp = model.generate_content(
+        [prompt, video_part],
+        generation_config={"max_output_tokens": 1024},
+        request_options={"timeout": timeout},
+    )
+    return getattr(resp, "text", str(resp))
 
-    try:
-        with yt_dlp.YoutubeDL(opts) as ydl:
-            info = ydl.extract_info(url, download=True)
-    except Exception as e:
-        raise RuntimeError(
-            f"yt‑dlp could not download the URL. "
-            f"Common reasons: DNS failure, unsupported site, or missing video. "
-            f"Original error: {e}"
-        ) from e
 
-    # If yt‑dlp gave us a predictable filename, use it
-    if isinstance(info, dict) and "id" in info:
-        vid_id = info["id"]
-        ext = info.get("ext", "mp4")
-        candidate = dst_dir / f"{vid_id}.{ext}"
-        if candidate.exists():
-            return convert_to_mp4(str(candidate))
+def _strip_prompt_echo(prompt: str, text: str, threshold: float = 0.68) -> str:
+    """Remove the prompt if the model repeats it at the start of *text*."""
+    if not prompt or not text:
+        return text
+    clean_prompt = " ".join(prompt.lower().split())
+    snippet = " ".join(text.lower().split()[:600])
 
-    # Fallback: newest file in the folder (yt‑dlp sometimes uses different naming)
-    if not any(dst_dir.iterdir()):
-        raise RuntimeError("yt‑dlp did not download any files.")
-    newest = max(dst_dir.iterdir(), key=lambda p: p.stat().st_mtime)
-     # Return the newest file converted to MP4
-    return convert_to_mp4(str(newest))
+    if SequenceMatcher(None, clean_prompt, snippet).ratio() > threshold:
+        cut = max(len(clean_prompt), int(len(prompt) * 0.9))
+        return text[cut:].lstrip(" \n:-")
+    return text
 
 
 # ----------------------------------------------------------------------
 # Streamlit UI
 # ----------------------------------------------------------------------
 def main() -> None:
-    st.set_page_config(page_title="Video Analysis Tool", layout="wide")
+    st.set_page_config(page_title="Video Analysis", layout="wide")
 
-    # ---------- Sidebar inputs ----------
+    # ---------- Sidebar ----------
     st.sidebar.header("Video Input")
     st.sidebar.text_input("Video URL", key="url", placeholder="https://")
 
@@ -256,51 +262,27 @@ def main() -> None:
             "Model", MODEL_OPTIONS, index=MODEL_OPTIONS.index(DEFAULT_MODEL)
         )
         if model == "custom":
-            model = st.text_input(
-                "Custom model ID", value=DEFAULT_MODEL, key="custom_model"
-            )
+            model = st.text_input("Custom model ID", value=DEFAULT_MODEL, key="custom_model")
         st.session_state["model_input"] = model
 
-        # ----- Secret handling (no secrets.toml) -----
-        # If a secret file existed it would be read here, but we fall back
-        # to the environment variable or manual entry.
+        # API key handling
         secret_key = os.getenv("GOOGLE_API_KEY", "")
         if secret_key:
             st.session_state["api_key"] = secret_key
-
-        # Allow manual entry (overwrites any env value)
         st.text_input("Google API Key", key="api_key", type="password")
 
         st.text_area(
             "Analysis prompt", value=DEFAULT_PROMPT, key="prompt", height=140
         )
-        st.text_input(
-            "Video password (if needed)", key="video_password", type="password"
-        )
+        st.text_input("Video password (if needed)", key="video_password", type="password")
 
-        st.number_input(
-            "Processing timeout (s)",
-            min_value=60,
-            max_value=3600,
-            value=st.session_state["processing_timeout"],
-            step=30,
-            key="processing_timeout",
-        )
-        st.number_input(
-            "Generation timeout (s)",
-            min_value=30,
-            max_value=1800,
-            value=st.session_state["generation_timeout"],
-            step=10,
-            key="generation_timeout",
-        )
         st.number_input(
             "Compress if > (MB)",
             min_value=10,
             max_value=2000,
-            value=st.session_state["compress_threshold_mb"],
+            value=st.session_state["compress_mb"],
             step=10,
-            key="compress_threshold_mb",
+            key="compress_mb",
         )
 
     # ---------- Load video ----------
@@ -308,93 +290,35 @@ def main() -> None:
         try:
             with st.spinner("Downloading video…"):
                 path = download_video(
-                    st.session_state["url"], str(DATA_DIR), st.session_state["video_password"]
+                    st.session_state["url"], DATA_DIR, st.session_state["video_password"]
                 )
-            st.session_state["videos"] = path
+            st.session_state["video_path"] = str(path)
             st.session_state["last_error"] = ""
             st.success("Video loaded successfully.")
         except Exception as e:
             st.session_state["last_error"] = f"Download failed: {e}"
             st.sidebar.error(st.session_state["last_error"])
 
-    # ---------- Twitter extractor ----------
-    with st.sidebar.expander("🔎 Extract video(s) from a Tweet", expanded=False):
-        tweet_url = st.text_input(
-            "Tweet URL (e.g. https://twitter.com/user/status/1234567890)",
-            key="tweet_url",
-        )
-        if st.button("Find videos in tweet"):
-            if not tweet_url:
-                st.error("Paste a tweet URL first.")
-            else:
-                try:
-                    tweet_id = tweet_url.split("/")[-1].split("?")[0]
-                    video_urls: List[str] = []
-                    for tweet in sntwitter.TwitterTweetScraper(tweet_id).get_items():
-                        if getattr(tweet, "media", None):
-                            for m in tweet.media:
-                                if getattr(m, "video_url", None):
-                                    video_urls.append(m.video_url)
-                        for u in getattr(tweet, "urls", []):
-                            if u.expandedUrl.lower().endswith(
-                                (".mp4", ".mov", ".webm", ".mkv", ".avi", ".flv")
-                            ):
-                                video_urls.append(u.expandedUrl)
-
-                    video_urls = list(dict.fromkeys(video_urls))  # dedupe, preserve order
-                    if not video_urls:
-                        raise RuntimeError("No video URLs detected in this tweet.")
-
-                    st.session_state["tweet_video_options"] = [
-                        (f"Video {i+1} – {url.split('/')[-1][:30]}...", url)
-                        for i, url in enumerate(video_urls)
-                    ]
-                    st.success(f"Found {len(video_urls)} video(s).")
-                except Exception as e:
-                    st.session_state["tweet_video_options"] = []
-                    st.error(f"Tweet scrape failed: {e}")
-
-        # selector & download
-        if st.session_state.get("tweet_video_options"):
-            labels, urls = zip(*st.session_state["tweet_video_options"])
-            sel = st.selectbox(
-                "Select video to download",
-                options=range(len(labels)),
-                format_func=lambda i: labels[i],
-                key="tweet_video_select",
-            )
-            if st.button("Download selected video"):
-                try:
-                    with st.spinner("Downloading selected video…"):
-                        path = download_video(urls[sel], str(DATA_DIR))
-                    st.session_state["videos"] = path
-                    st.session_state["last_error"] = ""
-                    st.success("Video downloaded and loaded.")
-                except Exception as e:
-                    st.session_state["last_error"] = f"Download failed: {e}"
-                    st.error(st.session_state["last_error"])
-        else:
-            st.info(
-                "Paste a tweet URL and click **Find videos in tweet** to discover available videos."
-            )
-
-    # ---------- Video preview ----------
-    if st.session_state["videos"]:
+    # ---------- Preview & clear ----------
+    if st.session_state["video_path"]:
         try:
-            mp4_path = convert_to_mp4(st.session_state["videos"])
-            st.sidebar.video(str(mp4_path))
+            mp4 = _convert_to_mp4(Path(st.session_state["video_path"]))
+            st.sidebar.video(str(mp4))
         except Exception:
             st.sidebar.write("Preview unavailable")
 
         if st.sidebar.button("Clear Video"):
+            # delete files
             for f in DATA_DIR.iterdir():
                 try:
                     f.unlink()
                 except Exception:
                     pass
+            # reset state, including URL field
             st.session_state.update(
                 {
-                    "videos": "",
+                    "url": "",
+                    "video_path": "",
                     "analysis_out": "",
                     "last_error": "",
                     "busy": False,
@@ -402,73 +326,80 @@ def main() -> None:
             )
             st.success("Session cleared.")
 
-    # ---------- Generation ----------
-    col1, col2 = st.columns([1, 3])
-    with col1:
-        generate_now = st.button(
-            "Generate analysis", type="primary", disabled=st.session_state["busy"]
-        )
-    with col2:
-        if not st.session_state["videos"]:
-            st.info("Load a video first.", icon="ℹ️")
-
-    if generate_now and not st.session_state["busy"]:
-        api_key = st.session_state["api_key"] or os.getenv("GOOGLE_API_KEY")
-        if not st.session_state["videos"]:
-            st.error("No video loaded.")
-        elif not api_key:
-            st.error("Google API key missing.")
-        else:
-            try:
-                st.session_state["busy"] = True
-                genai.configure(api_key=api_key)
-                model_id = st.session_state["model_input"]
-                prompt = st.session_state["prompt"]
-
-                # ---- optional compression ----
-                with st.spinner("Checking video size…"):
-                    video_path, was_compressed = maybe_compress(
-                        st.session_state["videos"],
-                        st.session_state["compress_threshold_mb"],
-                    )
-
-                # ---- generation ----
-                with st.spinner("Generating analysis…"):
-                    raw_out = generate_inline(
-                        video_path,
-                        prompt,
-                        model_id,
-                        st.session_state["generation_timeout"],
-                    )
-
-                # clean up temporary compressed file
-                if was_compressed:
-                    try:
-                        os.remove(video_path)
-                    except OSError:
-                        pass
-
-                out = strip_prompt_echo(prompt, raw_out)
-                st.session_state["analysis_out"] = out
-                st.success("Analysis generated successfully.")
-                st.markdown(out or "No output.")
-            except Exception as exc:
-                tb = traceback.format_exc()
-                st.session_state["last_error"] = f"Generation error: {exc}"
-                st.error("An error occurred during generation.")
-                st.code(tb, language="text")
-            finally:
-                st.session_state["busy"] = False
-
-    # ---------- Results / errors ----------
-    if st.session_state["analysis_out"]:
-        st.subheader("📝 Analysis")
-        st.markdown(st.session_state["analysis_out"])
-
-    if st.session_state["last_error"]:
-        with st.expander("❗️ Error details"):
-            st.code(st.session_state["last_error"], language="text")
+# ---------- Generation ----------
+col1, col2 = st.columns([1, 3])
+with col1:
+    generate_now = st.button(
+        "Generate analysis", type="primary", disabled=st.session_state["busy"]
+    )
+with col2:
+    if not st.session_state["video_path"]:
+        st.info("Load a video first.", icon="ℹ️")
+
+if generate_now and not st.session_state["busy"]:
+    api_key = st.session_state["api_key"] or os.getenv("GOOGLE_API_KEY")
+    if not st.session_state["video_path"]:
+        st.error("No video loaded.")
+    elif not api_key:
+        st.error("Google API key missing.")
+    else:
+        try:
+            st.session_state["busy"] = True
+            genai.configure(api_key=api_key)
+
+            # ---- optional compression ----
+            with st.spinner("Checking video size…"):
+                video_path, was_compressed = _maybe_compress(
+                    Path(st.session_state["video_path"]),
+                    st.session_state["compress_mb"],
+                )
+
+            # ---- generation ----
+            with st.spinner("Generating analysis…"):
+                raw_out = generate_report(
+                    video_path,
+                    st.session_state["prompt"],
+                    st.session_state["model_input"],
+                    st.session_state.get("generation_timeout", 300),
+                )
+                # store the untouched response for debugging
+                st.session_state["raw_output"] = raw_out
+
+            # clean up temporary compressed file
+            if was_compressed:
+                try:
+                    video_path.unlink()
+                except OSError:
+                    pass
 
+            out = _strip_prompt_echo(st.session_state["prompt"], raw_out)
+            st.session_state["analysis_out"] = out
+            st.success("Analysis generated.")
+            st.markdown(out or "*(no output)*")
+        except Exception as exc:
+            tb = traceback.format_exc()
+            # keep both traceback and whatever raw output we might have
+            st.session_state["last_error_detail"] = f"{tb}\n\nRaw Gemini output:\n{st.session_state.get('raw_output','')}"
+            st.session_state["last_error"] = f"Generation error: {exc}"
+            st.error("An error occurred during generation.")
+        finally:
+            st.session_state["busy"] = False
+
+# ---------- Results ----------
+if st.session_state["analysis_out"]:
+    st.subheader("📝 Analysis")
+    st.markdown(st.session_state["analysis_out"])
+
+    # NEW – show full Gemini response
+    if st.session_state["raw_output"]:
+        with st.expander("🔎 Full Gemini output (debug)"):
+            st.code(st.session_state["raw_output"], language="text")
+
+    # ---------- Errors ----------
+if st.session_state["last_error"]:
+    with st.expander("❗️ Error details"):
+        # NEW – include raw output if present
+        st.code(st.session_state["last_error_detail"], language="text")
 
 if __name__ == "__main__":
     main()