Update streamlit_app.py

streamlit_app.py

@@ -1,16 +1,4 @@
 # streamlit_app.py
-"""
-Streamlit app for video captioning / analysis using Google GenAI Responses API.
-
-Features:
-- Download video via yt-dlp
-- 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 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
@@ -27,13 +15,12 @@ import streamlit as st
 from dotenv import load_dotenv
 from difflib import SequenceMatcher
 
-# Google GenAI SDK detection (support multiple SDK shapes)
+# Try import google.generativeai, support multiple SDK shapes
 try:
     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) or getattr(genai, "upload_file", None)
-    get_file = getattr(genai, "get_file", None) or getattr(genai, "get_file", None)
+    upload_file = getattr(genai, "upload_file", None)
+    get_file = getattr(genai, "get_file", None)
     HAS_GENAI = True
 except Exception:
     genai = None
@@ -44,16 +31,10 @@ except Exception:
 
 load_dotenv()
 
-# Logging
+# Logging (minimal)
 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))
+logger.propagate = False
 
 # App config
 st.set_page_config(page_title="Generate the story of videos", layout="wide")
@@ -72,11 +53,10 @@ st.session_state.setdefault("last_error", "")
 st.session_state.setdefault("file_hash", None)
 st.session_state.setdefault("api_key", os.getenv("GOOGLE_API_KEY", ""))
 st.session_state.setdefault("last_model", "")
-st.session_state.setdefault("upload_progress", {"uploaded": 0, "total": 0})
 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("preferred_model", "gemini-2.0-flash-lite")
 st.session_state.setdefault("compression_threshold_mb", 200)
 
 MODEL_OPTIONS = [
@@ -118,9 +98,7 @@ def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str
         else:
             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
-        return input_path
+        return target_path if os.path.exists(target_path) else input_path
     except Exception:
         logger.exception("Compression failed")
         return input_path
@@ -165,7 +143,7 @@ def configure_genai_if_needed():
         logger.exception("Failed to configure genai")
     return True
 
-# Upload & processing helpers
+# Upload & processing
 def upload_video_sdk(filepath: str):
     key = get_effective_api_key()
     if not key:
@@ -177,10 +155,9 @@ def upload_video_sdk(filepath: str):
             genai.configure(api_key=key)
     except Exception:
         pass
-
     try:
         return upload_file(filepath)
-    except Exception as e:
+    except Exception:
         logger.exception("Upload failed")
         raise
 
@@ -222,7 +199,7 @@ def wait_for_processed(file_obj, timeout: int = None, progress_callback=None):
         time.sleep(backoff)
         backoff = min(backoff * 2, 8.0)
 
-# Response normalization
+# Normalize responses into text
 def _normalize_genai_response(response):
     if response is None:
         return ""
@@ -287,7 +264,7 @@ def _normalize_genai_response(response):
             seen.add(t)
     return "\n\n".join(filtered).strip()
 
-# Generation via Responses API (modern + legacy fallbacks)
+# Generation (supports various SDK shapes)
 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:
@@ -303,13 +280,11 @@ 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 = []
-    # 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}))
+    call_variants = [
+        ("responses.generate", {"model": model_used, "messages": [system_msg, user_msg], "files": [{"name": fname}], "max_output_tokens": max_tokens}),
+        ("responses.generate_alt", {"model": model_used, "input": [{"text": prompt_text, "files": [{"name": fname}]}], "max_output_tokens": max_tokens}),
+        ("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()
@@ -326,12 +301,12 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
                 if progress_callback:
                     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)
+                # Preferred modern: genai.responses.generate or genai_responses.generate
                 if genai_responses is not None and hasattr(genai_responses, "generate"):
                     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_name})
+                        progress_callback("done", int(time.time() - start), {"method": method_name})
                     return text
 
                 # Older path: genai.Responses.create
@@ -339,30 +314,36 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
                     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_name})
+                        progress_callback("done", int(time.time() - start), {"method": method_name})
                     return text
 
-                # Fallback: GenerativeModel chat
+                # Fallback: GenerativeModel API (ChatSession). This SDK's ChatSession.send_message may not accept timeout kw.
                 if hasattr(genai, "GenerativeModel"):
                     try:
                         model_obj = genai.GenerativeModel(model_name=model_used)
                         if hasattr(model_obj, "start_chat"):
                             chat = model_obj.start_chat()
-                            resp = chat.send_message(prompt_text, timeout=timeout)
+                            # Some SDKs' send_message signature differs; call without timeout kw when necessary.
+                            send = getattr(chat, "send_message", None)
+                            if send is None:
+                                raise RuntimeError("ChatSession has no send_message")
+                            try:
+                                resp = send(prompt_text, timeout=timeout)  # try with timeout
+                            except TypeError:
+                                resp = send(prompt_text)  # fallback without timeout
                             text = getattr(resp, "text", None) or str(resp)
                             text = text if text else _normalize_genai_response(resp)
                             if progress_callback:
-                                progress_callback("done", int(time.time() - start), {"model": model_used, "attempt": attempts, "method": "GenerativeModel.chat"})
+                                progress_callback("done", int(time.time() - start), {"method": "GenerativeModel.chat"})
                             return text
                     except Exception:
-                        # 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_name, msg)
+                logger.warning("Generation 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:
                         raise RuntimeError(
@@ -375,7 +356,7 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
                 time.sleep(backoff)
                 backoff = min(backoff * 2, 8.0)
 
-# Prompt echo removal
+# Trim prompt echoes
 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
@@ -395,12 +376,9 @@ def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_thres
             return b_full[len(ph):].lstrip(" \n:-")
     return text
 
-# -----------------------
-# UI
-# -----------------------
+# UI: reset per new URL value
 current_url = st.session_state.get("url", "")
 if current_url != st.session_state.get("last_url_value"):
-    # clear per new URL
     st.session_state["videos"] = ""
     st.session_state["last_loaded_path"] = ""
     st.session_state["uploaded_file"] = None
@@ -419,10 +397,10 @@ st.sidebar.header("Video Input")
 st.sidebar.text_input("Video URL", key="url", placeholder="https://")
 
 settings_exp = st.sidebar.expander("Settings", expanded=False)
-chosen = settings_exp.selectbox("Gemini model", MODEL_OPTIONS, index=MODEL_OPTIONS.index(st.session_state.get("preferred_model", "gemini-2.5-flash-lite")))
+chosen = settings_exp.selectbox("Gemini model", MODEL_OPTIONS, index=MODEL_OPTIONS.index(st.session_state.get("preferred_model", "gemini-2.0-flash-lite")))
 custom_model = ""
 if chosen == "custom":
-    custom_model = settings_exp.text_input("Custom model name", value=st.session_state.get("preferred_model", "gemini-2.5-flash-lite"))
+    custom_model = settings_exp.text_input("Custom model name", value=st.session_state.get("preferred_model", "gemini-2.0-flash-lite"))
 model_input_value = (custom_model.strip() if chosen == "custom" else chosen).strip()
 
 settings_exp.text_input("Google API Key", key="api_key", value=os.getenv("GOOGLE_API_KEY", ""), type="password")
@@ -456,7 +434,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="⚠️")
 
-# Buttons / UI layout
 col1, col2 = st.columns([1, 3])
 with col1:
     generate_now = st.button("Generate the story", type="primary", disabled=not bool(get_effective_api_key()))
@@ -536,7 +513,7 @@ if generate_now and not st.session_state.get("busy"):
                 except Exception:
                     logger.exception("genai configure failed")
 
-                model_id = model_input_value or st.session_state.get("preferred_model") or "gemini-2.5-flash-lite"
+                model_id = model_input_value or st.session_state.get("preferred_model") or "gemini-2.0-flash-lite"
                 if st.session_state.get("last_model") != model_id:
                     st.session_state["last_model"] = ""