Update streamlit_app.py

streamlit_app.py

@@ -1,4 +1,4 @@
-# streamlit_app_enhanced.py
+# streamlit_app_refined.py
 import os
 import time
 import string
@@ -7,7 +7,6 @@ import traceback
 from glob import glob
 from pathlib import Path
 from difflib import SequenceMatcher
-import concurrent.futures
 import json
 import logging
 
@@ -18,7 +17,7 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-# Optional phi integration (Agent + Gemini wrapper)
+# Optional phi integration (Agent wrapper)
 try:
     from phi.agent import Agent
     from phi.model.google import Gemini
@@ -38,7 +37,6 @@ except Exception:
     upload_file = get_file = None
     HAS_GENAI = False
 
-# Logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("video_ai")
 
@@ -64,7 +62,16 @@ 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")
 
-# Helpers (kept in-file for single-file deliverable)
+# Model choices for dropdown
+MODEL_OPTIONS = [
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+    "gemini-2.0-flash",
+    "gemini-2.0-flash-lite",
+    "custom",
+]
+
+# Helpers
 def sanitize_filename(path_str: str):
     name = Path(path_str).name
     return name.lower().translate(str.maketrans("", "", string.punctuation)).replace(" ", "_")
@@ -167,7 +174,7 @@ def clear_all_video_state():
         except Exception:
             pass
 
-# Reset when URL changes
+# 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()
@@ -178,7 +185,11 @@ st.sidebar.header("Video Input")
 st.sidebar.text_input("Video URL", key="url", placeholder="https://")
 
 settings_exp = st.sidebar.expander("Settings", expanded=False)
-model_input = settings_exp.text_input("Preferred Gemini Model (short name)", st.session_state.get("preferred_model", "gemini-2.5-flash-lite"), key="model_input")
+chosen = settings_exp.selectbox("Gemini model", MODEL_OPTIONS, index=MODEL_OPTIONS.index("gemini-2.5-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"))
+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")
 default_prompt = (
     "Watch the video and provide a detailed behavioral report focusing on human actions, interactions, posture, movement, and apparent intent. Keep language professional. Include a list of observations for notable events."
@@ -210,19 +221,14 @@ safety_settings = [
 ]
 
 # Upload & processing helpers
-def upload_video_sdk(filepath: str, progress_callback=None):
+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)
-    # upload_file doesn't offer progress hooks in SDK; attempt best-effort by streaming in chunks if possible
-    # Fall back to direct upload_file call for compatibility
-    try:
-        return upload_file(filepath)
-    except Exception as e:
-        raise
+    return upload_file(filepath)
 
 def wait_for_processed(file_obj, timeout: int = None, progress_callback=None):
     if timeout is None:
@@ -234,7 +240,6 @@ def wait_for_processed(file_obj, timeout: int = None, progress_callback=None):
     if not name:
         return file_obj
     backoff = 1.0
-    last_state = None
     while True:
         try:
             obj = get_file(name)
@@ -248,9 +253,8 @@ def wait_for_processed(file_obj, timeout: int = None, progress_callback=None):
         state = getattr(obj, "state", None)
         state_name = getattr(state, "name", None) if state else None
         if progress_callback:
-            # show a simple heuristic percent while PROCESSING
             elapsed = int(time.time() - start)
-            pct = 100 if not state_name else (50 if state_name == "PROCESSING" else 100)
+            pct = 50 if state_name == "PROCESSING" else 100
             try:
                 progress_callback(min(100, pct), elapsed, state_name)
             except Exception:
@@ -263,7 +267,6 @@ def wait_for_processed(file_obj, timeout: int = None, progress_callback=None):
             raise TimeoutError(f"File processing timed out after {int(time.time() - start)}s")
         time.sleep(backoff)
         backoff = min(backoff * 2, 8.0)
-        last_state = state_name
 
 def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_threshold: float = 0.68):
     if not prompt or not text:
@@ -304,7 +307,7 @@ 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
 
-# Robust Responses API caller with retries and auto-fallback to older model on certain failures
+# 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:
@@ -318,7 +321,6 @@ 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 = [
         {"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},
@@ -331,56 +333,30 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
     start = time.time()
     last_exc = None
     backoff = 1.0
-    max_total = timeout
     attempts = 0
-    tried_models = []
-    preferred_model = model_used or st.session_state.get("preferred_model", "gemini-2.5-flash-lite")
-    fallback_model = "gemini-2.0-flash-lite" if "2.5" in preferred_model else None
-    models_to_try = [preferred_model] + ([fallback_model] if fallback_model else [])
-    for m in models_to_try:
-        if not m:
-            continue
-        tried_models.append(m)
-        # per-model attempt window
-        model_start = time.time()
-        while True:
+    while True:
+        for payload in call_variants:
             attempts += 1
-            for payload in call_variants:
-                try:
-                    if progress_callback:
-                        elapsed = int(time.time() - start)
-                        try:
-                            progress_callback("starting_generation", elapsed, {"model": m, "attempt": attempts})
-                        except Exception:
-                            pass
-                    response = genai.responses.generate(model=m, **payload)
-                    text = _normalize_genai_response(response)
-                    if progress_callback:
-                        elapsed = int(time.time() - start)
-                        try:
-                            progress_callback("generation_complete", elapsed, {"model": m})
-                        except Exception:
-                            pass
-                    return text
-                except Exception as e:
-                    last_exc = e
-                    msg = str(e)
-                    logger.warning("Responses.generate error on model %s attempt %s: %s", m, attempts, msg)
-                    if not is_transient_error(msg):
-                        # Non-transient: rethrow to surface to caller
-                        raise
-                    # transient: will retry for this model up to timeout
-                    if time.time() - start > max_total:
-                        break
-                    time.sleep(backoff)
-                    backoff = min(backoff * 2, 8.0)
-            if time.time() - model_start > max_total:
-                break
-        # try next model (fallback)
-    raise TimeoutError(f"Responses.generate failed after trying models {tried_models}: last error: {last_exc}")
+            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):
-    outputs = []
     if response is None:
         return ""
     if not isinstance(response, dict):
@@ -511,7 +487,8 @@ if generate_now and not st.session_state.get("busy"):
                 except Exception:
                     pass
 
-                model_id = (st.session_state.get("model_input") or st.session_state.get("preferred_model") or "gemini-2.5-flash-lite").strip()
+                # 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"] = ""
                 maybe_create_agent(model_id)
@@ -534,7 +511,6 @@ if generate_now and not st.session_state.get("busy"):
                     upload_path, compressed = compress_video_if_large(local_path)
 
                     with st.spinner(f"Uploading video{' (compressed)' if compressed else ''}..."):
-                        upload_progress_placeholder = st.empty()
                         try:
                             uploaded = upload_video_sdk(upload_path)
                         except Exception as e: