Update app.py

app.py

@@ -1,153 +1,88 @@
-import streamlit as st
-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
-import tempfile
-from dotenv import load_dotenv
 import os
-from phi.model.groq import Groq
-from phi.tools.youtube_tools import YouTubeTools
+import gradio as gr
+from moviepy.video.io.VideoFileClip import VideoFileClip
+from pydub import AudioSegment
+import whisper
+from transformers import pipeline, MarianMTModel, MarianTokenizer
+import yt_dlp as youtube_dl
 
-# Load environment variables
-load_dotenv()
+def download_youtube_video(url):
+    try:
+        os.system(f"yt-dlp -o video.mp4 {url}")
+        return "video.mp4"
+    except Exception as e:
+        return str(e)
 
-# Configure API keys
-API_KEY = os.getenv("GOOGLE_API_KEY")
-groq_api_key = os.getenv("GROQ_API_KEY")
-if API_KEY:
-    genai.configure(api_key=API_KEY)
+def extract_audio(video_path):
+    try:
+        audio = AudioSegment.from_file(video_path)
+        audio.export("extracted_audio.mp3", format="mp3")
+        return "extracted_audio.mp3"
+    except Exception as e:
+        return str(e)
 
-# Page configuration
-st.set_page_config(
-    page_title="Multimodal AI Applications",
-    page_icon="🌐",
-    layout="wide"
-)
+def transcribe_audio(audio_path):
+    try:
+        model = whisper.load_model("base")
+        result = model.transcribe(audio_path)
+        return result['text']
+    except Exception as e:
+        return str(e)
 
-# Custom CSS for UI Styling
-def load_custom_css():
-    st.markdown(
-        """
-        <style>
-            .stButton>button {
-                width: 100%;
-                height: 50px;
-                font-size: 18px;
-                font-weight: bold;
-                background: rgba(255, 255, 255, 0.2);
-                border-radius: 12px;
-                border: 2px solid rgba(255, 255, 255, 0.5);
-                box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.2);
-            }
-            .stTextInput>div>div>input, .stTextArea>div>textarea {
-                background: rgba(255, 255, 255, 0.1);
-                border-radius: 8px;
-                border: 1px solid rgba(255, 255, 255, 0.3);
-                color: white;
-                padding: 10px;
-            }
-        </style>
-        """,
-        unsafe_allow_html=True
-    )
+def summarize_text(text):
+    try:
+        summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
+        summary = summarizer(text, max_length=150, min_length=30, do_sample=False)
+        return summary[0]['summary_text']
+    except Exception as e:
+        return str(e)
 
-load_custom_css()
+def translate_text(text, tgt_lang="es"):
+    try:
+        model_name = f"Helsinki-NLP/opus-mt-en-{tgt_lang}"
+        tokenizer = MarianTokenizer.from_pretrained(model_name)
+        model = MarianMTModel.from_pretrained(model_name)
+        translated = model.generate(**tokenizer(text, return_tensors="pt", padding=True))
+        return tokenizer.decode(translated[0], skip_special_tokens=True)
+    except Exception as e:
+        return str(e)
 
-st.markdown("# 🎥 Video Transcription and AI Summary")
-st.markdown("Upload a video or provide a YouTube link to get a transcription and AI-generated summary.")
+def process_video(video_file, youtube_url):
+    if youtube_url:
+        video_path = download_youtube_video(youtube_url)
+    elif video_file:
+        video_path = video_file.name
+    else:
+        return "No valid input provided."
+    
+    audio_path = extract_audio(video_path)
+    transcription = transcribe_audio(audio_path)
+    return transcription
 
-# Tabs for the two applications
-tab1, tab2 = st.tabs(["📤 Video Upload", "🔗 YouTube Video Analysis"])
+def summarize_and_translate(text, lang):
+    summary = summarize_text(text)
+    translation = translate_text(summary, lang)
+    return summary, translation
 
-# Tab 1: Video Summarizer with Gemini
-with tab1:
-    st.subheader("Phidata Video AI Summarizer Agent 🎥")
+with gr.Blocks() as app:
+    gr.Markdown("# 🎥 Smart Video-to-Text Summarization App")
     
-    @st.cache_resource
-    def initialize_agent():
-        return Agent(
-            name="Video AI Summarizer",
-            model=Gemini(id="gemini-2.0-flash-exp"),
-            tools=[DuckDuckGo()],
-            markdown=True,
-        )
+    with gr.Row():
+        video_upload = gr.File(label="Upload Video File", type="file")
+        youtube_link = gr.Textbox(label="YouTube URL")
     
-    multimodal_Agent = initialize_agent()
+    process_button = gr.Button("🚀 Process Video")
+    transcription_output = gr.Textbox(label="Transcription", interactive=False)
+    process_button.click(process_video, inputs=[video_upload, youtube_link], outputs=transcription_output)
     
-    video_file = st.file_uploader("Upload a video file", type=['mp4'])
+    summarize_button = gr.Button("📝 Summarize Text")
+    summary_output = gr.Textbox(label="Summary", interactive=False)
     
-    if video_file:
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_video:
-            temp_video.write(video_file.read())
-            video_path = temp_video.name
-        
-        st.video(video_path, format="video/mp4", start_time=0)
-
-        user_query = st.text_area("What insights are you seeking 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("Processing video..."):
-                        processed_video = upload_file(video_path)
-                        while processed_video.state.name == "PROCESSING":
-                            time.sleep(1)
-                            processed_video = get_file(processed_video.name)
-                        
-                        prompt = f"""
-                            Analyze the uploaded video and provide a summary.
-                            Respond to: {user_query}
-                        """
-                        response = multimodal_Agent.run(prompt, videos=[processed_video])
-                        st.subheader("Analysis Result")
-                        st.markdown(response.content)
-                except Exception as error:
-                    st.error(f"Error: {error}")
-                finally:
-                    Path(video_path).unlink(missing_ok=True)
-    else:
-        st.info("Upload a video file to begin analysis.")
-
-# Tab 2: YouTube Video Analyzer with Groq
-with tab2:
-    st.subheader("YouTube Video Analyzer 🎬")
-    
-    try:
-        youtube_agent = Agent(
-            model=Groq(id="llama3-8b-8192", api_key=groq_api_key),
-            tools=[YouTubeTools(), DuckDuckGo()],
-            show_tool_calls=True,
-            get_video_captions=True,
-            get_video_data=True,
-            description="Analyze YouTube videos for content, key points, and web research.",
-        )
-    except Exception as e:
-        st.error(f"Error initializing the agent: {e}")
-        st.stop()
+    translate_button = gr.Button("🌍 Translate Summary")
+    language_dropdown = gr.Dropdown(choices=["es", "fr", "de", "zh"], label="Select Translation Language")
+    translated_output = gr.Textbox(label="Translated Summary", interactive=False)
     
-    video_url = st.text_input("Enter YouTube Video URL:", "")
-    user_query = st.text_area("Enter your question about the video (optional):", "")
+    summarize_button.click(summarize_text, inputs=transcription_output, outputs=summary_output)
+    translate_button.click(summarize_and_translate, inputs=[transcription_output, language_dropdown], outputs=[summary_output, translated_output])
     
-    if st.button("✨ Analyze Video", key="analyze_video_button"):
-        if video_url:
-            with st.spinner("Analyzing..."):
-                try:
-                    prompt = f"""
-                        Analyze the YouTube video.
-                        Provide a detailed summary with key points.
-                        {f'Respond to: {user_query}' if user_query else ''}
-                        Video URL: {video_url}
-                    """
-                    output = youtube_agent.run(prompt)
-                    st.subheader("Analysis Result")
-                    st.markdown(output.content)
-                except Exception as e:
-                    st.error(f"Error: {e}")
-        else:
-            st.warning("Please enter a YouTube video URL.")
+app.launch()