app.py

import streamlit as st
from pytube import YouTube
from phi.agent import Agent
from phi.model.google import Gemini
from phi.tools.duckduckgo import DuckDuckGo
from google.generativeai import upload_file, get_file
import google.generativeai as genai

import time
from pathlib import Path
from dotenv import load_dotenv
import os
import tempfile

# Load environment variables
load_dotenv()
API_KEY = os.getenv("GOOGLE_API_KEY")
if API_KEY:
    genai.configure(api_key=API_KEY)

# Page configuration
st.set_page_config(
    page_title="YouTube Video Summarizer",
    page_icon="🎥",
    layout="wide"
)

st.title("Phidata YouTube Video Summarizer Agent 🎥🎤🖬")
st.header("Powered by Gemini 2.0 Flash Exp")

@st.cache_resource
def initialize_agent():
    return Agent(
        name="YouTube Video Summarizer",
        model=Gemini(id="gemini-2.0-flash-exp"),
        tools=[DuckDuckGo()],
        markdown=True,
    )

# Initialize the agent
multimodal_Agent = initialize_agent()

# Function to get YouTube video captions using pytube
def get_youtube_captions(youtube_url):
    """
    Retrieves YouTube video captions using pytube.
    
    Parameters:
    - youtube_url: The URL of the YouTube video.
    
    Returns:
    - The captions of the video in SRT format, or a message if captions are not available.
    """
    yt = YouTube(youtube_url)

    # List available caption tracks
    caption_tracks = yt.caption_tracks
    available_languages = [track.language_code for track in caption_tracks]

    if available_languages:
        st.write(f"Available caption languages: {', '.join(available_languages)}")

        # You can set a fallback language or prompt the user to select
        language = 'en'  # Change this to any available language from the list
        
        # Check if the chosen language exists in the video
        if language in yt.captions:
            caption = yt.captions[language]
            return caption.generate_srt_captions()  # Return captions in SRT format
        else:
            return f"Captions not available in the selected language ({language})."
    else:
        return "No captions available for this video."



# YouTube video URL input
youtube_url = st.text_input(
    "Enter the YouTube video link",
    placeholder="Paste the YouTube video URL here",
    help="Provide the link to the YouTube video you want to summarize."
)

if youtube_url:
    try:
        with st.spinner("Fetching captions from the YouTube video..."):
            # Get captions for the video
            captions = get_youtube_captions(youtube_url)

        # Display captions
        st.subheader("Video Captions (SRT format)")
        st.text(captions)

        # User query input
        user_query = st.text_area(
            "What insights are you seeking from the video?",
            placeholder="Ask anything about the video content. The AI agent will analyze and gather additional context if needed.",
            help="Provide specific questions or insights you want from the video."
        )

        if st.button("🔍 Analyze Video", key="analyze_video_button"):
            if not user_query:
                st.warning("Please enter a question or insight to analyze the video.")
            else:
                try:
                    with st.spinner("Analyzing captions and gathering insights..."):
                        # Generate the analysis prompt using captions
                        analysis_prompt = (
                            f"""
                            Analyze the content of the following YouTube video captions.
                            Respond to the following query using the video captions and supplementary web research:
                            {user_query}
                            Provide a detailed, user-friendly, and actionable response.
                            """
                        )

                        # AI agent processing
                        response = multimodal_Agent.run(analysis_prompt, video_captions=captions)

                    # Display the result
                    st.subheader("Analysis Result")
                    st.markdown(response.content)

                except Exception as error:
                    st.error(f"An error occurred during analysis: {error}")

    except Exception as e:
        st.error(f"An error occurred while fetching captions: {e}")
else:
    st.info("Enter a YouTube video link to begin analysis.")