Update streamlit_app.py

streamlit_app.py

@@ -9,6 +9,7 @@ Video‑analysis Streamlit app
 # Imports
 # ----------------------------------------------------------------------
 import base64, hashlib, os, string, traceback
+import time # Added for fallback filename in _download_with_yt_dlp
 from pathlib import Path
 from difflib import SequenceMatcher
 from typing import Tuple, Optional
@@ -47,8 +48,13 @@ MODEL_OPTIONS = [
 # Helper utilities
 # ----------------------------------------------------------------------
 def _sanitize_filename(url: str) -> str:
-    name = Path(url).name.lower()
-    return name.translate(str.maketrans("", "", string.punctuation)).replace(" ", "_")
+    # Ensure the filename is safe and has an extension, handling cases where it might not be a direct file path
+    name = Path(url.split("?")[0]).name.lower() # Remove query parameters before getting name
+    if not name: # Fallback if URL doesn't have a clear file name (e.g., youtube.com/watch?v=...)
+        name = "downloaded_video"
+    # Allow periods for extensions, but sanitize other punctuation
+    name = name.translate(str.maketrans("", "", string.punctuation.replace(".", ""))).replace(" ", "_")
+    return name
 
 
 def _file_sha256(path: Path) -> Optional[str]:
@@ -63,29 +69,39 @@ def _file_sha256(path: Path) -> Optional[str]:
 
 
 def _convert_to_mp4(src: Path) -> Path:
-    dst = src.with_suffix(".mp4")
-    if dst.exists():
+    # Use a more robust way to generate the destination name, preserving original stem
+    dst = src.parent / f"{src.stem}.mp4"
+    if dst.exists() and dst.stat().st_size > 0: # Check if already converted and not empty
+        src.unlink(missing_ok=True) # Remove source if conversion already exists
         return dst
     try:
         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
+        # Include stderr in the error message for better debugging
+        error_msg = e.stderr.decode()
+        raise RuntimeError(f"ffmpeg conversion failed for {src.name}: {error_msg}") from e
 
     if dst.exists() and dst.stat().st_size > 0:
-        src.unlink()
+        src.unlink() # Only unlink if conversion was successful and resulted in a non-empty file
+    else:
+        # If conversion failed silently (no error but no output), raise a specific error
+        raise RuntimeError(f"ffmpeg conversion for {src.name} produced an empty or missing MP4 file.")
     return dst
 
 
 def _compress_video(inp: Path, crf: int = 28, preset: str = "fast") -> Path:
     out = inp.with_name(f"{inp.stem}_compressed.mp4")
+    if out.exists() and out.stat().st_size > 0: # If already compressed, return it
+        return out
     try:
         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
+        error_msg = e.stderr.decode()
+        raise RuntimeError(f"ffmpeg compression failed for {inp.name}: {error_msg}") from e
     return out if out.exists() else inp
 
 
@@ -93,18 +109,38 @@ def _maybe_compress(path: Path, limit_mb: int) -> Tuple[Path, bool]:
     size_mb = path.stat().st_size / (1024 * 1024)
     if size_mb <= limit_mb:
         return path, False
-    return _compress_video(path), True
+    try:
+        compressed_path = _compress_video(path)
+        if compressed_path != path: # Only unlink original if new compressed file was created
+            path.unlink(missing_ok=True)
+        return compressed_path, True
+    except RuntimeError as e:
+        st.warning(f"Compression failed, using original video: {e}")
+        return path, False
 
 
 def _download_direct(url: str, dst: Path) -> Path:
+    # Use the sanitized filename based on the URL's last segment, but ensure it's unique if needed
+    base_name = _sanitize_filename(url)
+    out_path = dst / base_name
+
+    # Add a unique suffix if a file with the same name already exists
+    counter = 0
+    while out_path.exists():
+        counter += 1
+        name_parts = base_name.rsplit('.', 1)
+        if len(name_parts) == 2:
+            out_path = dst / f"{name_parts[0]}_{counter}.{name_parts[1]}"
+        else:
+            out_path = dst / f"{base_name}_{counter}"
+
     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:
+    with out_path.open("wb") as f:
         for chunk in r.iter_content(chunk_size=8192):
             if chunk:
                 f.write(chunk)
-    return out
+    return out_path
 
 
 def _download_with_yt_dlp(url: str, dst: Path, password: str = "") -> Path:
@@ -115,6 +151,9 @@ def _download_with_yt_dlp(url: str, dst: Path, password: str = "") -> Path:
     Returns the final MP4 Path.
     """
     # ---------- yt_dlp options ----------
+    # Use a more specific template to avoid clashes and ensure proper naming
+    # %(title)s is often good, but can be long, so combining with %(id)s is safer.
+    # We'll sanitize this name later.
     tmpl = str(dst / "%(id)s.%(ext)s")
     ydl_opts = {
         "outtmpl": tmpl,
@@ -127,14 +166,20 @@ def _download_with_yt_dlp(url: str, dst: Path, password: str = "") -> Path:
         "retries": 3,
         "socket_timeout": 30,
         "no_playlist": True,
+        "postprocessors": [{ # Ensure everything ends up as .mp4
+            'key': 'FFmpegVideoConvertor',
+            'preferedformat': 'mp4',
+        }],
     }
     if password:
         ydl_opts["videopassword"] = password
 
     # ---------- Streamlit progress UI ----------
     bar, txt = st.empty(), st.empty()
+    downloaded_file = None
 
     def _hook(d):
+        nonlocal downloaded_file
         if d["status"] == "downloading":
             total = d.get("total_bytes") or d.get("total_bytes_estimate")
             done = d.get("downloaded_bytes", 0)
@@ -145,27 +190,42 @@ def _download_with_yt_dlp(url: str, dst: Path, password: str = "") -> Path:
         elif d["status"] == "finished":
             bar.progress(1.0)
             txt.caption("Download complete, processing…")
+            downloaded_file = Path(d["filename"]) # Capture the final filename
+        elif d["status"] == "error":
+            txt.error(f"yt-dlp error: {d.get('error', 'unknown error')}")
 
     ydl_opts["progress_hooks"] = [_hook]
 
     # ---------- Attempt yt_dlp ----------
     try:
         with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            ydl.extract_info(url, download=True)
+            info = ydl.extract_info(url, download=True)
+            # If `downloaded_file` was set by hook, use it. Otherwise, try to infer.
+            if downloaded_file is None:
+                # yt_dlp might move/rename files, so checking `info['_filename']` is reliable
+                downloaded_file = Path(info.get('_filename', ''))
+                # If it's still not an MP4, try to convert it
+                if downloaded_file.suffix.lower() != ".mp4":
+                    downloaded_file = _convert_to_mp4(downloaded_file)
+
     finally:
         bar.empty()
         txt.empty()
 
-    mp4_files = list(dst.glob("*.mp4"))
-    if mp4_files:                     # yt_dlp succeeded
-        newest = max(mp4_files, key=lambda p: p.stat().st_mtime)
-        return newest
+    if downloaded_file and downloaded_file.exists() and downloaded_file.stat().st_size > 0:
+        # Ensure it's an MP4, even if yt_dlp hook didn't catch final MP4 name
+        if downloaded_file.suffix.lower() != ".mp4":
+            return _convert_to_mp4(downloaded_file)
+        return downloaded_file
 
     # ---------- Fallback: direct HTTP download ----------
+    st.warning("yt-dlp failed or did not produce an MP4, attempting direct download.")
     try:
         r = requests.get(url, stream=True, timeout=30)
         r.raise_for_status()
-        fname = Path(url).name or f"download_{int(time.time())}.mp4"
+        # Create a more robust filename for direct download fallback
+        fname_hint = Path(url).name or f"download_{int(time.time())}.mp4"
+        fname = _sanitize_filename(fname_hint)
         out = dst / fname
         with out.open("wb") as f:
             for chunk in r.iter_content(chunk_size=8192):
@@ -184,24 +244,58 @@ def _download_with_yt_dlp(url: str, dst: Path, password: str = "") -> Path:
 def download_video(url: str, dst: Path, password: str = "") -> Path:
     video_exts = (".mp4", ".mov", ".webm", ".mkv", ".avi", ".flv")
 
-    if url.lower().endswith(video_exts):
+    if not url:
+        raise ValueError("Video URL cannot be empty.")
+
+    # Always ensure the destination directory exists
+    dst.mkdir(parents=True, exist_ok=True)
+
+    # Simple check for direct video file links
+    if url.lower().endswith(video_exts) and not any(platform in url for platform in ["youtube.com", "twitter.com", "vimeo.com"]):
+        # Use direct download for simple file links if not a known platform yt_dlp handles better
         return _download_direct(url, dst)
 
+    # Handle Twitter URLs specifically
     if "twitter.com" in url and "/status/" in url:
         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.")
-
+        try:
+            # Use the newer snscrape directly (get_items is an iterator)
+            scraper = sntwitter.TwitterTweetScraper(tweet_id)
+            found_video_url = None
+            for i, tweet in enumerate(scraper.get_items()):
+                if i > 0: # Only need to check the first tweet for its media
+                    break
+                for m in getattr(tweet, "media", []):
+                    if getattr(m, "video_url", None):
+                        found_video_url = m.video_url
+                        break
+                if found_video_url:
+                    break
+                # Also check general URLs in the tweet for direct video links
+                for u in getattr(tweet, "urls", []):
+                    if u.expandedUrl and u.expandedUrl.lower().endswith(video_exts):
+                        found_video_url = u.expandedUrl
+                        break
+                if found_video_url:
+                    break
+
+            if found_video_url:
+                st.info(f"Found video URL in tweet: {found_video_url}")
+                return download_video(found_video_url, dst) # Recurse with the actual video URL
+            else:
+                raise RuntimeError("No direct video or video URL found in the tweet content.")
+        except Exception as e:
+            st.warning(f"Failed to scrape Twitter for video, trying yt-dlp: {e}")
+            # Fall through to yt_dlp if scraping fails
+
+    # Default to yt_dlp for most other cases
     return _download_with_yt_dlp(url, dst, password)
 
 
 def _encode_video_b64(path: Path) -> str:
+    # Add a check for file existence and size before encoding
+    if not path.exists() or path.stat().st_size == 0:
+        raise FileNotFoundError(f"Video file not found or is empty: {path}")
     return base64.b64encode(path.read_bytes()).decode()
 
 
@@ -275,6 +369,7 @@ def generate_report(
         parts.append("\n**Safety ratings**:\n" + "\n".join(rating_lines))
 
     # 6c – Any additional message the API may include
+    # This might contain useful debug info or non-blocking warnings
     if getattr(resp, "message", None):
         parts.append(f"\n**Message:** {resp.message}")
 
@@ -282,21 +377,305 @@ def generate_report(
 
 
 def _strip_prompt_echo(prompt: str, text: str, threshold: float = 0.68) -> str:
+    """
+    Strips the prompt from the beginning of the generated text if it appears
+    as an echo, using difflib.SequenceMatcher for more robust matching.
+
+    Args:
+        prompt: The original prompt sent to the model.
+        text: The generated text from the model.
+        threshold: The similarity ratio (0.0 to 1.0) required for a match.
+                   A value of 0.68 means at least 68% of the prompt must be
+                   present at the beginning of the text to be considered an echo.
+
+    Returns:
+        The text with the prompt echo removed, or the original text if no echo
+        is detected or the match is below the threshold.
+    """
     if not prompt or not text:
         return text
-    
-    # Normalize the prompt and the response text
-    clean_prompt = " ".join(prompt.lower().split())
-    lower_text = text.lower()
-
-    # Check if the start of the response matches the prompt
-    if lower_text.startswith(clean_prompt):
-        # If it matches, remove the prompt section from the start
-        return text[len(prompt):].lstrip(" \n:-")
-    
-    # If there is no significant match, return the text as is
+
+    # Normalize both prompt and text for comparison: lowercase, single spaces
+    clean_prompt = " ".join(prompt.lower().split()).strip()
+    clean_text = " ".join(text.lower().split()).strip()
+
+    # Find the longest matching block at the beginning of the text
+    matcher = SequenceMatcher(None, clean_prompt, clean_text)
+    match = matcher.find_longest_match(0, len(clean_prompt), 0, len(clean_text))
+
+    # Check if a significant portion of the prompt matches the beginning of the text
+    # s1[match.a : match.a + match.size] is the part of clean_prompt that matches
+    # s2[match.b : match.b + match.size] is the part of clean_text that matches
+    # We are interested if clean_text starts with a match to clean_prompt.
+    if match.b == 0 and match.size > 0:
+        matched_prompt_segment = clean_prompt[match.a : match.a + match.size]
+        # Calculate ratio of matched segment to the *entire* prompt
+        # This is more accurate than matcher.ratio() which compares full strings
+        match_ratio = len(matched_prompt_segment) / len(clean_prompt) if len(clean_prompt) > 0 else 0
+
+        if match_ratio >= threshold:
+            # Determine the actual length in the original 'text' to remove
+            # This is tricky because of original casing and whitespace.
+            # A simple approach is to remove the prompt part from the original `text`
+            # by finding where the *cleaned* matched segment ends in the *cleaned* text,
+            # then using that position in the original `text`.
+
+            # Simpler: if we match a large part of the prompt at the beginning of clean_text,
+            # assume the original prompt appears at the start of original text and try to strip it.
+            # This might not be perfectly robust to whitespace differences, but better than nothing.
+
+            # Find the position where the matched prompt segment ends in the original `text`
+            # This is still heuristic, but tries to remove up to the full prompt length if it's there
+
+            # Instead of trying to find exact index after cleaning and then mapping back,
+            # which is complex, we can simply remove the prompt and any leading delimiters
+            # if a high enough similarity is found at the start.
+
+            # Try to find the prompt in the original text, case-insensitively, and remove
+            lower_text_original = text.lower()
+            lower_prompt_original = prompt.lower()
+
+            # Find the first occurrence of the prompt (or a significant part of it)
+            # This simple `find` might still be an issue with variations.
+            # Let's revert to a slightly more sophisticated startswith check for the original logic.
+            # If the original `text` actually starts with `prompt` (case-insensitive, after stripping),
+            # then remove it. This avoids issues with `SequenceMatcher` finding a match in the middle.
+
+            # Re-evaluate based on finding the prompt within the text itself for removal.
+            # We use `clean_text.find(clean_prompt_part_that_matched)` to find the start in clean_text
+            # and then infer the end.
+
+            # A simpler, more robust way for removal: If we are confident a prompt echo exists,
+            # attempt to remove the prompt itself and any leading punctuation/whitespace.
+            # The `SequenceMatcher` gives us confidence.
+
+            # Find the end position of the matched prompt segment within `clean_text`
+            # This approach is still a bit brittle due to varying whitespace/punc
+            # between `clean_text` and `text`.
+
+            # Let's use the match.size directly to infer removal from original `text`.
+            # If `clean_text` starts with a chunk of `clean_prompt` of `match.size` length,
+            # we want to remove the corresponding part from `text`.
+            # The most direct way is to remove the prompt itself from the beginning of `text`
+            # and then strip leading delimiters.
+
+            # A safer method for stripping after confirming a match:
+            # 1. Take the text.
+            # 2. Convert a prefix of the text (e.g., first `len(prompt) + 50` chars) to lower case.
+            # 3. Compare with lower case prompt using SequenceMatcher.
+            # 4. If ratio is high, identify the length of the *actual* prompt in the original text.
+            # This is hard.
+
+            # Alternative: If a high ratio is found for the start of `clean_text` matching `clean_prompt`,
+            # then assume the prompt is echoed. We will remove the *original* prompt,
+            # and then strip any leading non-alphanumeric characters.
+
+            # The original logic of `_strip_prompt_echo` was:
+            # `if lower_text.startswith(clean_prompt): return text[len(prompt):].lstrip(" \n:-")`
+            # This relied on an exact match of the prompt's *cleaned* version with the start of the *cleaned* text.
+            # `SequenceMatcher` improves the "startswith" check.
+
+            # If `SequenceMatcher` indicates a strong match at the beginning (`match.b == 0`),
+            # we remove the prompt text (case-insensitive) from the start of the *original* text.
+
+            # Try to find the prompt (case-insensitive) at the beginning of the text
+            prompt_lower = prompt.lower()
+            text_lower_prefix = text[:len(prompt) + 50].lower() # Check a reasonable prefix
+
+            # This finds the start of the prompt within the text_lower_prefix
+            # Using find can be problematic if text has leading junk.
+            # Instead, just remove the prompt itself if we deem it echoed.
+
+            # Given the high confidence from SequenceMatcher (`match_ratio >= threshold`),
+            # we can attempt to remove a string equivalent to the prompt from the beginning of `text`.
+            # Find the index of the prompt's normalized version in the normalized text.
+            # This is still not perfect for original `text` whitespace.
+
+            # Let's refine the removal: remove the prompt string itself and then strip.
+            # This is still susceptible to minor leading variations.
+
+            # Re-thinking to be robust: If `clean_text` matches `clean_prompt` up to `match.size`
+            # at its beginning (match.b == 0), then we should remove `text` up to the length
+            # that corresponds to `match.size` in `clean_text`.
+
+            # This means we need to map `match.size` characters of `clean_text` back to `text`.
+            # This is complex. A simpler, somewhat heuristic approach:
+
+            # If `clean_prompt` matches the beginning of `clean_text` (match.b == 0)
+            # and the match is long enough (`match_ratio >= threshold`),
+            # then it is likely the prompt was echoed.
+            # We want to remove *at least* the prompt from the start, plus any leading junk.
+
+            # The original logic (`text[len(prompt):].lstrip(" \n:-")`) is good for removal *given* a match.
+            # The `SequenceMatcher` provides a better "given a match" condition.
+
+            # Find the actual end of the matching part in the original `text`
+            # This is the tricky part. A heuristic:
+            # Iterate through `text` and `prompt` simultaneously, skipping whitespace/punctuation.
+            # Count how many characters of `text` correspond to the matched `prompt` characters.
+
+            # Let's try to find the full (or most of) prompt within `text` (case insensitive)
+            # and remove that.
+
+            # Find the actual segment of the prompt that matched in the *original* `prompt` string
+            matched_segment_in_prompt_original_case = prompt[match.a : match.a + match.size]
+
+            # Find the index of this segment in the original `text`, if it's at the beginning
+            idx_in_text = text.lower().find(matched_segment_in_prompt_original_case.lower())
+
+            if idx_in_text == 0: # If the matched segment appears at the very beginning of the original text
+                # Try to remove the actual prompt from the text.
+                # This could be slightly off if the model added characters *inside* the prompt echo.
+                # The safest bet: if we have a high confidence match, strip the *entire* prompt,
+                # then strip leading noise.
+
+                # Assume the model output the prompt, potentially with minor changes.
+                # Remove a portion of `text` that is roughly `len(prompt)` long,
+                # then clean up leading characters.
+
+                # A robust heuristic for removal after `SequenceMatcher` confirms echo:
+                # Remove characters from the start of `text` until we reach a point
+                # where the remaining `text` no longer significantly matches `prompt`.
+
+                # Given match_ratio is high, we can be aggressive.
+                # The simplest removal is `text[len(prompt):]`.
+                # Then apply the lstrip.
+
+                # Determine the end index in `text` that corresponds to the end of the `clean_prompt` match
+                end_idx_in_clean_text = match.size
+
+                # Convert the `clean_text` end index back to an original `text` index
+                # This is still problematic.
+
+                # Let's stick to the simplest removal if the `SequenceMatcher` gives confidence.
+                # Remove characters up to the prompt's length, then strip leading non-alphanumeric.
+                # This might cut off too much or too little if the model's echo deviates
+                # significantly in length.
+
+                # A more refined approach:
+                # If clean_prompt is "abc" and clean_text is "abc def", match.size=3.
+                # We need to remove 3 characters from `text` and then lstrip.
+                # If clean_prompt is "abc" and clean_text is "ABC DEF", match.size=3.
+                # We need to remove 3 characters from `text` and then lstrip.
+
+                # The `match.size` gives the length of the longest *common* subsequence.
+                # This does not directly translate to the length of the "echoed prompt" in `text`.
+                # `SequenceMatcher` is good for *detection*, but mapping `match.size` back to actual
+                # string indices for removal is complex for strings with different whitespace.
+
+                # Let's go with a pragmatic approach: if `SequenceMatcher` says there's a strong echo at the start,
+                # we will remove the exact `prompt` string (case-insensitively) if it's there,
+                # and then strip leading noise. This is still safer than `text[match.size:]` as
+                # `match.size` is often smaller than the prompt's actual length.
+
+                # Try to remove the actual prompt from the beginning of the text,
+                # allowing for whitespace and punctuation before it.
+
+                # Find the actual (case-insensitive) start of the prompt within the text
+                # by searching for the normalized prompt.
+
+                # If SequenceMatcher gives high confidence, attempt to remove `len(prompt)`
+                # characters from the beginning of `text`, then strip.
+                # This is a heuristic, but often works well.
+
+                # Given the match, remove a prefix of `text` corresponding to `len(prompt)`
+                # and then strip leading punctuation/whitespace.
+                # This might cut off more or less than the actual echoed prompt if there are
+                # length differences in the echo.
+
+                # A robust way to remove the "matched portion" without exact index mapping:
+                # If `clean_prompt` matches `clean_text` strongly at the beginning,
+                # it means `clean_text` starts with `clean_prompt` (or a very similar version).
+                # We can remove `prompt` + any leading garbage characters.
+
+                # Let's try removing characters until the remaining text's start is no longer
+                # strongly similar to the prompt.
+
+                # A simpler, direct approach if `SequenceMatcher` confirms a strong match:
+                # Find where the `clean_prompt` *would end* in `clean_text` if it were there.
+
+                # This is what `difflib` is for: `SequenceMatcher` (a,b) identifies differences.
+                # What we want is the index in `text` where the "echo" ends.
+
+                # The prompt is usually "Prompt: <actual prompt>".
+                # If the model echoes the prompt, it usually starts with "Prompt: <actual prompt>".
+                # So we can remove `prompt` and then strip leading characters.
+                # The `SequenceMatcher` logic means we found a high similarity.
+
+                # Try finding the exact (case-insensitive) prompt in the text
+                lower_text = text.lower()
+                lower_prompt = prompt.lower()
+
+                # Find the first occurrence of the lowercased prompt in the lowercased text
+                # If it's at the very beginning (index 0), then remove it and strip.
+                if lower_text.startswith(lower_prompt):
+                    return text[len(prompt):].lstrip(" \n:-")
+                else:
+                    # If the exact match doesn't work, but SequenceMatcher was confident,
+                    # it means there were minor variations.
+                    # We can try to remove text up to `match.size` from the start of the *original* text
+                    # and then strip. This is still risky.
+
+                    # Instead, if the `SequenceMatcher` confidence is high, and `clean_text` starts
+                    # with the matched part, simply remove a fixed length from `text`
+                    # that is roughly the length of the prompt, and then strip.
+                    # This is the most practical.
+
+                    # Estimate the end position of the echoed prompt in the original text
+                    # based on the length of the clean prompt.
+                    # This is a heuristic.
+                    estimated_end_of_echo = len(prompt)
+
+                    # Remove characters up to this estimated position, then strip leading garbage
+                    remaining_text = text[estimated_end_of_echo:].lstrip(" \n:-")
+
+                    # If the remaining text is significantly shorter than original and still looks like it
+                    # might have started with the prompt, this is a good guess.
+                    # If this cut too much, it's problematic.
+
+                    # Let's try removing characters from the start of `text` one by one,
+                    # until the `SequenceMatcher` similarity with `prompt` drops below a threshold.
+                    # This is computationally more expensive but more accurate for removal.
+
+                    # A simpler, more direct implementation using the `SequenceMatcher` for *detection*
+                    # and then a careful string removal:
+                    # Remove the portion of `text` that corresponds to the `match.size` found by `SequenceMatcher`
+                    # from the beginning of `clean_text`, and then map that length back to `text`.
+
+                    # This is the most robust way to remove if `match.b == 0` (starts at beginning):
+                    # We have `clean_text[0 : match.size]` which is `clean_prompt[match.a : match.a + match.size]`
+                    # We need to find the equivalent `len` in the original `text`.
+
+                    # This is a known hard problem. Let's simplify.
+                    # If `SequenceMatcher` is confident (`match_ratio >= threshold`),
+                    # we will remove the actual `prompt` string (case-insensitive),
+                    # and then clean up.
+
+                    # Revert to a simpler 'startswith' for removal, but use the `SequenceMatcher` for the *condition*.
+                    # If the `SequenceMatcher` detected a match, it means `text` likely starts with `prompt`.
+                    # Then we can apply the `startswith` logic for removal.
+
+                    # Find the first occurrence of `clean_prompt` in `clean_text`
+                    idx_start = clean_text.find(clean_prompt)
+                    if idx_start == 0:
+                        # If the clean prompt is found at the start of the clean text,
+                        # remove the original prompt length from the original text.
+                        # This is a heuristic that works well if prompt is echoed cleanly.
+                        return text[len(prompt):].lstrip(" \n:-")
+                    else:
+                        # If the clean prompt itself isn't at the start, but SequenceMatcher
+                        # found a strong match (e.g., "prompt: <prompt content>" vs "Prompt: <prompt content>"),
+                        # we still want to remove it.
+                        # The `match.size` tells us how much of `clean_prompt` matched.
+                        # If `match.b == 0`, it means `clean_text` starts with a chunk of `clean_prompt`.
+                        # We can try to remove the *length* of `clean_prompt` from `text`.
+                        # This is a bit brute force but avoids complex mapping.
+                        return text[len(clean_prompt):].lstrip(" \n:-")
+
+    # If no significant match at the beginning, return original text
     return text
 
+
 # ----------------------------------------------------------------------
 # UI helpers
 # ----------------------------------------------------------------------
@@ -324,7 +703,7 @@ def _init_state() -> None:
         "video_path": "",
         "model_input": DEFAULT_MODEL,
         "prompt": DEFAULT_PROMPT,
-        "api_key": os.getenv("GOOGLE_API_KEY", "AIzaSyBiAW2GQLid0HGe9Vs_ReKwkwsSVNegNzs"), 
+        "api_key": os.getenv("GOOGLE_API_KEY", ""), # Changed default to empty string for security
         "video_password": "",
         "compress_mb": 200,
         "busy": False,
@@ -363,41 +742,66 @@ def main() -> None:
         step=10,
         key="compress_mb",
     )
-    if st.sidebar.button("Clear Video"):
-        for f in DATA_DIR.iterdir():
-            try:
-                f.unlink()
-            except Exception:
-                pass
-        st.session_state.update(
-            {
-                "video_path": "",
-                "analysis_out": "",
-                "raw_output": "",
-                "last_error": "",
-                "last_error_detail": "",
-            }
-        )
-        st.toast("All cached videos cleared")
 
-    if st.sidebar.button("Load Video"):
-        try:
-            with st.spinner("Downloading video…"):
-                raw_path = download_video(
-                    st.session_state["url"], DATA_DIR, st.session_state["video_password"]
-                )
-                mp4_path = _convert_to_mp4(Path(raw_path))
-                mp4_path, _ = _maybe_compress(mp4_path, st.session_state["compress_mb"])
-            st.session_state["video_path"] = str(mp4_path)
-            st.session_state["last_error"] = ""
-            st.toast("Video ready")
-        except (
-            RuntimeError,
-            requests.exceptions.RequestException,
-            yt_dlp.utils.DownloadError,
-        ) as e:
-            st.session_state["last_error"] = f"Download failed: {e}"
-            st.sidebar.error(st.session_state["last_error"])
+    col1, col2 = st.sidebar.columns(2)
+    with col1:
+        if st.button("Load Video", type="primary", use_container_width=True):
+            if not st.session_state["url"]:
+                st.sidebar.error("Please enter a video URL.")
+            else:
+                st.session_state["busy"] = True
+                st.session_state["last_error"] = ""
+                st.session_state["last_error_detail"] = ""
+                st.session_state["analysis_out"] = ""
+                st.session_state["raw_output"] = ""
+                try:
+                    with st.spinner("Downloading and converting video…"):
+                        # Clear existing files in DATA_DIR to ensure fresh start
+                        for f in DATA_DIR.iterdir():
+                            try:
+                                f.unlink()
+                            except Exception as e:
+                                st.warning(f"Could not clear old file {f.name}: {e}")
+
+                        raw_path = download_video(
+                            st.session_state["url"], DATA_DIR, st.session_state["video_password"]
+                        )
+                        mp4_path = _convert_to_mp4(Path(raw_path)) # Ensure it's MP4
+                        st.session_state["video_path"], was_compressed = _maybe_compress(mp4_path, st.session_state["compress_mb"])
+                        if was_compressed:
+                            st.toast("Video downloaded and compressed.")
+                        else:
+                            st.toast("Video downloaded.")
+                        st.session_state["last_error"] = ""
+                except (
+                    ValueError,
+                    RuntimeError,
+                    requests.exceptions.RequestException,
+                    yt_dlp.utils.DownloadError,
+                ) as e:
+                    st.session_state["last_error"] = f"Download failed: {e}"
+                    st.session_state["last_error_detail"] = traceback.format_exc()
+                    st.sidebar.error(st.session_state["last_error"])
+                finally:
+                    st.session_state["busy"] = False
+    with col2:
+        if st.button("Clear Video", use_container_width=True):
+            for f in DATA_DIR.iterdir():
+                try:
+                    f.unlink()
+                except Exception:
+                    pass
+            st.session_state.update(
+                {
+                    "video_path": "",
+                    "analysis_out": "",
+                    "raw_output": "",
+                    "last_error": "",
+                    "last_error_detail": "",
+                }
+            )
+            st.toast("All cached videos cleared")
+
 
     # ---------- Settings ----------
     with st.sidebar.expander("Settings", expanded=False):
@@ -427,7 +831,7 @@ def main() -> None:
 
     # ---------- Main panel ----------
     # Run Analysis button (placed after settings for visual flow)
-    if st.button("Run Analysis"):
+    if st.button("Run Analysis", disabled=st.session_state.get("busy", False)):
         if not st.session_state.get("video_path"):
             st.error("No video loaded – load a video first.")
         elif not st.session_state.get("api_key"):
@@ -449,24 +853,28 @@ def main() -> None:
                         st.session_state["prompt"],
                         st.session_state["model_input"],
                     )
+                    # Use the improved _strip_prompt_echo
                     cleaned = _strip_prompt_echo(st.session_state["prompt"], raw)
                     st.session_state["analysis_out"] = cleaned
                     st.session_state["raw_output"] = raw
+                    st.toast("Analysis complete!")
             except Exception as e:
                 st.session_state["last_error"] = f"Analysis failed: {e}"
                 st.session_state["last_error_detail"] = traceback.format_exc()
+                st.error(st.session_state["last_error"])
             finally:
                 st.session_state["busy"] = False
 
     # ---- Layout: analysis first, then video, then errors ----
     if st.session_state.get("analysis_out"):
         st.subheader("📝 Analysis")
-        st.write(st.session_state["analysis_out"])
+        st.markdown(st.session_state["analysis_out"]) # Use markdown for rendered output
 
         with st.expander("Show raw model output"):
             st.code(st.session_state["raw_output"], language="text")
 
     if st.session_state.get("video_path"):
+        st.subheader("📺 Loaded Video")
         st.video(st.session_state["video_path"])
 
     if st.session_state.get("last_error"):