Update streamlit_app.py

streamlit_app.py

@@ -281,11 +281,20 @@ def get_runtime_api_key():
 
 # ---- Simplified SDK-first + HTTP-fallback layer ----
 def _normalize_model_for_http(model: str) -> str:
+    """
+    Return a model identifier appropriate for the HTTP path.
+    Accept inputs like:
+      - "text-bison@001" -> "models/text-bison@001"
+      - "models/text-bison@001" -> "models/text-bison@001"
+      - "models/foo" -> "models/foo"
+      - "foo" -> "models/foo"
+    """
     if not model:
-        return "text-bison@001"
-    # if user provided "models/..." strip prefix
-    m = model.split("/", 1)[-1] if model.startswith("models/") else model
-    return m
+        return "models/text-bison@001"
+    m = model.strip()
+    if m.startswith("models/"):
+        return m
+    return f"models/{m}"
 
 def _messages_to_prompt(messages):
     if not messages:
@@ -300,10 +309,11 @@ def _messages_to_prompt(messages):
 def _http_generate(api_key: str, model: str, prompt: str, max_tokens: int):
     host = "https://generativelanguage.googleapis.com"
     norm = _normalize_model_for_http(model)
+    # Try several API paths. norm already contains "models/..."
     candidates = [
-        f"{host}/v1/models/{norm}:generate",
-        f"{host}/v1beta3/models/{norm}:generate",
-        f"{host}/v1beta2/models/{norm}:generate",
+        f"{host}/v1/{norm}:generate",
+        f"{host}/v1beta3/{norm}:generate",
+        f"{host}/v1beta2/{norm}:generate",
     ]
     payload = {"prompt": {"text": prompt}, "maxOutputTokens": int(max_tokens or 512)}
     headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
@@ -316,6 +326,7 @@ def _http_generate(api_key: str, model: str, prompt: str, max_tokens: int):
                     return r.json()
                 except Exception:
                     return {"text": r.text}
+            # Explicit 404 handling: try next candidate
             last_exc = RuntimeError(f"HTTP {r.status_code}: {r.text}")
         except Exception as e:
             last_exc = e
@@ -358,10 +369,13 @@ def extract_text_from_response(response):
         return None
     # dict-like (HTTP)
     if isinstance(response, dict):
-        # try common shapes
+        # Try common shapes
+        # 1) "candidates": [ { "content": "...", "text": "..." } ]
         if "candidates" in response and isinstance(response["candidates"], list) and response["candidates"]:
             cand = response["candidates"][0]
-            return cand.get("content") or cand.get("text") or response.get("text")
+            if isinstance(cand, dict):
+                return cand.get("content") or cand.get("text") or response.get("text")
+        # 2) "output": [ { "content": "..."} ] or "output_text"
         if "output" in response and isinstance(response["output"], list):
             pieces = []
             for item in response["output"]:
@@ -373,7 +387,12 @@ def extract_text_from_response(response):
                 return "\n\n".join(pieces)
         if "text" in response and isinstance(response["text"], str):
             return response["text"]
-        # fallback: join any candidate-like entries
+        if "outputText" in response and isinstance(response["outputText"], str):
+            return response["outputText"]
+        # fallback: try joining string fields
+        for k in ("result", "generated_text", "description"):
+            if k in response and isinstance(response[k], str):
+                return response[k]
         return None
     # object-like (SDK)
     try:
@@ -386,7 +405,7 @@ def extract_text_from_response(response):
                     pieces.append(txt)
             if pieces:
                 return "\n\n".join(pieces)
-        txt = getattr(response, "text", None)
+        txt = getattr(response, "text", None) or getattr(response, "output_text", None)
         if txt:
             return txt
     except Exception:
@@ -395,6 +414,7 @@ def extract_text_from_response(response):
 
 # ---- end compatibility layer ----
 
+# The main generation block (patched, robust)
 if (st.session_state.get("busy") is False) and ('generate_now' in locals() and generate_now):
     if not st.session_state.get("videos"):
         st.error("No video loaded. Use 'Load Video' in the sidebar.")
@@ -418,22 +438,26 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
 
                 upload_path = current_path
                 uploaded = st.session_state.get("uploaded_file")
+                compressed_path = None
                 if reupload_needed:
                     local_path = current_path
-                    fast_mode = st.session_state.get("fast_mode", False)
+                    fast_mode = bool(st.session_state.get("fast_mode", False))
                     try:
                         file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
                     except Exception:
                         file_size_mb = 0
 
-                    use_compression = st.session_state.get("use_compression", True)
+                    use_compression = bool(st.session_state.get("use_compression", True))
                     if use_compression and not fast_mode and file_size_mb > 50:
                         compressed_path = str(Path(local_path).with_name(Path(local_path).stem + "_compressed.mp4"))
                         try:
                             preset = "veryfast" if fast_mode else "fast"
                             upload_path = compress_video(local_path, compressed_path, crf=28, preset=preset)
+                            if Path(upload_path) == Path(local_path):
+                                compressed_path = None
                         except Exception:
                             upload_path = local_path
+                            compressed_path = None
 
                     if HAS_GENAI and upload_file is not None:
                         genai.configure(api_key=runtime_key)
@@ -453,13 +477,13 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
                     uploaded = st.session_state.get("uploaded_file")
                     processed = st.session_state.get("processed_file")
 
-                prompt_text = (analysis_prompt or default_prompt).strip()
+                prompt_text = (analysis_prompt or default_prompt or "").strip()
                 if st.session_state.get("fast_mode"):
                     model_used = model_arg or "text-bison@001"
-                    max_tokens = min(st.session_state.get("max_output_tokens", 512), 1024)
+                    max_tokens = min(int(st.session_state.get("max_output_tokens", 512)), 1024)
                 else:
-                    model_used = model_arg
-                    max_tokens = st.session_state.get("max_output_tokens", 1024)
+                    model_used = model_arg or "text-bison@001"
+                    max_tokens = int(st.session_state.get("max_output_tokens", 1024))
 
                 # Ensure model_used is a short name (SDK accepts it; HTTP will normalize)
                 system_msg = {"role": "system", "content": "You are a helpful assistant that summarizes videos concisely in vivid detail."}
@@ -506,12 +530,18 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
                 st.subheader("Analysis Result")
                 st.markdown(out or "_(no text returned)_")
 
+                # Clean up compressed temporary file only (don't remove original unless it was a true temp)
                 try:
                     if reupload_needed:
-                        if upload_path and Path(upload_path).exists() and Path(upload_path) != Path(current_path):
-                            Path(upload_path).unlink(missing_ok=True)
-                        Path(current_path).unlink(missing_ok=True)
-                        st.session_state["videos"] = ""
+                        try:
+                            if compressed_path:
+                                p = Path(compressed_path)
+                                if p.exists():
+                                    p.unlink(missing_ok=True)
+                        except Exception:
+                            pass
+                        # don't delete original unless it's intended to be removed (conservative)
+                        # If you want original removed, enable a setting and handle carefully.
                 except Exception:
                     pass
 
@@ -560,8 +590,7 @@ with st.sidebar.expander("Manage uploads", expanded=False):
         st.session_state["uploaded_file"] = None
         st.session_state["processed_file"] = None
         st.session_state["last_loaded_path"] = ""
-        st.session_state["analysis_out"] = ""
-        st.session_state["file_hash"] = None
+        st.session_state[""] = None
         try:
             fname = file_name_or_id(st.session_state.get("uploaded_file"))
             if fname and delete_file and HAS_GENAI: