Update streamlit_app.py

streamlit_app.py

@@ -8,12 +8,14 @@ from glob import glob
 from pathlib import Path
 import json
 import logging
+import mimetypes
 
 import yt_dlp
 import ffmpeg
 import streamlit as st
 from dotenv import load_dotenv
 from difflib import SequenceMatcher
+import requests
 
 # Try import google.generativeai, support multiple SDK shapes
 try:
@@ -264,25 +266,60 @@ def _normalize_genai_response(response):
             seen.add(t)
     return "\n\n".join(filtered).strip()
 
-# Generation (supports various SDK shapes)
+# REST fallback to GenAI Responses API
+def rest_responses_api(prompt_text: str, file_path: str, model: 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")
+    url = "https://generativelanguage.googleapis.com/v1beta2/responses:generate"
+    headers = {"Authorization": f"Bearer {key}"}
+    # Build a simple request that attaches the file as a "file" in multipart/form-data.
+    # Use a minimal JSON payload referencing the file by name in the input.
+    fname = Path(file_path).name
+    input_json = {
+        "model": model,
+        "input": [
+            {
+                "text": prompt_text,
+                "mimeType": mimetypes.guess_type(file_path)[0] or "application/octet-stream",
+                "attachments": [{"contentType": mimetypes.guess_type(file_path)[0] or "application/octet-stream", "name": fname}],
+            }
+        ],
+        "maxOutputTokens": max_tokens,
+    }
+    # Multipart: one part "request" with JSON, another with the file binary.
+    try:
+        with open(file_path, "rb") as f:
+            files = {
+                "request": ("request", json.dumps(input_json), "application/json"),
+                "file": (fname, f, mimetypes.guess_type(file_path)[0] or "application/octet-stream"),
+            }
+            resp = requests.post(url, headers=headers, files=files, timeout=timeout)
+        resp.raise_for_status()
+        data = resp.json()
+        return _normalize_genai_response(data)
+    except Exception as e:
+        raise RuntimeError(f"REST Responses API failed: {e}")
+
+# Generation (supports various SDK shapes + REST fallback)
 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")
+        try:
+            genai.configure(api_key=key)
+        except Exception:
+            pass
+    fname = file_name_or_id(processed) or None
 
+    # Prepare simple system+user structure
     system_msg = {"role": "system", "content": prompt_text}
-    user_msg = {"role": "user", "content": "Please summarize the attached video."}
+    user_msg = {"role": "user", "content": f"Please summarize the attached video: {fname or '[uploaded file]'}."}
 
     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}),
+        ("responses.generate", {"model": model_used, "messages": [system_msg, user_msg], "files": [{"name": fname}] if fname else None, "max_output_tokens": max_tokens}),
+        ("responses.generate_alt", {"model": model_used, "input": [{"text": prompt_text, "files": [{"name": fname}]}] if fname else None, "max_output_tokens": max_tokens}),
         ("legacy_create", {"model": model_used, "input": prompt_text, "file": fname, "max_output_tokens": max_tokens}),
     ]
 
@@ -290,10 +327,33 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
         txt = str(e_text).lower()
         return any(k in txt for k in ("internal", "unavailable", "deadlineexceeded", "deadline exceeded", "timeout", "rate limit", "503", "502", "500"))
 
+    # Quick pre-check: if processed is a local path (dictless), prefer REST fallback to ensure attachment works
+    local_file_path = None
+    if isinstance(processed, str) and os.path.exists(processed):
+        local_file_path = processed
+    elif isinstance(processed, dict):
+        # if SDK provided a dict with local path info (rare), try to detect
+        for k in ("path", "name", "filename", "uri"):
+            v = processed.get(k)
+            if isinstance(v, str) and os.path.exists(v):
+                local_file_path = v
+                break
+
     start = time.time()
     last_exc = None
     backoff = 1.0
     attempts = 0
+
+    # If we have a local file path, try REST fallback first for reliable file attachment.
+    if local_file_path:
+        try:
+            if progress_callback:
+                progress_callback("rest-fallback", 0, {"file": local_file_path, "model": model_used})
+            return rest_responses_api(prompt_text, local_file_path, model_used, max_tokens=max_tokens, timeout=timeout, progress_callback=progress_callback)
+        except Exception as e:
+            last_exc = e
+            logger.warning("REST fallback failed; will try SDK: %s", e)
+
     while True:
         for method_name, payload in call_variants:
             attempts += 1
@@ -303,18 +363,26 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
 
                 # Preferred modern: genai.responses.generate or genai_responses.generate
                 if genai_responses is not None and hasattr(genai_responses, "generate"):
+                    # Remove None entries from payload
+                    payload = {k: v for k, v in payload.items() if v is not None}
                     resp = genai_responses.generate(**payload)
                     text = _normalize_genai_response(resp)
                     if progress_callback:
                         progress_callback("done", int(time.time() - start), {"method": method_name})
+                    # If the model returns a request-for-file style message, try REST fallback
+                    if text and ("please provide the video" in text.lower() or "upload the video" in text.lower()):
+                        raise RuntimeError("Model indicates it didn't receive the file")
                     return text
 
                 # Older path: genai.Responses.create
                 if hasattr(genai, "Responses") and hasattr(genai.Responses, "create"):
+                    payload = {k: v for k, v in payload.items() if v is not None}
                     resp = genai.Responses.create(**payload)  # type: ignore
                     text = _normalize_genai_response(resp)
                     if progress_callback:
                         progress_callback("done", int(time.time() - start), {"method": method_name})
+                    if text and ("please provide the video" in text.lower() or "upload the video" in text.lower()):
+                        raise RuntimeError("Model indicates it didn't receive the file")
                     return text
 
                 # Fallback: GenerativeModel API (ChatSession). This SDK's ChatSession.send_message may not accept timeout kw.
@@ -323,7 +391,6 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
                         model_obj = genai.GenerativeModel(model_name=model_used)
                         if hasattr(model_obj, "start_chat"):
                             chat = model_obj.start_chat()
-                            # 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")
@@ -335,6 +402,8 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
                             text = text if text else _normalize_genai_response(resp)
                             if progress_callback:
                                 progress_callback("done", int(time.time() - start), {"method": "GenerativeModel.chat"})
+                            if text and ("please provide the video" in text.lower() or "upload the video" in text.lower()):
+                                raise RuntimeError("Model indicates it didn't receive the file")
                             return text
                     except Exception:
                         logger.exception("GenerativeModel.chat fallback failed")
@@ -345,10 +414,11 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
                 msg = str(e)
                 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:
+                    if "No supported response generation method" in msg or "has no attribute" in msg or "didn't receive the file" in msg:
+                        # If it's a file-attachment issue or incompatible SDK, offer a clear upgrade message (but don't spam UI)
                         raise RuntimeError(
-                            "Installed google-generativeai package does not expose a compatible Responses API. "
-                            "Please upgrade to a recent release: pip install --upgrade google-generativeai"
+                            "Installed google-generativeai package may not expose a compatible Responses API or the SDK didn't attach the file correctly. "
+                            "Try upgrading the SDK: pip install --upgrade google-generativeai, or use the app's REST fallback."
                         ) from e
                     raise
                 if time.time() - start > timeout:
@@ -529,8 +599,8 @@ if generate_now and not st.session_state.get("busy"):
                     reupload_needed = False
 
                 if reupload_needed:
-                    if not HAS_GENAI:
-                        raise RuntimeError("google.generativeai SDK not available; install it.")
+                    if not HAS_GENAI and not get_effective_api_key():
+                        raise RuntimeError("google.generativeai SDK not available and no API key; cannot upload")
                     local_path = current_path
 
                     try:
@@ -550,7 +620,12 @@ if generate_now and not st.session_state.get("busy"):
 
                     with st.spinner(f"Uploading video{' (compressed)' if compressed else ''}..."):
                         try:
-                            uploaded = upload_video_sdk(upload_path)
+                            # Prefer SDK upload if available, else keep local path for REST fallback
+                            if HAS_GENAI and upload_file is not None:
+                                uploaded = upload_video_sdk(upload_path)
+                            else:
+                                # No SDK upload; retain local path (REST fallback will attach file directly)
+                                uploaded = upload_path
                         except Exception as e:
                             st.session_state["last_error"] = f"Upload failed: {e}\n\nTraceback:\n{traceback.format_exc()}"
                             st.error("Upload failed. See Last Error for details.")
@@ -593,7 +668,7 @@ if generate_now and not st.session_state.get("busy"):
                             gen_status.text(f"Stage: {stage} — elapsed: {elapsed}s — {info}")
                         except Exception:
                             pass
-                    out = generate_via_responses_api(prompt_text, processed, model_used, max_tokens=max_tokens, timeout=st.session_state.get("generation_timeout", 300), progress_callback=gen_progress_cb)
+                    out = generate_via_responses_api(prompt_text, st.session_state.get("processed_file"), model_used, max_tokens=max_tokens, timeout=st.session_state.get("generation_timeout", 300), progress_callback=gen_progress_cb)
                     gen_progress_placeholder.text(f"Generation complete in {int(time.time()-start_gen)}s")
                 except Exception as e:
                     tb = traceback.format_exc()