Update streamlit_app.py

streamlit_app.py

@@ -8,9 +8,10 @@ from glob import glob
 from pathlib import Path
 from difflib import SequenceMatcher
 import json
+import logging
 
 import yt_dlp
-import ffmpeg
+import ffmpeg  # ffmpeg-python
 import streamlit as st
 from dotenv import load_dotenv
 
@@ -21,6 +22,7 @@ try:
     from phi.agent import Agent
     from phi.model.google import Gemini
     from phi.tools.duckduckgo import DuckDuckGo
+
     HAS_PHI = True
 except Exception:
     Agent = Gemini = DuckDuckGo = None
@@ -30,12 +32,15 @@ except Exception:
 try:
     import google.generativeai as genai
     from google.generativeai import upload_file, get_file
+
     HAS_GENAI = True
 except Exception:
     genai = None
     upload_file = get_file = None
     HAS_GENAI = False
 
+logging.basicConfig(level=logging.INFO)
+
 st.set_page_config(page_title="Generate the story of videos", layout="wide")
 DATA_DIR = Path("./data")
 DATA_DIR.mkdir(exist_ok=True)
@@ -92,11 +97,19 @@ def convert_video_to_mp4(video_path: str) -> str:
     target_path = str(Path(video_path).with_suffix(".mp4"))
     if os.path.exists(target_path):
         return target_path
-    ffmpeg.input(video_path).output(target_path).run(overwrite_output=True, quiet=True)
     try:
-        os.remove(video_path)
-    except Exception:
-        pass
+        ffmpeg.input(video_path).output(target_path).run(overwrite_output=True, quiet=True)
+    except Exception as e:
+        logging.exception("ffmpeg conversion failed")
+        # If conversion fails, do not delete original; re-raise for caller to handle if needed
+        raise
+    # Only remove source if target exists and is non-empty
+    if os.path.exists(target_path) and os.path.getsize(target_path) > 0:
+        try:
+            if str(Path(video_path).resolve()) != str(Path(target_path).resolve()):
+                os.remove(video_path)
+        except Exception:
+            logging.exception("Failed to remove original video after conversion")
     return target_path
 
 def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str = "fast"):
@@ -104,8 +117,12 @@ def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str
         ffmpeg.input(input_path).output(
             target_path, vcodec="libx264", crf=crf, preset=preset
         ).run(overwrite_output=True, quiet=True)
-        return target_path
+        if os.path.exists(target_path) and os.path.getsize(target_path) > 0:
+            return target_path
+        logging.warning("Compression completed but target missing or empty; returning input path")
+        return input_path
     except Exception:
+        logging.exception("Video compression failed")
         return input_path
 
 def download_video_ytdlp(url: str, save_dir: str, video_password: str = None) -> str:
@@ -114,24 +131,46 @@ def download_video_ytdlp(url: str, save_dir: str, video_password: str = None) ->
     outtmpl = str(Path(save_dir) / "%(id)s.%(ext)s")
     ydl_opts = {"outtmpl": outtmpl, "format": "best"}
     if video_password:
+        # yt-dlp accepts 'videopassword' in options for password-protected videos
         ydl_opts["videopassword"] = video_password
     with yt_dlp.YoutubeDL(ydl_opts) as ydl:
         info = ydl.extract_info(url, download=True)
-    video_id = info.get("id") if isinstance(info, dict) else None
-    if video_id:
-        matches = glob(os.path.join(save_dir, f"{video_id}.*"))
-    else:
+    # info may be a dict for single video or playlist; prefer single entry if present
+    video_candidates = []
+    if isinstance(info, dict):
+        # playlist -> entries list
+        entries = info.get("entries")
+        if entries:
+            # get last-downloaded entry (entries may be nested); map to filesystem files by ids
+            for e in entries:
+                if isinstance(e, dict) and e.get("id"):
+                    video_candidates.append(str(Path(save_dir) / f"{e['id']}.mp4"))
+        else:
+            vid = info.get("id")
+            ext = info.get("ext") or "mp4"
+            if vid:
+                video_candidates.append(str(Path(save_dir) / f"{vid}.{ext}"))
+    # fallback: pick most recent file in dir
+    if not video_candidates:
         all_files = glob(os.path.join(save_dir, "*"))
-        matches = sorted(all_files, key=os.path.getmtime, reverse=True)[:1] if all_files else []
-    if not matches:
-        raise FileNotFoundError("Downloaded video not found")
-    return convert_video_to_mp4(matches[0])
+        if not all_files:
+            raise FileNotFoundError("Downloaded video not found")
+        matches = sorted(all_files, key=os.path.getmtime, reverse=True)
+        chosen = matches[0]
+    else:
+        # prefer existing files among candidates; pick first that exists, else fall back to newest
+        existing = [p for p in video_candidates if os.path.exists(p)]
+        chosen = existing[0] if existing else (sorted(glob(os.path.join(save_dir, "*")), key=os.path.getmtime, reverse=True)[0])
+    # Ensure mp4 target
+    final = convert_video_to_mp4(chosen)
+    return final
 
 def file_name_or_id(file_obj):
     if file_obj is None:
         return None
     if isinstance(file_obj, dict):
         return file_obj.get("name") or file_obj.get("id")
+    # common SDK wrappers may expose 'name', 'id', 'fileId'
     return getattr(file_obj, "name", None) or getattr(file_obj, "id", None) or getattr(file_obj, "fileId", None)
 
 def get_effective_api_key():
@@ -144,7 +183,7 @@ def configure_genai_if_needed():
     try:
         genai.configure(api_key=key)
     except Exception:
-        pass
+        logging.exception("genai.configure failed")
     return True
 
 # ---- Agent management (reuse) ----
@@ -162,6 +201,7 @@ def maybe_create_agent(model_id: str):
         _agent = Agent(name="Video AI summarizer", model=Gemini(id=model_id), tools=[DuckDuckGo()], markdown=True)
         st.session_state["last_model"] = model_id
     except Exception:
+        logging.exception("Failed to create PHI Agent")
         _agent = None
     return _agent
 
@@ -177,7 +217,7 @@ def clear_all_video_state():
         try:
             os.remove(f)
         except Exception:
-            pass
+            logging.exception("Failed to remove data file during clear_all_video_state")
 
 # Reset when URL changes
 current_url = st.session_state.get("url", "")
@@ -195,6 +235,7 @@ if model_choice == "custom":
     model_input = settings_exp.text_input("Custom model id", value=DEFAULT_MODEL, key="model_input")
     model_selected = model_input.strip() or DEFAULT_MODEL
 else:
+    # keep model_input in session_state for later reads
     st.session_state["model_input"] = model_choice
     model_selected = model_choice
 
@@ -238,6 +279,7 @@ def upload_video_sdk(filepath: str):
     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 may return object with id or name, keep as-is
     return upload_file(filepath)
 
 def wait_for_processed(file_obj, timeout: int = None):
@@ -298,10 +340,14 @@ def compress_video_if_large(local_path: str, threshold_mb: int = 200):
     if file_size_mb <= threshold_mb:
         return local_path, False
 
-    compressed_path = str(Path(local_path).with_name(Path(local_path).stem + "_compressed.mp4"))
+    # build compressed path reliably
+    p = Path(local_path)
+    compressed_name = f"{p.stem}_compressed.mp4"
+    compressed_path = str(p.with_name(compressed_name))
+
     try:
         result = compress_video(local_path, compressed_path, crf=28, preset="fast")
-        if result and os.path.exists(result):
+        if result and os.path.exists(result) and os.path.getsize(result) > 0:
             return result, True
         return local_path, False
     except Exception as e:
@@ -339,10 +385,12 @@ def generate_via_responses_api(prompt_text: str, processed, model_used: str, max
             except Exception as e:
                 last_exc = e
                 msg = str(e).lower()
+                # retry for transient/server errors
                 if any(k in msg for k in ("internal", "unavailable", "deadlineexceeded", "deadline exceeded", "timeout", "rate limit")):
-                    pass
-                else:
-                    raise
+                    logging.warning("Transient error from Responses API, will retry: %s", e)
+                    continue
+                logging.exception("Non-retryable Responses API error")
+                raise
         if time.time() - start > timeout:
             raise TimeoutError(f"Responses.generate timed out after {timeout}s: last error: {last_exc}")
         time.sleep(backoff)
@@ -423,6 +471,14 @@ def safe_traceback(max_chars=2000):
     tb = traceback.format_exc()
     return tb if len(tb) <= max_chars else tb[:max_chars] + "\n...[truncated]"
 
+def scrub_api_keys(s: str) -> str:
+    if not s:
+        return s
+    key = get_effective_api_key()
+    if key and key in s:
+        return s.replace(key, "[REDACTED_API_KEY]")
+    return s
+
 # ---- Layout ----
 col1, col2 = st.columns([1, 3])
 with col1:
@@ -443,6 +499,7 @@ if st.sidebar.button("Load Video", use_container_width=True):
         except Exception:
             st.session_state["file_hash"] = None
     except Exception as e:
+        logging.exception("Failed to load video")
         st.sidebar.error(f"Failed to load video: {e}")
 
 if st.session_state["videos"]:
@@ -488,7 +545,7 @@ if generate_now and not st.session_state.get("busy"):
                     if HAS_GENAI and genai is not None:
                         genai.configure(api_key=key_to_use)
                 except Exception:
-                    pass
+                    logging.exception("genai.configure failed at start")
 
                 model_id = (st.session_state.get("model_input") or model_selected or DEFAULT_MODEL).strip()
                 if st.session_state.get("last_model") != model_id:
@@ -519,7 +576,8 @@ if generate_now and not st.session_state.get("busy"):
                         try:
                             uploaded = upload_video_sdk(upload_path)
                         except Exception as e:
-                            st.session_state["last_error"] = f"Upload failed: {e}\n\nTraceback:\n{safe_traceback()}"
+                            err = scrub_api_keys(f"Upload failed: {e}\n\nTraceback:\n{safe_traceback()}")
+                            st.session_state["last_error"] = err
                             st.error("Upload failed. See Last Error for details.")
                             raise
 
@@ -535,7 +593,8 @@ if generate_now and not st.session_state.get("busy"):
                         processing_bar.progress(pct)
                         processing_placeholder.success("Processing complete")
                     except Exception as e:
-                        st.session_state["last_error"] = f"Processing failed/wait timeout: {e}\n\nTraceback:\n{safe_traceback()}"
+                        err = scrub_api_keys(f"Processing failed/wait timeout: {e}\n\nTraceback:\n{safe_traceback()}")
+                        st.session_state["last_error"] = err
                         st.error("Video processing failed or timed out. See Last Error.")
                         raise
 
@@ -586,7 +645,7 @@ if generate_now and not st.session_state.get("busy"):
                             out = generate_via_responses_api(prompt_text, processed, model_used, max_tokens=max_tokens, timeout=st.session_state.get("generation_timeout", 300))
                     except Exception as e:
                         tb = traceback.format_exc()
-                        st.session_state["last_error"] = f"Responses API error: {e}\n\nDebug: {debug_info}\n\nTraceback:\n{safe_traceback()}"
+                        st.session_state["last_error"] = scrub_api_keys(f"Responses API error: {e}\n\nDebug: {debug_info}\n\nTraceback:\n{safe_traceback()}")
                         st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
                         out = ""
 
@@ -611,7 +670,8 @@ 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', {})}\n\nTraceback:\n{safe_traceback()}"
+                err = scrub_api_keys(f"{e}\n\nDebug: {locals().get('debug_info', {})}\n\nTraceback:\n{safe_traceback()}")
+                st.session_state["last_error"] = err
                 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