Update streamlit_app.py

streamlit_app.py

@@ -1,24 +1,16 @@
 # 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)
+- Optional compression for files > compression_threshold_mb
 - 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 logging
-import google.generativeai as genai
-logger = logging.getLogger("video_ai")
-logger.info("genai attrs: %s", [k for k in dir(genai) if not k.startswith('_')])
-logger.info("has genai.responses: %s, has genai.Responses: %s, has NewClient: %s",
-            hasattr(genai, "responses"), hasattr(genai, "Responses"), hasattr(genai, "NewClient"))
+- Generate analysis via Responses API supporting multiple SDK versions and fallbacks
+- Minimal UI for model selection, prompts, timeouts, and status/progress reporting
 
+Requirements: see requirements.txt provided by user.
+"""
 import os
 import time
 import string
@@ -33,13 +25,15 @@ import yt_dlp
 import ffmpeg
 import streamlit as st
 from dotenv import load_dotenv
+from difflib import SequenceMatcher
 
-# Google GenAI SDK
+# Google GenAI SDK detection (support multiple SDK shapes)
 try:
-    import google.generativeai as genai
+    import google.generativeai as genai  # type: ignore
+    # Newer SDKs expose genai.responses; older/other expose different members
     genai_responses = getattr(genai, "responses", None) or getattr(genai, "Responses", None)
-    upload_file = getattr(genai, "upload_file", None)
-    get_file = getattr(genai, "get_file", None)
+    upload_file = getattr(genai, "upload_file", None) or getattr(genai, "upload_file", None)
+    get_file = getattr(genai, "get_file", None) or getattr(genai, "get_file", None)
     HAS_GENAI = True
 except Exception:
     genai = None
@@ -54,6 +48,13 @@ load_dotenv()
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("video_ai")
 
+logger.info("genai attrs: %s", sorted(dir(genai)) if genai is not None else "None")
+logger.info("has genai.responses: %s, has genai.Responses: %s, has upload_file: %s, has get_file: %s",
+            bool(getattr(genai, "responses", None)),
+            bool(getattr(genai, "Responses", None)),
+            bool(upload_file),
+            bool(get_file))
+
 # App config
 st.set_page_config(page_title="Generate the story of videos", layout="wide")
 DATA_DIR = Path("./data")
@@ -76,7 +77,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
+st.session_state.setdefault("compression_threshold_mb", 200)
 
 MODEL_OPTIONS = [
     "gemini-2.5-flash",
@@ -110,19 +111,12 @@ def convert_video_to_mp4(video_path: str) -> str:
     return target_path
 
 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:
         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)
+            stream = out.output(target_path, vcodec="libx264", preset=preset, video_bitrate=bitrate)
         else:
-            stream = out.output(target_path, **params)
+            stream = out.output(target_path, vcodec="libx264", crf=crf, preset=preset)
         stream.run(overwrite_output=True, quiet=True)
         if os.path.exists(target_path):
             return target_path
@@ -171,25 +165,19 @@ def configure_genai_if_needed():
         logger.exception("Failed to configure genai")
     return True
 
-# 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.
-    """
+# Upload & processing helpers
+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")
-    # 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)
     except Exception:
         pass
 
-    # call upload_file and return its result
     try:
         return upload_file(filepath)
     except Exception as e:
@@ -197,9 +185,6 @@ def upload_video_sdk(filepath: str, progress_callback=None):
         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:
@@ -302,7 +287,7 @@ def _normalize_genai_response(response):
             seen.add(t)
     return "\n\n".join(filtered).strip()
 
-# Generation via Responses API (supports modern and legacy patterns)
+# Generation via Responses API (modern + legacy fallbacks)
 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:
@@ -317,14 +302,14 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
 
     system_msg = {"role": "system", "content": prompt_text}
     user_msg = {"role": "user", "content": "Please summarize the attached video."}
-    call_variants = []
 
-    # 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}})
+    call_variants = []
+    # modern responses.generate
+    call_variants.append(("generate", {"model": model_used, "messages": [system_msg, user_msg], "files": [{"name": fname}], "max_output_tokens": max_tokens}))
+    # alternate modern shape
+    call_variants.append(("generate_alt", {"model": model_used, "input": [{"text": prompt_text, "files": [{"name": fname}]}], "max_output_tokens": max_tokens}))
+    # legacy create
+    call_variants.append(("legacy_create", {"model": model_used, "input": prompt_text, "file": fname, "max_output_tokens": max_tokens}))
 
     def is_transient_error(e_text: str):
         txt = str(e_text).lower()
@@ -335,25 +320,29 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
     backoff = 1.0
     attempts = 0
     while True:
-        for attempt_payload in call_variants:
+        for method_name, payload in call_variants:
             attempts += 1
-            method = attempt_payload["method"]
-            payload = attempt_payload["payload"]
             try:
                 if progress_callback:
-                    progress_callback("starting", int(time.time() - start), {"model": model_used, "attempt": attempts, "method": method})
+                    progress_callback("starting", int(time.time() - start), {"model": model_used, "attempt": attempts, "method": method_name})
+
+                # Preferred modern path: genai.responses.generate (or genai_responses.generate)
                 if genai_responses is not None and hasattr(genai_responses, "generate"):
-                    response = genai_responses.generate(**payload)
-                    text = _normalize_genai_response(response)
+                    resp = genai_responses.generate(**payload)
+                    text = _normalize_genai_response(resp)
                     if progress_callback:
-                        progress_callback("done", int(time.time() - start), {"model": model_used, "attempt": attempts, "method": method})
+                        progress_callback("done", int(time.time() - start), {"model": model_used, "attempt": attempts, "method": method_name})
                     return text
+
+                # Older path: genai.Responses.create
                 if hasattr(genai, "Responses") and hasattr(genai.Responses, "create"):
-                    response = genai.Responses.create(**payload)  # type: ignore
-                    text = _normalize_genai_response(response)
+                    resp = genai.Responses.create(**payload)  # type: ignore
+                    text = _normalize_genai_response(resp)
                     if progress_callback:
-                        progress_callback("done", int(time.time() - start), {"model": model_used, "attempt": attempts, "method": method})
+                        progress_callback("done", int(time.time() - start), {"model": model_used, "attempt": attempts, "method": method_name})
                     return text
+
+                # Fallback: GenerativeModel chat
                 if hasattr(genai, "GenerativeModel"):
                     try:
                         model_obj = genai.GenerativeModel(model_name=model_used)
@@ -366,18 +355,19 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
                                 progress_callback("done", int(time.time() - start), {"model": model_used, "attempt": attempts, "method": "GenerativeModel.chat"})
                             return text
                     except Exception:
-                        pass
+                        # ignore and try next variant/fallback
+                        logger.exception("GenerativeModel.chat fallback failed")
+
                 raise RuntimeError("No supported response generation method available in installed google-generativeai package.")
             except Exception as e:
                 last_exc = e
                 msg = str(e)
-                logger.warning("Responses.generate error (model=%s attempt=%s method=%s): %s", model_used, attempts, method, msg)
+                logger.warning("Responses.generate error (model=%s attempt=%s method=%s): %s", model_used, attempts, method_name, msg)
                 if not is_transient_error(msg):
-                    if "No supported response generation method" in msg or "has no attribute" in msg or "module 'google.generativeai' has no attribute" in msg:
+                    if "No supported response generation method" in msg or "has no attribute" in msg:
                         raise RuntimeError(
                             "Installed google-generativeai package does not expose a compatible Responses API. "
-                            "Please upgrade to a recent release or install the Google GenAI SDK. "
-                            "Run: pip install --upgrade google-generativeai"
+                            "Please upgrade to a recent release: pip install --upgrade google-generativeai"
                         ) from e
                     raise
                 if time.time() - start > timeout:
@@ -386,7 +376,6 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
                 backoff = min(backoff * 2, 8.0)
 
 # 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
@@ -406,10 +395,12 @@ def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_thres
             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
+    # clear per new URL
     st.session_state["videos"] = ""
     st.session_state["last_loaded_path"] = ""
     st.session_state["uploaded_file"] = None
@@ -453,7 +444,6 @@ settings_exp.number_input(
     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,
@@ -466,14 +456,6 @@ 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:
@@ -507,7 +489,6 @@ if st.session_state["videos"]:
         st.session_state["loop_video"] = loop_checkbox
 
         if st.button("Clear Video(s)"):
-            # minimal clear
             st.session_state["videos"] = ""
             st.session_state["last_loaded_path"] = ""
             st.session_state["uploaded_file"] = None
@@ -550,7 +531,7 @@ if generate_now and not st.session_state.get("busy"):
             try:
                 st.session_state["busy"] = True
                 try:
-                    if HAS_GENAI and genai is not None:
+                    if HAS_GENAI and genai is not None and hasattr(genai, "configure"):
                         genai.configure(api_key=key_to_use)
                 except Exception:
                     logger.exception("genai configure failed")
@@ -558,7 +539,6 @@ if generate_now and not st.session_state.get("busy"):
                 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"] = ""
-                # no phi agent creation per plan
 
                 processed = st.session_state.get("processed_file")
                 current_path = st.session_state.get("videos")
@@ -576,7 +556,6 @@ if generate_now and not st.session_state.get("busy"):
                         raise RuntimeError("google.generativeai SDK not available; install it.")
                     local_path = current_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:
@@ -586,7 +565,6 @@ if generate_now and not st.session_state.get("busy"):
                     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")
@@ -629,7 +607,6 @@ 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
 
-                # Generate via Responses API
                 try:
                     gen_progress_placeholder = st.empty()
                     gen_status = gen_progress_placeholder.text("Starting generation...")