Update streamlit_app.py

streamlit_app.py

@@ -52,6 +52,7 @@ 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", 600)  # default 10 minutes
 
 def sanitize_filename(path_str: str):
     name = Path(path_str).name
@@ -77,7 +78,9 @@ def convert_video_to_mp4(video_path: str) -> str:
 
 def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str = "fast"):
     try:
-        ffmpeg.input(input_path).output(target_path, vcodec="libx264", crf=crf, preset=preset).run(overwrite_output=True, quiet=True)
+        ffmpeg.input(input_path).output(
+            target_path, vcodec="libx264", crf=crf, preset=preset
+        ).run(overwrite_output=True, quiet=True)
         return target_path
     except Exception:
         return input_path
@@ -170,6 +173,16 @@ default_prompt = (
 analysis_prompt = settings_exp.text_area("Enter analysis", value=default_prompt, height=140)
 settings_exp.text_input("Video Password (if needed)", key="video-password", placeholder="password", type="password")
 
+# Expose processing timeout
+settings_exp.number_input(
+    "Processing timeout (s)",
+    min_value=60,
+    max_value=3600,
+    value=st.session_state.get("processing_timeout", 600),
+    step=30,
+    key="processing_timeout",
+)
+
 key_source = "session" if st.session_state.get("api_key") else ".env" if os.getenv("GOOGLE_API_KEY") else "none"
 settings_exp.caption(f"Using API key from: **{key_source}**")
 
@@ -192,7 +205,15 @@ def upload_video_sdk(filepath: str):
     genai.configure(api_key=key)
     return upload_file(filepath)
 
-def wait_for_processed(file_obj, timeout=180):
+def wait_for_processed(file_obj, timeout: int = None):
+    """
+    Poll get_file until file is no longer in PROCESSING state.
+    Uses st.session_state['processing_timeout'] if timeout is None.
+    Retries on transient get_file errors with exponential backoff.
+    Raises TimeoutError on timeout.
+    """
+    if timeout is None:
+        timeout = st.session_state.get("processing_timeout", 600)
     if not HAS_GENAI or get_file is None:
         return file_obj
     start = time.time()
@@ -200,13 +221,24 @@ def wait_for_processed(file_obj, timeout=180):
     if not name:
         return file_obj
     backoff = 1.0
+    last_exc = None
     while True:
-        obj = get_file(name)
+        try:
+            obj = get_file(name)
+        except Exception as e:
+            last_exc = e
+            if time.time() - start > timeout:
+                raise TimeoutError(f"Failed to fetch file status before timeout: {e}")
+            time.sleep(backoff)
+            backoff = min(backoff * 2, 8.0)
+            continue
+
         state = getattr(obj, "state", None)
         if not state or getattr(state, "name", None) != "PROCESSING":
             return obj
+
         if time.time() - start > timeout:
-            raise TimeoutError("File processing timed out")
+            raise TimeoutError(f"File processing timed out after {int(time.time() - start)}s")
         time.sleep(backoff)
         backoff = min(backoff * 2, 8.0)
 
@@ -230,17 +262,29 @@ def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_thres
     return text
 
 def compress_video_if_large(local_path: str, threshold_mb: int = 50):
+    """
+    Returns (path_to_upload, compressed_flag).
+    If compression fails or isn't needed returns (local_path, False).
+    Logs errors to st.session_state['last_error'].
+    """
     try:
         file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
-    except Exception:
-        return local_path
+    except Exception as e:
+        st.session_state["last_error"] = f"Failed to stat file before compression: {e}"
+        return local_path, False
+
     if file_size_mb <= threshold_mb:
-        return local_path
+        return local_path, False
+
     compressed_path = str(Path(local_path).with_name(Path(local_path).stem + "_compressed.mp4"))
     try:
-        return compress_video(local_path, compressed_path, crf=28, preset="fast")
-    except Exception:
-        return local_path
+        result = compress_video(local_path, compressed_path, crf=28, preset="fast")
+        if result and os.path.exists(result):
+            return result, True
+        return local_path, False
+    except Exception as e:
+        st.session_state["last_error"] = f"Video compression failed: {e}\n{traceback.format_exc()}"
+        return local_path, False
 
 def generate_via_responses_api(prompt_text: str, processed, model_used: str, max_tokens: int = 1024):
     key = get_effective_api_key()
@@ -446,15 +490,27 @@ if generate_now and not st.session_state.get("busy"):
                     if not HAS_GENAI:
                         raise RuntimeError("google.generativeai SDK not available; install it.")
                     local_path = current_path
-                    upload_path = compress_video_if_large(local_path)
+                    upload_path, compressed = compress_video_if_large(local_path)
+
+                    with st.spinner(f"Uploading video{' (compressed)' if compressed else ''}..."):
+                        try:
+                            uploaded = upload_video_sdk(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.")
+                            raise
+
+                    try:
+                        processed = wait_for_processed(uploaded, timeout=st.session_state.get("processing_timeout", 600))
+                    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.")
+                        raise
 
-                    with st.spinner("Uploading video..."):
-                        uploaded = upload_video_sdk(upload_path)
-                        processed = wait_for_processed(uploaded, timeout=180)
-                        st.session_state["uploaded_file"] = uploaded
-                        st.session_state["processed_file"] = processed
-                        st.session_state["last_loaded_path"] = current_path
-                        st.session_state["file_hash"] = current_hash
+                    st.session_state["uploaded_file"] = uploaded
+                    st.session_state["processed_file"] = processed
+                    st.session_state["last_loaded_path"] = current_path
+                    st.session_state["file_hash"] = current_hash
 
                 prompt_text = (analysis_prompt.strip() or default_prompt).strip()
                 out = ""
@@ -523,7 +579,7 @@ if generate_now and not st.session_state.get("busy"):
 
             except Exception as e:
                 tb = traceback.format_exc()
-                st.session_state["last_error"] = f"{e}\n\nDebug: {locals().get('debug_info', debug_info)}\n\nTraceback:\n{tb}"
+                st.session_state["last_error"] = f"{e}\n\nDebug: {locals().get('debug_info', {})}\n\nTraceback:\n{tb}"
                 st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
             finally:
                 st.session_state["busy"] = False