Update streamlit_app.py

streamlit_app.py

@@ -1,4 +1,3 @@
-# streamlit_app.py
 import os
 import time
 import json
@@ -10,24 +9,30 @@ import yt_dlp
 import ffmpeg
 import streamlit as st
 from dotenv import load_dotenv
-import requests
 
 load_dotenv()
 
-# Try to import the Google SDK
-HAS_GENAI = False
-GENAI = None
+# Try imports (phi and google SDK)
+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
+    HAS_PHI = False
+
 try:
     import google.generativeai as genai
     from google.generativeai import upload_file, get_file
     GENAI = genai
     HAS_GENAI = True
 except Exception:
-    upload_file = None
-    get_file = None
+    upload_file = get_file = None
+    GENAI = None
+    HAS_GENAI = False
 
 st.set_page_config(page_title="Generate the story of videos:", layout="wide")
-
 DATA_DIR = Path("./data")
 DATA_DIR.mkdir(exist_ok=True)
 
@@ -42,8 +47,8 @@ settings_exp = st.sidebar.expander("Settings", expanded=False)
 env_api_key = os.getenv("GOOGLE_API_KEY", "")
 API_KEY = settings_exp.text_input("Google API Key", value=env_api_key, placeholder="Set GOOGLE_API_KEY in .env or enter here")
 
-raw_model = settings_exp.text_input("Gemini Model (model name)", "gemini-2.0-flash-lite")
-model_id = raw_model.strip() or "gemini-2.0-flash-lite"
+model_input = settings_exp.text_input("Gemini Model (short name)", "gemini-2.0-flash-lite")
+model_id = model_input.strip() or "gemini-2.0-flash-lite"
 
 analysis_prompt = settings_exp.text_area("Enter analysis", "watch entire video and describe")
 settings_exp.text_input("Video Password", key="video-password", placeholder="Enter Video Password (if needed)")
@@ -93,12 +98,22 @@ def download_video_ytdlp(url: str, save_dir: str, video_password: str = None) ->
         raise FileNotFoundError("Downloaded video not found")
     return convert_video_to_mp4(matches[0])
 
+# configure GENAI if available
 if API_KEY and HAS_GENAI:
     try:
         GENAI.configure(api_key=API_KEY)
     except Exception:
         pass
 
+# initialize phi Agent if available (uses Gemini wrapper)
+_agent = None
+if HAS_PHI and HAS_GENAI and API_KEY:
+    try:
+        _agent = Agent(name="Video AI summarizer", model=Gemini(id=model_id), tools=[DuckDuckGo()], markdown=True)
+    except Exception:
+        _agent = None
+
+# UI actions
 if st.sidebar.button("Load Video", use_container_width=True):
     try:
         video_password = st.session_state.get("video-password", "")
@@ -139,79 +154,26 @@ if st.session_state["videos"]:
 
     st.sidebar.write("Title:", Path(st.session_state["videos"]).name)
 
-def upload_video(filepath: str):
+def upload_video_sdk(filepath: str):
     if not API_KEY:
         raise RuntimeError("No API key provided")
-    if HAS_GENAI and callable(upload_file):
-        return upload_file(filepath)
-    url = "https://generative.googleapis.com/v1beta2/files?uploadType=multipart"
-    headers = {"Authorization": f"Bearer {API_KEY}"}
-    metadata = {"mimeType": "video/mp4", "displayName": Path(filepath).name}
-    files = {
-        "metadata": ("metadata", json.dumps(metadata), "application/json"),
-        "file": (Path(filepath).name, open(filepath, "rb"), "video/mp4"),
-    }
-    r = requests.post(url, headers=headers, files=files)
-    r.raise_for_status()
-    return r.json()
+    return upload_file(filepath)
 
-def poll_file_processed(file_obj, timeout=180):
+def wait_for_processed(file_obj, timeout=180):
     start = time.time()
-    if HAS_GENAI and hasattr(file_obj, "name"):
-        name = file_obj.name
-        while getattr(file_obj, "state", None) and getattr(file_obj.state, "name", None) == "PROCESSING":
-            if time.time() - start > timeout:
-                raise TimeoutError("File processing timed out")
-            time.sleep(2)
-            file_obj = get_file(name)
-        return file_obj
-    fid = file_obj.get("name") or file_obj.get("id")
-    if not fid:
+    name = getattr(file_obj, "name", None) or file_obj.get("name") or file_obj.get("id")
+    if not name:
         return file_obj
-    url = f"https://generative.googleapis.com/v1beta2/{fid}"
-    headers = {"Authorization": f"Bearer {API_KEY}"}
     while True:
-        r = requests.get(url, headers=headers)
-        r.raise_for_status()
-        j = r.json()
-        state = j.get("state", {}).get("name") if j.get("state") else None
-        if state != "PROCESSING":
-            return j
+        obj = get_file(name)
+        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")
         time.sleep(2)
 
-def call_model_with_file(prompt_text: str, uploaded_file_obj):
-    if not API_KEY:
-        raise RuntimeError("No API key provided")
-
-    file_ref_name = (
-        uploaded_file_obj.name
-        if hasattr(uploaded_file_obj, "name")
-        else uploaded_file_obj.get("name") or uploaded_file_obj.get("id")
-    )
-
-    if HAS_GENAI and hasattr(GENAI, "responses") and hasattr(GENAI.responses, "generate"):
-        request = {
-            "model": f"models/{model_id}",
-            "input": [{"text": prompt_text, "files": [{"name": file_ref_name}]}],
-            "safetySettings": safety_settings,
-            "maxOutputTokens": 1000,
-        }
-        return GENAI.responses.generate(**request)
-
-    model_short = model_id.split("/")[-1]
-    endpoint = f"https://generativeapis.googleapis.com/v1/models/{model_short}:generate"
-    body = {
-        "input": [{"text": prompt_text, "files": [{"name": file_ref_name}]}],
-        "safetySettings": safety_settings,
-        "maxOutputTokens": 1000,
-    }
-    headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
-    r = requests.post(endpoint, headers=headers, json=body, timeout=180)
-    r.raise_for_status()
-    return r.json()
-
+# Main generate (Agent.run flow)
 if st.button("Generate the story", type="primary"):
     if not st.session_state.get("videos"):
         st.error("No video loaded. Use 'Load Video' in the sidebar.")
@@ -220,41 +182,35 @@ if st.button("Generate the story", type="primary"):
     else:
         try:
             with st.spinner("Uploading video..."):
-                uploaded = upload_video(st.session_state["videos"])
-                processed = poll_file_processed(uploaded)
+                uploaded = upload_video_sdk(st.session_state["videos"])
+                processed = wait_for_processed(uploaded)
 
             prompt_text = (analysis_prompt.strip() or "Describe this video in vivid detail.").strip()
 
-            with st.spinner("Generating description..."):
-                result = call_model_with_file(prompt_text, processed)
-
-            text_out = ""
-            if isinstance(result, dict):
-                if "output" in result:
-                    try:
-                        for item in result.get("output", []):
-                            for c in item.get("content", []):
-                                if c.get("type") in ("output_text", "text"):
-                                    text_out += c.get("text", "")
-                    except Exception:
-                        text_out = json.dumps(result)
-                elif "candidates" in result:
-                    for cand in result["candidates"]:
-                        if isinstance(cand.get("content"), str):
-                            text_out += cand.get("content", "")
-                        elif isinstance(cand.get("content"), list):
-                            for part in cand.get("content"):
-                                text_out += part.get("text", "") if isinstance(part, dict) else str(part)
-                elif "outputText" in result:
-                    text_out = result.get("outputText") or result.get("output_text") or ""
-                elif "generatedText" in result:
-                    text_out = result.get("generatedText")
-                else:
-                    text_out = json.dumps(result, indent=2)
+            if _agent:
+                with st.spinner("Generating description via Agent..."):
+                    response = _agent.run(prompt_text, videos=[processed], safety_settings=safety_settings)
+                    out = getattr(response, "content", None) or getattr(response, "outputText", None) or str(response)
             else:
-                text_out = str(result)
+                # fallback: call GENAI.responses.generate directly
+                with st.spinner("Generating description via SDK..."):
+                    request = {
+                        "model": f"models/{model_id}",
+                        "input": [{"text": prompt_text, "files": [{"name": getattr(processed, 'name', processed.get('name'))}]}],
+                        "safetySettings": safety_settings,
+                        "maxOutputTokens": 1000,
+                    }
+                    res = GENAI.responses.generate(**request)
+                    out = ""
+                    # basic extraction
+                    for item in res.output or res.get("output", []):
+                        for c in (getattr(item, "content", None) or item.get("content", [])):
+                            if getattr(c, "type", None) in ("output_text", "text") or c.get("type") in ("output_text", "text"):
+                                out += getattr(c, "text", "") or c.get("text", "")
+                    if not out:
+                        out = getattr(res, "text", None) or json.dumps(res, default=str)
 
             st.subheader("Analysis Result")
-            st.markdown(text_out)
+            st.markdown(out)
         except Exception as e:
             st.error(f"An error occurred: {e}")