Update streamlit_app.py

streamlit_app.py

@@ -33,7 +33,6 @@ for k, v in {
 }.items():
     st.session_state.setdefault(k, v)
 
-# helpers
 def sanitize_filename(path_str: str):
     return Path(path_str).name.lower().translate(str.maketrans("", "", "!?\"'`~@#$%^&*()[]{}<>:,;\\/|+=*")).replace(" ", "_")
 
@@ -66,7 +65,7 @@ def convert_video_to_mp4(video_path: str) -> str:
             os.remove(tmp.name)
         except Exception:
             pass
-        raise RuntimeError("ffmpeg conversion failed")
+        raise RuntimeError(f"ffmpeg conversion failed: {err}")
     os.replace(tmp.name, str(target))
     if Path(video_path).suffix.lower() != ".mp4":
         try:
@@ -160,14 +159,13 @@ if os.getenv("GOOGLE_API_KEY"):
         genai = genai_mod
         upload_file = genai_mod.upload_file
         get_file = genai_mod.get_file
-        # delete_file may not exist in SDK; guard later
         delete_file = getattr(genai_mod, "delete_file", None)
         HAS_GENAI = True
     except Exception:
         HAS_GENAI = False
 
 def upload_video_sdk(filepath: str):
-    key = os.getenv("GOOGLE_API_KEY")
+    key = get_runtime_api_key()
     if not key:
         raise RuntimeError("No API key")
     if not HAS_GENAI:
@@ -175,7 +173,7 @@ 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=600):
     if not HAS_GENAI or get_file is None:
         return file_obj
     start = time.time()
@@ -184,7 +182,10 @@ def wait_for_processed(file_obj, timeout=180):
         return file_obj
     backoff = 1.0
     while True:
-        obj = get_file(name)
+        try:
+            obj = get_file(name)
+        except Exception:
+            obj = file_obj
         state = getattr(obj, "state", None)
         if not state or getattr(state, "name", None) != "PROCESSING":
             return obj
@@ -251,7 +252,7 @@ if st.sidebar.button("Load Video", use_container_width=True):
         st.session_state["processed_file"] = None
         st.session_state["file_hash"] = file_sha256(path)
     except Exception as e:
-        st.sidebar.error("Failed to load video")
+        st.sidebar.error(f"Failed to load video: {e}")
 
 if st.session_state["videos"]:
     try:
@@ -283,7 +284,6 @@ if st.session_state["videos"]:
             pass
     st.sidebar.write("Title:", Path(st.session_state["videos"]).name)
 
-# controls
 col1, col2 = st.columns([1, 3])
 with col1:
     if st.session_state.get("busy"):
@@ -296,7 +296,6 @@ with col1:
 with col2:
     pass
 
-# determine runtime API key (one-time entry not stored)
 def get_runtime_api_key():
     key = API_KEY_INPUT.strip() if API_KEY_INPUT else ""
     if key:
@@ -311,6 +310,8 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
         runtime_key = get_runtime_api_key()
         if not runtime_key:
             st.error("Google API key not set. Provide in Settings or set GOOGLE_API_KEY in environment.")
+        elif not HAS_GENAI:
+            st.error("google.generativeai SDK not available. Install the SDK to enable uploads/generation.")
         else:
             try:
                 st.session_state["busy"] = True
@@ -325,12 +326,12 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
                 if processed and st.session_state.get("last_loaded_path") == current_path and st.session_state.get("file_hash") == current_hash:
                     reupload_needed = False
 
+                upload_path = current_path
+                uploaded = st.session_state.get("uploaded_file")
+                # If we need to (re)upload
                 if reupload_needed:
-                    if not HAS_GENAI:
-                        raise RuntimeError("google.generativeai SDK not available")
                     local_path = current_path
                     fast_mode = st.session_state.get("fast_mode", False)
-                    upload_path = local_path
                     try:
                         file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
                     except Exception:
@@ -348,21 +349,16 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
                     genai.configure(api_key=runtime_key)
                     with st.spinner("Uploading video..."):
                         uploaded = upload_video_sdk(upload_path)
-                        processed = wait_for_processed(uploaded, timeout=180)
+                        processed = wait_for_processed(uploaded, timeout=600)
                         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
 
-                    # privacy: delete local copy after successful upload (if different path)
-                    try:
-                        if Path(upload_path).exists() and Path(upload_path) != Path(current_path):
-                            Path(upload_path).unlink(missing_ok=True)
-                        # optionally remove original local file to avoid persistence
-                        Path(current_path).unlink(missing_ok=True)
-                        st.session_state["videos"] = ""
-                    except Exception:
-                        pass
+                    # Do not delete original local file until entire generation succeeds.
+                else:
+                    uploaded = st.session_state.get("uploaded_file")
+                    processed = st.session_state.get("processed_file")
 
                 prompt_text = (analysis_prompt or default_prompt).strip()
                 if st.session_state.get("fast_mode"):
@@ -377,22 +373,29 @@ if (st.session_state.get("busy") is False) and ('generate_now' in locals() and g
 
                 def call_responses_once(model_used, system_msg, user_msg, fname, max_tokens):
                     genai.configure(api_key=runtime_key)
-                    try:
-                        response = genai.responses.generate(
-                            model=model_used,
-                            messages=[system_msg, user_msg],
-                            files=[{"name": fname}],
-                            max_output_tokens=max_tokens,
-                        )
-                    except TypeError:
-                        response = genai.responses.generate(
-                            model=model_used,
-                            input=[{"text": user_msg["content"], "files": [{"name": fname}]}],
-                            max_output_tokens=max_tokens,
-                        )
-                    return response
-
-                fname = file_name_or_id(processed) or file_name_or_id(st.session_state.get("uploaded_file"))
+                    for attempt in range(2):
+                        try:
+                            try:
+                                response = genai.responses.generate(
+                                    model=model_used,
+                                    messages=[system_msg, user_msg],
+                                    files=[{"name": fname}],
+                                    max_output_tokens=max_tokens,
+                                )
+                            except TypeError:
+                                response = genai.responses.generate(
+                                    model=model_used,
+                                    input=[{"text": user_msg["content"], "files": [{"name": fname}]}],
+                                    max_output_tokens=max_tokens,
+                                )
+                            return response
+                        except Exception as e:
+                            if attempt == 0:
+                                time.sleep(1.0)
+                                continue
+                            raise
+
+                fname = file_name_or_id(processed) or file_name_or_id(uploaded)
                 if not fname:
                     try:
                         uri = getattr(processed, "uri", None) or (processed.get("uri") if isinstance(processed, dict) else None)
@@ -467,22 +470,41 @@ 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)_")
 
-                # compact debug (user-triggered)
+                # delete local copies now that generation succeeded (if upload created temporary compressed file)
+                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)
+                        # optionally remove original local file to avoid persistence
+                        Path(current_path).unlink(missing_ok=True)
+                        st.session_state["videos"] = ""
+                except Exception:
+                    pass
+
                 with st.expander("Debug (compact)", expanded=False):
                     try:
                         info = {
                             "model": model_used,
                             "output_tokens": output_tokens,
                             "upload_succeeded": bool(st.session_state.get("uploaded_file")),
-                            "processed_active": getattr(st.session_state.get("processed_file"), "state", None) if st.session_state.get("processed_file") else None,
+                            "processed_state": getattr(st.session_state.get("processed_file"), "state", None) if st.session_state.get("processed_file") else None,
                         }
                         st.write(info)
+                        # truncated response keys for debugging
+                        try:
+                            if isinstance(response, dict):
+                                keys = list(response.keys())[:20]
+                            else:
+                                keys = [k for k in dir(response) if not k.startswith("_")][:20]
+                            st.write({"response_keys_or_attrs": keys})
+                        except Exception:
+                            pass
                     except Exception:
                         st.write("Debug info unavailable")
 
             except Exception as e:
-                st.session_state["last_error"] = "Generation error"
-                st.error("An error occurred while generating the story.")
+                st.session_state["last_error"] = str(e)
+                st.error(f"An error occurred while generating the story: {e}")
             finally:
                 st.session_state["busy"] = False
 
@@ -498,7 +520,6 @@ if st.session_state.get("last_error"):
 # delete uploaded files (local + cloud if possible)
 with st.sidebar.expander("Manage uploads", expanded=False):
     if st.button("Delete uploaded files (local + cloud)"):
-        # delete local files
         for f in glob(str(DATA_DIR / "*")):
             try:
                 Path(f).unlink(missing_ok=True)
@@ -510,7 +531,6 @@ with st.sidebar.expander("Manage uploads", expanded=False):
         st.session_state["last_loaded_path"] = ""
         st.session_state["analysis_out"] = ""
         st.session_state["file_hash"] = None
-        # attempt to delete cloud file if SDK supports it
         try:
             fname = file_name_or_id(st.session_state.get("uploaded_file"))
             if fname and delete_file and HAS_GENAI: