Update streamlit_app.py

streamlit_app.py

@@ -1,4 +1,3 @@
-# streamlit_app.py
 import os
 import time
 import string
@@ -6,18 +5,15 @@ import hashlib
 import traceback
 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
 
 load_dotenv()
 
-# Optional PHI integration
+# Optional PHI integration (kept guarded)
 try:
     from phi.agent import Agent
     from phi.model.google import Gemini
@@ -28,7 +24,7 @@ except Exception:
     Agent = Gemini = DuckDuckGo = None
     HAS_PHI = False
 
-# google.generativeai SDK
+# google.generativeai SDK (guarded)
 try:
     import google.generativeai as genai
     from google.generativeai import upload_file, get_file
@@ -39,8 +35,6 @@ except Exception:
     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)
@@ -72,8 +66,6 @@ st.session_state.setdefault("last_error", "")
 st.session_state.setdefault("file_hash", None)
 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", 900)
 st.session_state.setdefault("generation_timeout", 300)
 st.session_state.setdefault("compress_threshold_mb", 200)
@@ -99,17 +91,16 @@ def convert_video_to_mp4(video_path: str) -> str:
         return target_path
     try:
         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
+    except Exception:
+        # re-raise so caller can handle
         raise
-    # Only remove source if target exists and is non-empty
+    # remove source only if different and successful
     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")
+            pass
     return target_path
 
 def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str = "fast"):
@@ -119,10 +110,8 @@ def compress_video(input_path: str, target_path: str, crf: int = 28, preset: str
         ).run(overwrite_output=True, quiet=True)
         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:
@@ -131,37 +120,29 @@ 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)
-    # info may be a dict for single video or playlist; prefer single entry if present
-    video_candidates = []
+    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"))
+                    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:
+                candidates.append(str(Path(save_dir) / f"{vid}.{ext}"))
+    if not candidates:
         all_files = glob(os.path.join(save_dir, "*"))
         if not all_files:
             raise FileNotFoundError("Downloaded video not found")
-        matches = sorted(all_files, key=os.path.getmtime, reverse=True)
-        chosen = matches[0]
+        chosen = sorted(all_files, key=os.path.getmtime, reverse=True)[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
+        existing = [p for p in 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]
     final = convert_video_to_mp4(chosen)
     return final
 
@@ -170,7 +151,6 @@ def file_name_or_id(file_obj):
         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():
@@ -183,7 +163,7 @@ def configure_genai_if_needed():
     try:
         genai.configure(api_key=key)
     except Exception:
-        logging.exception("genai.configure failed")
+        pass
     return True
 
 # ---- Agent management (reuse) ----
@@ -201,7 +181,6 @@ 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
 
@@ -217,13 +196,13 @@ def clear_all_video_state():
         try:
             os.remove(f)
         except Exception:
-            logging.exception("Failed to remove data file during clear_all_video_state")
+            pass
 
 # Reset when URL changes
 current_url = st.session_state.get("url", "")
-if current_url != st.session_state.get("last_url_value"):
+if current_url != st.session_state.get("last_loaded_path"):
     clear_all_video_state()
-    st.session_state["last_url_value"] = current_url
+    st.session_state["last_loaded_path"] = current_url
 
 # ---- Sidebar UI ----
 st.sidebar.header("Video Input")
@@ -235,7 +214,6 @@ 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
 
@@ -260,7 +238,7 @@ settings_exp.number_input(
 )
 
 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}**")
+settings_exp.caption(f"Using API key from: {key_source}")
 if not get_effective_api_key():
     settings_exp.warning("No Google API key provided; upload/generation disabled.", icon="⚠️")
 
@@ -279,7 +257,6 @@ 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):
@@ -295,9 +272,9 @@ def wait_for_processed(file_obj, timeout: int = None):
     while True:
         try:
             obj = get_file(name)
-        except Exception as e:
+        except Exception:
             if time.time() - start > timeout:
-                raise TimeoutError(f"Failed to fetch file status before timeout: {e}")
+                raise TimeoutError("Failed to fetch file status before timeout")
             time.sleep(backoff)
             backoff = min(backoff * 2, 8.0)
             continue
@@ -307,7 +284,7 @@ def wait_for_processed(file_obj, timeout: int = None):
             return obj
 
         if time.time() - start > timeout:
-            raise TimeoutError(f"File processing timed out after {int(time.time() - start)}s")
+            raise TimeoutError("File processing timed out")
         time.sleep(backoff)
         backoff = min(backoff * 2, 8.0)
 
@@ -317,7 +294,11 @@ def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_thres
     a = " ".join(prompt.strip().lower().split())
     b_full = text.strip()
     b = " ".join(b_full[:check_len].lower().split())
-    ratio = SequenceMatcher(None, a, b).ratio()
+    try:
+        from difflib import SequenceMatcher
+        ratio = SequenceMatcher(None, a, b).ratio()
+    except Exception:
+        ratio = 0.0
     if ratio >= ratio_threshold:
         cut = min(len(b_full), max(int(len(prompt) * 0.9), len(a)))
         new_text = b_full[cut:].lstrip(" \n:-")
@@ -333,14 +314,13 @@ def remove_prompt_echo(prompt: str, text: str, check_len: int = 600, ratio_thres
 def compress_video_if_large(local_path: str, threshold_mb: int = 200):
     try:
         file_size_mb = os.path.getsize(local_path) / (1024 * 1024)
-    except Exception as e:
-        st.session_state["last_error"] = f"Failed to stat file before compression: {e}"
+    except Exception:
+        st.session_state["last_error"] = "Failed to stat file before compression"
         return local_path, False
 
     if file_size_mb <= threshold_mb:
         return local_path, False
 
-    # build compressed path reliably
     p = Path(local_path)
     compressed_name = f"{p.stem}_compressed.mp4"
     compressed_path = str(p.with_name(compressed_name))
@@ -350,136 +330,11 @@ def compress_video_if_large(local_path: str, threshold_mb: int = 200):
         if result and os.path.exists(result) and os.path.getsize(result) > 0:
             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()}"
+    except Exception:
+        st.session_state["last_error"] = "Video compression failed"
         return local_path, False
 
-# ---- Responses API integration ----
-def generate_via_responses_api(prompt_text: str, processed, model_used: str, max_tokens: int = 1024, timeout: int = 300):
-    key = get_effective_api_key()
-    if not key:
-        raise RuntimeError("No API key provided")
-    if not HAS_GENAI or genai is None:
-        raise RuntimeError("Responses API not available; install google.generativeai SDK.")
-    genai.configure(api_key=key)
-    fname = file_name_or_id(processed)
-    if not fname:
-        raise RuntimeError("Uploaded file missing name/id")
-
-    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},
-    ]
-
-    last_exc = None
-    start = time.time()
-    backoff = 1.0
-    while True:
-        for payload in call_variants:
-            try:
-                response = genai.responses.generate(model=model_used, **payload)
-                return _normalize_genai_response(response)
-            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")):
-                    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)
-        backoff = min(backoff * 2, 8.0)
-
-def _normalize_genai_response(response):
-    outputs = []
-    if response is None:
-        return ""
-
-    if not isinstance(response, dict):
-        try:
-            response = json.loads(str(response))
-        except Exception:
-            pass
-
-    candidate_lists = []
-    if isinstance(response, dict):
-        for key in ("output", "candidates", "items", "responses", "choices"):
-            val = response.get(key)
-            if isinstance(val, list) and val:
-                candidate_lists.append(val)
-    if not candidate_lists and isinstance(response, dict):
-        for v in response.values():
-            if isinstance(v, list) and v:
-                candidate_lists.append(v)
-                break
-
-    text_pieces = []
-    for lst in candidate_lists:
-        for item in lst:
-            if not item:
-                continue
-            if isinstance(item, dict):
-                for k in ("content", "text", "message", "output_text", "output"):
-                    t = item.get(k)
-                    if t:
-                        text_pieces.append(str(t).strip())
-                        break
-                else:
-                    if "content" in item and isinstance(item["content"], list):
-                        for part in item["content"]:
-                            if isinstance(part, dict):
-                                t = part.get("text") or part.get("content")
-                                if t:
-                                    text_pieces.append(str(t).strip())
-                            elif isinstance(part, str):
-                                text_pieces.append(part.strip())
-            elif isinstance(item, str):
-                text_pieces.append(item.strip())
-            else:
-                try:
-                    t = getattr(item, "text", None) or getattr(item, "content", None)
-                    if t:
-                        text_pieces.append(str(t).strip())
-                except Exception:
-                    pass
-
-    if not text_pieces and isinstance(response, dict):
-        for k in ("text", "message", "output_text"):
-            v = response.get(k)
-            if v:
-                text_pieces.append(str(v).strip())
-                break
-
-    seen = set()
-    filtered = []
-    for t in text_pieces:
-        if not isinstance(t, str):
-            continue
-        if t and t not in seen:
-            filtered.append(t)
-            seen.add(t)
-    return "\n\n".join(filtered).strip()
-
-# ---- small helpers for safer tracebacks ----
-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 ----
+# ---- Simple layout ----
 col1, col2 = st.columns([1, 3])
 with col1:
     generate_now = st.button("Generate the story", type="primary", disabled=not bool(get_effective_api_key()))
@@ -499,12 +354,16 @@ 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"]:
+    path = st.session_state["videos"]
+    # ensure mp4 for preview and read bytes for reliable preview
     try:
-        st.sidebar.video(st.session_state["videos"], loop=st.session_state.get("loop_video", False))
+        mp4_path = convert_video_to_mp4(path)
+        with open(mp4_path, "rb") as vf:
+            video_bytes = vf.read()
+        st.sidebar.video(video_bytes, format="video/mp4", start_time=0)
     except Exception:
         st.sidebar.write("Couldn't preview video")
 
@@ -530,7 +389,7 @@ if st.session_state["videos"]:
     except Exception:
         pass
 
-# ---- Main generation flow ----
+# ---- Generation flow (minimal) ----
 if generate_now and not st.session_state.get("busy"):
     if not st.session_state.get("videos"):
         st.error("No video loaded. Use 'Load Video' in the sidebar.")
@@ -545,7 +404,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:
-                    logging.exception("genai.configure failed at start")
+                    pass
 
                 model_id = (st.session_state.get("model_input") or model_selected or DEFAULT_MODEL).strip()
                 if st.session_state.get("last_model") != model_id:
@@ -559,7 +418,6 @@ if generate_now and not st.session_state.get("busy"):
                 except Exception:
                     current_hash = None
 
-                # determine if reupload is needed: same local path + same hash + we have uploaded/processed file id
                 reupload_needed = True
                 uploaded_file = st.session_state.get("uploaded_file")
                 uploaded_name = file_name_or_id(uploaded_file)
@@ -576,8 +434,7 @@ if generate_now and not st.session_state.get("busy"):
                         try:
                             uploaded = upload_video_sdk(upload_path)
                         except Exception as e:
-                            err = scrub_api_keys(f"Upload failed: {e}\n\nTraceback:\n{safe_traceback()}")
-                            st.session_state["last_error"] = err
+                            st.session_state["last_error"] = f"Upload failed: {e}"
                             st.error("Upload failed. See Last Error for details.")
                             raise
 
@@ -586,15 +443,13 @@ if generate_now and not st.session_state.get("busy"):
                         processing_bar = processing_placeholder.progress(0)
                         start_time = time.time()
                         processed = wait_for_processed(uploaded, timeout=st.session_state.get("processing_timeout", 900))
-                        # update progress once after wait (full incremental requires moving polling here)
                         elapsed = time.time() - start_time
                         timeout = st.session_state.get("processing_timeout", 900)
                         pct = min(100, int((elapsed / timeout) * 100)) if timeout > 0 else 0
                         processing_bar.progress(pct)
                         processing_placeholder.success("Processing complete")
                     except Exception as e:
-                        err = scrub_api_keys(f"Processing failed/wait timeout: {e}\n\nTraceback:\n{safe_traceback()}")
-                        st.session_state["last_error"] = err
+                        st.session_state["last_error"] = f"Processing failed/wait timeout: {e}"
                         st.error("Video processing failed or timed out. See Last Error.")
                         raise
 
@@ -621,14 +476,11 @@ if generate_now and not st.session_state.get("busy"):
                             agent_response = agent.run(prompt_text, videos=[processed], safety_settings=safety_settings)
                             agent_text = getattr(agent_response, "content", None) or getattr(agent_response, "outputText", None) or None
                             if not agent_text:
-                                try:
-                                    if isinstance(agent_response, dict):
-                                        for k in ("content", "outputText", "text", "message"):
-                                            if k in agent_response and agent_response[k]:
-                                                agent_text = agent_response[k]
-                                                break
-                                except Exception:
-                                    pass
+                                if isinstance(agent_response, dict):
+                                    for k in ("content", "outputText", "text", "message"):
+                                        if k in agent_response and agent_response[k]:
+                                            agent_text = agent_response[k]
+                                            break
                             if agent_text and str(agent_text).strip():
                                 out = str(agent_text).strip()
                                 debug_info["agent_ok"] = True
@@ -637,15 +489,92 @@ if generate_now and not st.session_state.get("busy"):
                                 debug_info["agent_ok"] = False
                     except Exception as ae:
                         debug_info["agent_error"] = f"{ae}"
-                        debug_info["agent_traceback"] = traceback.format_exc()
 
                 if not out:
+                    # Use Responses API directly
+                    def generate_via_responses_api(prompt_text: str, processed, model_used: str, max_tokens: int = 1024, timeout: int = 300):
+                        key = get_effective_api_key()
+                        if not key:
+                            raise RuntimeError("No API key provided")
+                        if not HAS_GENAI or genai is None:
+                            raise RuntimeError("Responses API not available")
+                        genai.configure(api_key=key)
+                        fname = file_name_or_id(processed)
+                        if not fname:
+                            raise RuntimeError("Uploaded file missing name/id")
+
+                        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},
+                        ]
+
+                        last_exc = None
+                        start = time.time()
+                        backoff = 1.0
+                        while True:
+                            for payload in call_variants:
+                                try:
+                                    response = genai.responses.generate(model=model_used, **payload)
+                                    return _normalize_genai_response(response)
+                                except Exception as e:
+                                    last_exc = e
+                                    msg = str(e).lower()
+                                    if any(k in msg for k in ("internal", "unavailable", "deadlineexceeded", "deadline exceeded", "timeout", "rate limit")):
+                                        continue
+                                    raise
+                            if time.time() - start > timeout:
+                                raise TimeoutError("Responses.generate timed out")
+                            time.sleep(backoff)
+                            backoff = min(backoff * 2, 8.0)
+
+                    def _normalize_genai_response(response):
+                        outputs = []
+                        if response is None:
+                            return ""
+                        # response may be SDK object or dict-like; coerce to string chunks
+                        text_pieces = []
+                        try:
+                            if isinstance(response, dict):
+                                for key in ("output", "candidates", "items", "responses", "choices"):
+                                    val = response.get(key)
+                                    if isinstance(val, list) and val:
+                                        for item in val:
+                                            if isinstance(item, dict):
+                                                for k in ("content", "text", "message", "output_text", "output"):
+                                                    t = item.get(k)
+                                                    if t:
+                                                        text_pieces.append(str(t).strip())
+                                                        break
+                                            elif isinstance(item, str):
+                                                text_pieces.append(item.strip())
+                                if not text_pieces:
+                                    for k in ("text", "message", "output_text"):
+                                        v = response.get(k)
+                                        if v:
+                                            text_pieces.append(str(v).strip())
+                                            break
+                            else:
+                                text_pieces.append(str(response))
+                        except Exception:
+                            text_pieces.append(str(response))
+                        seen = set()
+                        filtered = []
+                        for t in text_pieces:
+                            if not isinstance(t, str):
+                                continue
+                            if t and t not in seen:
+                                filtered.append(t)
+                                seen.add(t)
+                        return "\n\n".join(filtered).strip()
+
                     try:
                         with st.spinner("Generating description via Responses API..."):
                             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"] = scrub_api_keys(f"Responses API error: {e}\n\nDebug: {debug_info}\n\nTraceback:\n{safe_traceback()}")
+                        st.session_state["last_error"] = f"Responses API error: {e}\nDebug: {debug_info}"
                         st.error("An error occurred while generating the story. You can try Generate again; the uploaded video will be reused.")
                         out = ""
 
@@ -669,18 +598,14 @@ if generate_now and not st.session_state.get("busy"):
                 st.caption(f"Est. max tokens: {est_tokens}")
 
             except Exception as e:
-                tb = traceback.format_exc()
-                err = scrub_api_keys(f"{e}\n\nDebug: {locals().get('debug_info', {})}\n\nTraceback:\n{safe_traceback()}")
-                st.session_state["last_error"] = err
+                st.session_state["last_error"] = f"{e}"
                 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
 
 if st.session_state.get("analysis_out"):
-    just_loaded_same = (st.session_state.get("last_loaded_path") == st.session_state.get("videos"))
-    if not just_loaded_same:
-        st.subheader("Analysis Result")
-        st.markdown(st.session_state.get("analysis_out"))
+    st.subheader("Analysis Result")
+    st.markdown(st.session_state.get("analysis_out"))
 
 if st.session_state.get("last_error"):
     with st.expander("Last Error", expanded=False):