Update app.py

app.py

@@ -1,62 +1,74 @@
 import streamlit as st
-import youtube_dl
 from moviepy.editor import VideoFileClip
 import speech_recognition as sr
-from transformers import pipeline
+from moviepy.editor import TextClip, concatenate_videoclips
+from tempfile import NamedTemporaryFile
+import os
 
-# Initialize the Hugging Face text generation pipeline (using GPT-Neo or GPT-2)
-generator = pipeline("text-generation", model="EleutherAI/gpt-neo-2.7B")
+# Function to extract subtitles using speech recognition
+def generate_subtitles(video_path):
+    recognizer = sr.Recognizer()
+    clip = VideoFileClip(video_path)
+    audio = clip.audio
+    audio_file = NamedTemporaryFile(delete=False, suffix='.wav')
+    audio.write_audiofile(audio_file.name)
+    
+    with sr.AudioFile(audio_file.name) as source:
+        audio_data = recognizer.record(source)
+        try:
+            # Recognize speech using Google Web Speech API
+            text = recognizer.recognize_google(audio_data)
+        except sr.UnknownValueError:
+            text = "Could not understand audio"
+        except sr.RequestError:
+            text = "Could not request results"
+    
+    os.remove(audio_file.name)
+    return text
+
+# Streamlit App
+st.title("Video Trimmer with Subtitles")
+
+# Video upload
+uploaded_file = st.file_uploader("Choose a video...", type=["mp4", "avi", "mov", "mkv"])
+
+if uploaded_file is not None:
+    # Display uploaded video
+    st.video(uploaded_file)
 
-def download_video(url):
-    ydl_opts = {
-        'format': 'bestvideo+bestaudio/best',
-        'outtmpl': 'downloaded_video.mp4'
-    }
-    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
-        ydl.download([url])
+    # Load video file
+    video = VideoFileClip(uploaded_file)
 
-def trim_video(video_path, start_time, end_time):
-    video = VideoFileClip(video_path)
+    # Time options for trimming
+    time_options = [15, 30, 60]  # in seconds
+    trim_time = st.selectbox("Select trim duration", time_options)
+
+    # User selects trim time
+    start_time = 0
+    end_time = trim_time
     trimmed_video = video.subclip(start_time, end_time)
-    trimmed_video.write_videofile("trimmed_video.mp4")
 
-def transcribe_audio(video_path):
-    recognizer = sr.Recognizer()
-    with sr.AudioFile(video_path) as source:
-        audio = recognizer.record(source)
-    try:
-        text = recognizer.recognize_google(audio)  # This uses Google's free Web Speech API
-        return text
-    except sr.UnknownValueError:
-        return "Sorry, I could not understand the audio."
-    except sr.RequestError:
-        return "Error with the API request."
-
-def generate_subtitles(text):
-    # Use Hugging Face's GPT-Neo model for text generation
-    generated_text = generator(text, max_length=150, num_return_sequences=1)
-    return generated_text[0]['generated_text']
-
-# Streamlit Interface
-st.title("YouTube Video Trimmer and Subtitle Generator")
-url = st.text_input("Enter YouTube URL")
-start_time = st.selectbox("Select Start Time", [0, 15, 30, 60])
-end_time = st.selectbox("Select End Time", [15, 30, 60, 90])
-
-font_style = st.selectbox("Select Font Style", ["Arial", "Helvetica", "Times New Roman", "Courier"])
-
-if st.button("Generate"):
-    # Download and trim the video
-    download_video(url)
-    trim_video("downloaded_video.mp4", start_time, end_time)
+    # Display trimmed video
+    st.video(trimmed_video)
+
+    # User selects subtitle font style
+    font_style = st.selectbox("Choose subtitle font style", ["Arial", "Courier", "Times-Roman", "Impact"])
+
+    # Generate subtitles
+    subtitles_text = generate_subtitles(uploaded_file)
+    
+    # Add subtitles to video
+    subtitle_clip = TextClip(subtitles_text, fontsize=24, color='white', font=font_style)
+    subtitle_clip = subtitle_clip.set_position('bottom').set_duration(trimmed_video.duration)
     
-    # Transcribe audio to text
-    transcription = transcribe_audio("trimmed_video.mp4")
+    final_video = concatenate_videoclips([trimmed_video.set_audio(trimmed_video.audio), subtitle_clip])
     
-    # Generate subtitles using Hugging Face's GPT model
-    subtitles = generate_subtitles(transcription)
+    # Display final video
+    st.video(final_video)
     
-    # Show trimmed video and generated subtitles
-    st.video("trimmed_video.mp4")
-    st.subheader("Subtitles:")
-    st.write(subtitles)
+    # Button to generate video
+    if st.button("Generate Video"):
+        # Save the final video
+        final_output = NamedTemporaryFile(delete=False, suffix='.mp4')
+        final_video.write_videofile(final_output.name, codec="libx264")
+        st.download_button("Download Final Video", final_output.name)