Update streamlit_app.py

streamlit_app.py

@@ -1,4 +1,4 @@
-# streamlit_app_refined.py
+# streamlit_app.py
 import os
 import time
 import string
@@ -27,14 +27,19 @@ except Exception:
     Agent = Gemini = DuckDuckGo = None
     HAS_PHI = False
 
-# google.generativeai SDK
+# google.generativeai SDK (try both legacy and newer patterns)
 try:
     import google.generativeai as genai
-    from google.generativeai import upload_file, get_file  # type: ignore
+    # some installs expose a top-level `responses` object, others require attribute access
+    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)
     HAS_GENAI = True
 except Exception:
     genai = None
-    upload_file = get_file = None
+    genai_responses = None
+    upload_file = None
+    get_file = None
     HAS_GENAI = False
 
 logging.basicConfig(level=logging.INFO)
@@ -44,7 +49,6 @@ st.set_page_config(page_title="Generate the story of videos", layout="wide")
 DATA_DIR = Path("./data")
 DATA_DIR.mkdir(exist_ok=True)
 
-# Session defaults
 st.session_state.setdefault("videos", "")
 st.session_state.setdefault("loop_video", False)
 st.session_state.setdefault("uploaded_file", None)
@@ -62,7 +66,6 @@ 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")
 
-# Model choices for dropdown
 MODEL_OPTIONS = [
     "gemini-2.5-flash",
     "gemini-2.5-flash-lite",
@@ -71,7 +74,6 @@ MODEL_OPTIONS = [
     "custom",
 ]
 
-# Helpers
 def sanitize_filename(path_str: str):
     name = Path(path_str).name
     return name.lower().translate(str.maketrans("", "", string.punctuation)).replace(" ", "_")
@@ -137,12 +139,12 @@ def configure_genai_if_needed():
     if not key:
         return False
     try:
-        genai.configure(api_key=key)
+        if genai is not None and hasattr(genai, "configure"):
+            genai.configure(api_key=key)
     except Exception:
         pass
     return True
 
-# Agent management
 _agent = None
 def maybe_create_agent(model_id: str):
     global _agent
@@ -153,7 +155,8 @@ def maybe_create_agent(model_id: str):
     if _agent and st.session_state.get("last_model") == model_id:
         return _agent
     try:
-        genai.configure(api_key=key)
+        if genai is not None and hasattr(genai, "configure"):
+            genai.configure(api_key=key)
         _agent = Agent(name="Video AI summarizer", model=Gemini(id=model_id), tools=[DuckDuckGo()], markdown=True)
         st.session_state["last_model"] = model_id
     except Exception:
@@ -174,13 +177,11 @@ def clear_all_video_state():
         except Exception:
             pass
 
-# Reset on URL change
 current_url = st.session_state.get("url", "")
 if current_url != st.session_state.get("last_url_value"):
     clear_all_video_state()
     st.session_state["last_url_value"] = current_url
 
-# Sidebar UI
 st.sidebar.header("Video Input")
 st.sidebar.text_input("Video URL", key="url", placeholder="https://")
 
@@ -220,14 +221,14 @@ safety_settings = [
     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "OFF"},
 ]
 
-# 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")
-    genai.configure(api_key=key)
+    if genai is not None and hasattr(genai, "configure"):
+        genai.configure(api_key=key)
     return upload_file(filepath)
 
 def wait_for_processed(file_obj, timeout: int = None, progress_callback=None):
@@ -307,55 +308,6 @@ def compress_video_if_large(local_path: str, threshold_mb: int = 50):
         st.session_state["last_error"] = f"Video compression failed: {e}\n{traceback.format_exc()}"
         return local_path, False
 
-# Responses API caller: robust, but NO automatic model-switching (user-controlled)
-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:
-        raise RuntimeError("No API key provided")
-    if not HAS_GENAI or genai is None:
-        raise RuntimeError("Responses API not available; install google.generativeai SDK.")
-    genai.configure(api_key=key)
-    fname = file_name_or_id(processed)
-    if not fname:
-        raise RuntimeError("Uploaded file missing name/id")
-
-    system_msg = {"role": "system", "content": prompt_text}
-    user_msg = {"role": "user", "content": "Please summarize the attached video."}
-    call_variants = [
-        {"messages": [system_msg, user_msg], "files": [{"name": fname}], "safety_settings": safety_settings, "max_output_tokens": max_tokens},
-        {"input": [{"text": prompt_text, "files": [{"name": fname}]}], "safety_settings": safety_settings, "max_output_tokens": max_tokens},
-    ]
-
-    def is_transient_error(e_text: str):
-        txt = str(e_text).lower()
-        return any(k in txt for k in ("internal", "unavailable", "deadlineexceeded", "deadline exceeded", "timeout", "rate limit", "503", "502", "500"))
-
-    start = time.time()
-    last_exc = None
-    backoff = 1.0
-    attempts = 0
-    while True:
-        for payload in call_variants:
-            attempts += 1
-            try:
-                if progress_callback:
-                    progress_callback("starting", int(time.time() - start), {"model": model_used, "attempt": attempts})
-                response = genai.responses.generate(model=model_used, **payload)
-                text = _normalize_genai_response(response)
-                if progress_callback:
-                    progress_callback("done", int(time.time() - start), {"model": model_used, "attempt": attempts})
-                return text
-            except Exception as e:
-                last_exc = e
-                msg = str(e)
-                logger.warning("Responses.generate error (model=%s attempt=%s): %s", model_used, attempts, msg)
-                if not is_transient_error(msg):
-                    raise
-                if time.time() - start > timeout:
-                    raise TimeoutError(f"Responses.generate timed out after {timeout}s: last error: {last_exc}")
-                time.sleep(backoff)
-                backoff = min(backoff * 2, 8.0)
-
 def _normalize_genai_response(response):
     if response is None:
         return ""
@@ -420,7 +372,95 @@ def _normalize_genai_response(response):
             seen.add(t)
     return "\n\n".join(filtered).strip()
 
-# Layout
+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:
+        raise RuntimeError("No API key provided")
+    if not HAS_GENAI or genai is None:
+        raise RuntimeError("Responses API not available; install google-generativeai SDK.")
+    if genai is not None and hasattr(genai, "configure"):
+        genai.configure(api_key=key)
+    fname = file_name_or_id(processed)
+    if not fname:
+        raise RuntimeError("Uploaded file missing name/id")
+
+    system_msg = {"role": "system", "content": prompt_text}
+    user_msg = {"role": "user", "content": "Please summarize the attached video."}
+    call_variants = []
+
+    # Two common payload shapes: `genai.responses.generate(model=..., **payload)`
+    # and legacy `genai.Responses.create(...)` or model/chat wrappers.
+    # Build payloads for both styles.
+    call_variants.append({"method": "responses.generate", "payload": {"model": model_used, "messages": [system_msg, user_msg], "files": [{"name": fname}], "safety_settings": safety_settings, "max_output_tokens": max_tokens}})
+    call_variants.append({"method": "responses.generate_alt", "payload": {"model": model_used, "input": [{"text": prompt_text, "files": [{"name": fname}]}], "safety_settings": safety_settings, "max_output_tokens": max_tokens}})
+    call_variants.append({"method": "legacy_responses_create", "payload": {"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()
+        return any(k in txt for k in ("internal", "unavailable", "deadlineexceeded", "deadline exceeded", "timeout", "rate limit", "503", "502", "500"))
+
+    start = time.time()
+    last_exc = None
+    backoff = 1.0
+    attempts = 0
+    while True:
+        for attempt_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})
+                # Preferred new API style if available
+                if genai_responses is not None and hasattr(genai_responses, "generate"):
+                    response = genai_responses.generate(**payload) if method.startswith("responses.generate") else genai_responses.generate(**payload)
+                    text = _normalize_genai_response(response)
+                    if progress_callback:
+                        progress_callback("done", int(time.time() - start), {"model": model_used, "attempt": attempts, "method": method})
+                    return text
+                # Some versions expose a top-level Responses class/or function `genai.Responses.create`
+                if hasattr(genai, "Responses") and hasattr(genai.Responses, "create"):
+                    response = genai.Responses.create(**payload)  # type: ignore
+                    text = _normalize_genai_response(response)
+                    if progress_callback:
+                        progress_callback("done", int(time.time() - start), {"model": model_used, "attempt": attempts, "method": method})
+                    return text
+                # Legacy model object style (older gemini SDK wrappers)
+                if hasattr(genai, "GenerativeModel"):
+                    try:
+                        model_obj = genai.GenerativeModel(model_name=model_used)
+                        # try chat pattern
+                        if hasattr(model_obj, "start_chat"):
+                            chat = model_obj.start_chat()
+                            resp = chat.send_message(prompt_text, timeout=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"})
+                            return text
+                    except Exception:
+                        pass
+                # If none matched, raise to be caught below and trigger helpful error
+                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)
+                if not is_transient_error(msg):
+                    # non-transient -> surface meaningful hint for common misconfig issues
+                    if "No supported response generation method" in msg or "has no attribute" in msg or "module 'google.generativeai' 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"
+                        ) from e
+                    raise
+                if time.time() - start > timeout:
+                    raise TimeoutError(f"Responses.generate timed out after {timeout}s: last error: {last_exc}")
+                time.sleep(backoff)
+                backoff = min(backoff * 2, 8.0)
+
+# 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()))
@@ -470,7 +510,6 @@ if st.session_state["videos"]:
     except Exception:
         pass
 
-# Main generation flow
 if generate_now and not st.session_state.get("busy"):
     if not st.session_state.get("videos"):
         st.error("No video loaded. Use 'Load Video' in the sidebar.")
@@ -487,7 +526,6 @@ if generate_now and not st.session_state.get("busy"):
                 except Exception:
                     pass
 
-                # chosen model
                 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"] = ""