Update streamlit_app.py

streamlit_app.py

@@ -1,4 +1,3 @@
-# streamlit_app.py
 import os
 import time
 import string
@@ -7,7 +6,6 @@ import traceback
 from glob import glob
 from pathlib import Path
 from difflib import SequenceMatcher
-import concurrent.futures
 import json
 
 import yt_dlp
@@ -27,14 +25,15 @@ except Exception:
     Agent = Gemini = DuckDuckGo = None
     HAS_PHI = False
 
-# google.generativeai SDK
+# google-genai (v1.49.1)
 try:
-    import google.generativeai as genai
-    from google.generativeai import upload_file, get_file  # type: ignore
+    import google_genai as genai  # package name for google-genai
+    from google_genai import Files, Responses, configure as genai_configure  # convenience
     HAS_GENAI = True
 except Exception:
     genai = None
-    upload_file = get_file = None
+    Files = Responses = None
+    genai_configure = None
     HAS_GENAI = False
 
 st.set_page_config(page_title="Generate the story of videos", layout="wide")
@@ -70,9 +69,9 @@ 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)  # seconds
-st.session_state.setdefault("generation_timeout", 300)  # seconds
-st.session_state.setdefault("compress_threshold_mb", 200)  # optional compression default
+st.session_state.setdefault("processing_timeout", 900)
+st.session_state.setdefault("generation_timeout", 300)
+st.session_state.setdefault("compress_threshold_mb", 200)
 
 # ---- Helpers ----
 def sanitize_filename(path_str: str):
@@ -140,7 +139,8 @@ def configure_genai_if_needed():
     if not key:
         return False
     try:
-        genai.configure(api_key=key)
+        if genai_configure:
+            genai_configure(api_key=key)
     except Exception:
         pass
     return True
@@ -156,7 +156,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_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:
@@ -177,7 +178,6 @@ def clear_all_video_state():
         except Exception:
             pass
 
-# Reset when URL changes
 current_url = st.session_state.get("url", "")
 if current_url != st.session_state.get("last_url_value"):
     clear_all_video_state()
@@ -228,33 +228,34 @@ safety_settings = [
     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "OFF"},
 ]
 
-# ---- Upload & processing helpers ----
+# ---- Upload & processing helpers for google-genai Files ----
 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)
-    return upload_file(filepath)
+    if not HAS_GENAI or Files is None:
+        raise RuntimeError("google-genai SDK not available; cannot upload")
+    if genai_configure:
+        genai_configure(api_key=key)
+    with open(filepath, "rb") as fh:
+        # Files.upload returns a response-like object; adapt as needed
+        resp = Files.create(file=fh, purpose="video")
+    return resp
 
 def wait_for_processed(file_obj, timeout: int = None):
-    """
-    Poll get_file until file is no longer PROCESSING.
-    Retries get_file on transient errors with exponential backoff.
-    """
     if timeout is None:
         timeout = st.session_state.get("processing_timeout", 900)
-    if not HAS_GENAI or get_file is None:
+    if not HAS_GENAI or Files is None:
         return file_obj
     start = time.time()
-    name = file_name_or_id(file_obj)
-    if not name:
+    # file_obj may be a dict or an SDK object; adapt
+    file_id = file_obj.get("name") if isinstance(file_obj, dict) else getattr(file_obj, "name", None) or getattr(file_obj, "id", None)
+    if not file_id:
         return file_obj
     backoff = 1.0
     while True:
         try:
-            obj = get_file(name)
+            obj = Files.get(file_id)
         except Exception as e:
             if time.time() - start > timeout:
                 raise TimeoutError(f"Failed to fetch file status before timeout: {e}")
@@ -262,8 +263,9 @@ def wait_for_processed(file_obj, timeout: int = None):
             backoff = min(backoff * 2, 8.0)
             continue
 
-        state = getattr(obj, "state", None)
-        if not state or getattr(state, "name", None) != "PROCESSING":
+        state = obj.get("state") if isinstance(obj, dict) else getattr(obj, "state", None)
+        name = state.get("name") if isinstance(state, dict) else getattr(state, "name", None)
+        if not name or name != "PROCESSING":
             return obj
 
         if time.time() - start > timeout:
@@ -310,123 +312,67 @@ def compress_video_if_large(local_path: str, threshold_mb: int = 200):
         st.session_state["last_error"] = f"Video compression failed: {e}\n{traceback.format_exc()}"
         return local_path, False
 
-# ---- Robust Responses API caller adapted for varying model versions ----
+# ---- Responses API caller adapted for google-genai Responses ----
 def generate_via_responses_api(prompt_text: str, processed, model_used: str, max_tokens: int = 1024, timeout: int = 300):
     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."}
-
-    # Some model versions and SDK releases expect messages, some older ones expect input with files.
-    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},
-    ]
-
-    last_exc = None
-    start = time.time()
-    backoff = 1.0
-    while True:
-        for payload in call_variants:
-            try:
-                response = genai.responses.generate(model=model_used, **payload)
-                return _normalize_genai_response(response)
-            except Exception as e:
-                last_exc = e
-                msg = str(e).lower()
-                if any(k in msg for k in ("internal", "unavailable", "deadlineexceeded", "deadline exceeded", "timeout", "rate limit")):
-                    pass
-                else:
-                    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)
+    if not HAS_GENAI or Responses is None:
+        raise RuntimeError("Responses API not available; install google-genai SDK.")
+    if genai_configure:
+        genai_configure(api_key=key)
 
-def _normalize_genai_response(response):
-    outputs = []
-    if response is None:
-        return ""
+    file_name = file_name_or_id(processed)
+    if not file_name:
+        raise RuntimeError("Uploaded file missing name/id")
 
-    if not isinstance(response, dict):
+    # Build a minimal Responses.create call that attaches the video file reference.
+    # The exact shape depends on google-genai; here we create a simple text + reference instruction.
+    request = {
+        "model": model_used,
+        "input": [
+            {"role": "system", "content": prompt_text},
+            {"role": "user", "content": "Please summarize the attached video."}
+        ],
+        "attachments": [{"mime_type": "video/mp4", "uri": f"file:{file_name}"}],
+        "max_output_tokens": max_tokens,
+        "temperature": 0.2,
+    }
+
+    # Responses.create returns a response object/dict; attempt to extract text
+    resp = Responses.create(**request)
+    text = ""
+    # support multiple response shapes
+    if isinstance(resp, dict):
+        # common shapes: resp['output'][0]['content'] or resp['candidates'][0]['content']
+        out = resp.get("output") or resp.get("candidates")
+        if isinstance(out, list) and out:
+            first = out[0]
+            if isinstance(first, dict):
+                text = first.get("content") or first.get("text") or ""
+            else:
+                text = str(first)
+        else:
+            text = resp.get("content") or resp.get("text") or ""
+    else:
+        # SDK object: try attributes
         try:
-            response = json.loads(str(response))
+            if hasattr(resp, "outputs"):
+                outputs = getattr(resp, "outputs", None)
+                if outputs:
+                    text = outputs[0].get("content") if isinstance(outputs, list) and isinstance(outputs[0], dict) else str(outputs[0])
+            elif hasattr(resp, "text"):
+                text = getattr(resp, "text", "")
         except Exception:
-            pass
-
-    candidate_lists = []
-    if isinstance(response, dict):
-        for key in ("output", "candidates", "items", "responses", "choices"):
-            val = response.get(key)
-            if isinstance(val, list) and val:
-                candidate_lists.append(val)
-    if not candidate_lists and isinstance(response, dict):
-        for v in response.values():
-            if isinstance(v, list) and v:
-                candidate_lists.append(v)
-                break
-
-    text_pieces = []
-    for lst in candidate_lists:
-        for item in lst:
-            if not item:
-                continue
-            if isinstance(item, dict):
-                for k in ("content", "text", "message", "output_text", "output"):
-                    t = item.get(k)
-                    if t:
-                        text_pieces.append(str(t).strip())
-                        break
-                else:
-                    if "content" in item and isinstance(item["content"], list):
-                        for part in item["content"]:
-                            if isinstance(part, dict):
-                                t = part.get("text") or part.get("content")
-                                if t:
-                                    text_pieces.append(str(t).strip())
-                            elif isinstance(part, str):
-                                text_pieces.append(part.strip())
-            elif isinstance(item, str):
-                text_pieces.append(item.strip())
-            else:
-                try:
-                    t = getattr(item, "text", None) or getattr(item, "content", None)
-                    if t:
-                        text_pieces.append(str(t).strip())
-                except Exception:
-                    pass
-
-    if not text_pieces and isinstance(response, dict):
-        for k in ("text", "message", "output_text"):
-            v = response.get(k)
-            if v:
-                text_pieces.append(str(v).strip())
-                break
-
-    seen = set()
-    filtered = []
-    for t in text_pieces:
-        if not isinstance(t, str):
-            continue
-        if t and t not in seen:
-            filtered.append(t)
-            seen.add(t)
-    return "\n\n".join(filtered).strip()
+            text = str(resp)
+    return text or ""
 
 # ---- 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()))
 with col2:
-    st.write("")  # placeholder
+    st.write("")
 
 if st.sidebar.button("Load Video", use_container_width=True):
     try:
@@ -484,7 +430,8 @@ if generate_now and not st.session_state.get("busy"):
                 st.session_state["busy"] = True
                 try:
                     if HAS_GENAI and genai is not None:
-                        genai.configure(api_key=key_to_use)
+                        if genai_configure:
+                            genai_configure(api_key=key_to_use)
                 except Exception:
                     pass
 
@@ -506,12 +453,11 @@ if generate_now and not st.session_state.get("busy"):
 
                 if reupload_needed:
                     if not HAS_GENAI:
-                        raise RuntimeError("google.generativeai SDK not available; install it.")
+                        raise RuntimeError("google-genai SDK not available; install it.")
                     local_path = current_path
                     upload_path, compressed = compress_video_if_large(local_path, threshold_mb=st.session_state.get("compress_threshold_mb", 200))
 
                     with st.spinner(f"Uploading video{' (compressed)' if compressed else ''}..."):
-                        progress_placeholder = st.empty()
                         try:
                             uploaded = upload_video_sdk(upload_path)
                         except Exception as e:
@@ -520,11 +466,7 @@ if generate_now and not st.session_state.get("busy"):
                             raise
 
                     try:
-                        processing_placeholder = st.empty()
-                        processing_bar = processing_placeholder.progress(0)
                         processed = wait_for_processed(uploaded, timeout=st.session_state.get("processing_timeout", 900))
-                        processing_bar.progress(100)
-                        processing_placeholder.success("Processing complete")
                     except Exception as e:
                         st.session_state["last_error"] = f"Processing failed/wait timeout: {e}\n\nTraceback:\n{traceback.format_exc()}"
                         st.error("Video processing failed or timed out. See Last Error.")
@@ -541,7 +483,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
 
-                # Try Agent first, fallback to Responses API
                 agent = maybe_create_agent(model_used)
                 debug_info = {"agent_attempted": False, "agent_ok": False, "agent_error": None, "agent_response_has_text": False}
                 if agent: