Update streamlit_app.py

streamlit_app.py

@@ -3,6 +3,7 @@
 
 """
 Video‑analysis Streamlit app.
+
 Features
 --------
 * Download videos from direct links, Twitter, or any site supported by yt‑dlp.
@@ -11,6 +12,9 @@ Features
 * Simple sidebar UI with clear‑video handling.
 """
 
+# ----------------------------------------------------------------------
+# Standard library
+# ----------------------------------------------------------------------
 import base64
 import hashlib
 import os
@@ -18,17 +22,17 @@ import string
 import traceback
 from pathlib import Path
 from typing import List, Tuple, Optional
-from difflib import SequenceMatcher
 
+# ----------------------------------------------------------------------
+# Third‑party libraries
+# ----------------------------------------------------------------------
 import ffmpeg
 import google.generativeai as genai
 import requests
 import streamlit as st
 import yt_dlp
 
-# ----------------------------------------------------------------------
-# Optional dependency – Twitter scraper
-# ----------------------------------------------------------------------
+# Optional Twitter scraper – show a friendly error if missing
 try:
     import snscrape.modules.twitter as sntwitter
 except ImportError:  # pragma: no cover
@@ -60,21 +64,21 @@ DEFAULT_PROMPT = (
 )
 
 # ----------------------------------------------------------------------
-# Session‑state defaults
+# Session‑state defaults (run once per session)
 # ----------------------------------------------------------------------
 DEFAULT_STATE = {
     "url": "",
     "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", ""),
     "video_password": "",
     "compress_mb": 200,
     "busy": False,
     "last_error": "",
     "analysis_out": "",
-    "raw_output": "",          # full Gemini response before stripping
-    "last_error_detail": "",  # traceback + raw output for debugging    
+    "raw_output": "",
+    "last_error_detail": "",
     "show_raw_on_error": False,
 }
 for k, v in DEFAULT_STATE.items():
@@ -84,13 +88,13 @@ for k, v in DEFAULT_STATE.items():
 # Helper utilities
 # ----------------------------------------------------------------------
 def _sanitize_filename(url: str) -> str:
-    """Lower‑case, punctuation‑free filename derived from a URL."""
+    """Create a lower‑case, punctuation‑free filename from a URL."""
     name = Path(url).name.lower()
     return name.translate(str.maketrans("", "", string.punctuation)).replace(" ", "_")
 
 
 def _file_sha256(path: Path) -> Optional[str]:
-    """Return SHA‑256 hex digest or None on failure."""
+    """Return SHA‑256 hex digest of *path* or ``None`` on failure."""
     try:
         h = hashlib.sha256()
         with path.open("rb") as f:
@@ -113,6 +117,7 @@ def _convert_to_mp4(src: Path) -> Path:
     except ffmpeg.Error as e:
         raise RuntimeError(f"ffmpeg conversion failed: {e.stderr.decode()}") from e
 
+    # Remove original if conversion succeeded
     if dst.exists() and dst.stat().st_size > 0:
         src.unlink()
     return dst
@@ -131,7 +136,7 @@ def _compress_video(inp: Path, crf: int = 28, preset: str = "fast") -> Path:
 
 
 def _maybe_compress(path: Path, limit_mb: int) -> Tuple[Path, bool]:
-    """Compress *path* if larger than *limit_mb*."""
+    """Compress *path* if its size exceeds *limit_mb*."""
     size_mb = path.stat().st_size / (1024 * 1024)
     if size_mb <= limit_mb:
         return path, False
@@ -139,7 +144,7 @@ def _maybe_compress(path: Path, limit_mb: int) -> Tuple[Path, bool]:
 
 
 def _download_direct(url: str, dst: Path) -> Path:
-    """HTTP GET for a raw video file."""
+    """Download a raw video file via HTTP GET."""
     r = requests.get(url, stream=True, timeout=30)
     r.raise_for_status()
     out = dst / _sanitize_filename(url.split("/")[-1])
@@ -161,9 +166,7 @@ def _download_with_yt_dlp(url: str, dst: Path, password: str = "") -> Path:
         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
+        raise RuntimeError(f"yt‑dlp could not download the URL: {e}") from e
 
     # Predictable filename from yt‑dlp info dict
     if isinstance(info, dict) and "id" in info:
@@ -219,7 +222,7 @@ def generate_report(
     video_path: Path,
     prompt: str,
     model_id: str,
-    timeout: int,
+    timeout: int = 300,
 ) -> str:
     """Send video + prompt to Gemini and return the text response."""
     b64 = _encode_video_b64(video_path)
@@ -234,10 +237,11 @@ def generate_report(
     return getattr(resp, "text", str(resp))
 
 
-def _strip_prompt_echo(prompt: str, text: str, threshold: float = 0.68) -> str:
+def _strip_prompt_echo(prompt: str, text: str, threshold: float = 0
     """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])
 
@@ -250,19 +254,6 @@ def _strip_prompt_echo(prompt: str, text: str, threshold: float = 0.68) -> str:
 # ----------------------------------------------------------------------
 # Streamlit UI
 # ----------------------------------------------------------------------
-import os
-import traceback
-from pathlib import Path
-
-import streamlit as st
-import genai  # your Gemini wrapper
-
-# import your helpers:
-# download_video, _convert_to_mp4, _maybe_compress,
-# generate_report, _strip_prompt_echo, MODEL_OPTIONS,
-# DEFAULT_MODEL, DEFAULT_PROMPT, DATA_DIR
-
-
 def main() -> None:
     st.set_page_config(page_title="Video Analysis", layout="wide")
 
@@ -270,18 +261,16 @@ def main() -> None:
     st.sidebar.header("Video Input")
     st.sidebar.text_input("Video URL", key="url", placeholder="https://")
 
-    # ---- Load Video button (directly under the URL) ----
     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))   # always MP4
-            st.session_state["video_path"] = str(mp4_path)   # guaranteed MP4
+                mp4_path = _convert_to_mp4(Path(raw_path))
+            st.session_state["video_path"] = str(mp4_path)
             st.session_state["last_error"] = ""
             st.success("Video loaded successfully.")
-            # Force Streamlit to rerun so the preview appears immediately
             st.experimental_rerun()
         except Exception as e:
             st.session_state["last_error"] = f"Download failed: {e}"
@@ -302,18 +291,27 @@ def main() -> None:
             st.session_state["api_key"] = secret_key
         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_area(
+            "Analysis prompt",
+            value=DEFAULT_PROMPT,
+            key="prompt",
+            height=140,
+        )
+        st.text_input(
+            "Video password (if needed)",
+            key="video_password",
+            type="password",
+        )
         st.number_input(
             "Compress if > (MB)",
             min_value=10,
             max_value=2000,
-            value=st.session_state.get("compress_mb", 100),
+            value=st.session_state.get("compress_mb", 200),
             step=10,
             key="compress_mb",
         )
 
-    # ---------- Preview & clear (shown only when a video is loaded) ----------
+    # ---------- Preview & clear ----------
     if st.session_state.get("video_path"):
         try:
             mp4 = _convert_to_mp4(Path(st.session_state["video_path"]))
@@ -322,13 +320,11 @@ def main() -> None:
             st.sidebar.write("Preview unavailable")
 
         if st.sidebar.button("Clear Video"):
-            # delete every file in DATA_DIR (both raw and converted)
             for f in DATA_DIR.iterdir():
                 try:
                     f.unlink()
                 except Exception:
                     pass
-            # reset session state (including the URL field)
             st.session_state.update(
                 {
                     "url": "",
@@ -344,14 +340,12 @@ def main() -> None:
 
     # ---------- Generation ----------
     col1, col2 = st.columns([1, 3])
-
     with col1:
         generate_now = st.button(
             "Generate analysis",
             type="primary",
             disabled=st.session_state.get("busy", False),
         )
-
     with col2:
         if not st.session_state.get("video_path"):
             st.info("Load a video first.", icon="ℹ️")
@@ -367,14 +361,14 @@ def main() -> None:
                 st.session_state["busy"] = True
                 genai.configure(api_key=api_key)
 
-                # ---- optional compression ----
+                # 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 ----
+                # Generation
                 with st.spinner("Generating analysis…"):
                     raw_out = generate_report(
                         video_path,
@@ -384,17 +378,17 @@ def main() -> None:
                     )
                     st.session_state["raw_output"] = raw_out
 
-                # clean up temporary compressed file
+                # Clean up compressed temporary 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
+                cleaned = _strip_prompt_echo(st.session_state["prompt"], raw_out)
+                st.session_state["analysis_out"] = cleaned
                 st.success("Analysis generated.")
-                st.markdown(out or "*(no output)*")
+                st.markdown(cleaned or "*(no output)*")
 
             except Exception as exc:
                 tb = traceback.format_exc()
@@ -412,13 +406,12 @@ def main() -> None:
                 st.subheader("📝 Analysis")
                 st.markdown(st.session_state["analysis_out"])
 
-            # Full Gemini output – collapsed by default, expanded only on error
+            # Full Gemini output – collapsed by default, expanded on error
             if st.session_state.get("raw_output"):
                 if st.session_state.get("show_raw_on_error"):
                     st.subheader("🔎 Full Gemini output")
                     st.code(st.session_state["raw_output"], language="text")
                 else:
-                    # collapsed expander, starts closed
                     with st.expander("🔎 Full Gemini output (collapsed)"):
                         st.code(st.session_state["raw_output"], language="text")