Update app.py

app.py

@@ -1,205 +1,24 @@
 import gradio as gr
-import moviepy.editor as mp
-import librosa
-from transformers import pipeline
-from concurrent.futures import ThreadPoolExecutor
-import tempfile
-import docx  # To create Word documents
-from moviepy.video.tools.subtitles import SubtitlesClip
-from moviepy.editor import TextClip
-from pytube import YouTube  # For downloading YouTube videos
+from moviepy.editor import VideoFileClip
 
-# Load Whisper model for speech-to-text (using smaller 'tiny' model for faster performance)
-asr = pipeline("automatic-speech-recognition", model="openai/whisper-tiny")
-
-# MarianMT or M2M100 for translation (multi-language)
-translator = pipeline("translation", model="facebook/m2m100_418M")
-
-# Store generated subtitles and translations
-subtitle_storage = {}
-
-# Supported languages with their codes
-languages = {
-    "Persian": "fa",
-    "French": "fr",
-    "Spanish": "es",
-    "German": "de",
-    "Chinese": "zh",
-    "Arabic": "ar",
-    "Hindi": "hi",
-    "Russian": "ru"
-}
-
-def download_video_from_link(link):
-    """Download a video from a YouTube link and return the file path."""
-    try:
-        yt = YouTube(link)
-        stream = yt.streams.filter(file_extension="mp4").first()  # Downloading in mp4 format
-        video_file = stream.download()  # Download to the current directory
-        return video_file
-    except Exception as e:
-        return f"Error downloading video: {e}"
-
-def transcribe_audio(chunk):
-    """Transcribe a single audio chunk."""
-    return asr(chunk)["text"]
-
-def add_subtitle(video):
-    try:
-        video_path = video if isinstance(video, str) else None
-        if not video_path:
-            return "No video provided!"
-        
-        video = mp.VideoFileClip(video_path)
-        audio = video.audio
-        
-        # Extract audio to a temporary file
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tmp_audio_file:
-            audio.write_audiofile(tmp_audio_file.name, codec='pcm_s16le')
-            waveform, sr = librosa.load(tmp_audio_file.name, sr=16000)
-
-        # Transcribe in chunks (parallel)
-        chunk_duration = 15  # seconds
-        chunk_size = sr * chunk_duration
-        chunks = [waveform[i:i + chunk_size] for i in range(0, len(waveform), chunk_size)]
-
-        with ThreadPoolExecutor() as executor:
-            transcriptions = list(executor.map(transcribe_audio, chunks))
-
-        full_transcription = " ".join(transcriptions)
-        subtitle_storage["original"] = full_transcription
-        subtitle_storage["video_path"] = video_path
-
-        return f"Subtitle added: {full_transcription[:100]}..."  # Display first 100 characters
-
-    except Exception as e:
-        return f"Error in adding subtitle: {e}"
-
-def translate_subtitle(language):
-    try:
-        # Translate the stored subtitle
-        original_subtitle = subtitle_storage.get("original")
-        if not original_subtitle:
-            return "No subtitle to translate!"
-        
-        # Translate using the selected language
-        translated_subtitle = translator(
-            original_subtitle, 
-            src_lang="en",  # Source language (assuming the subtitle is in English)
-            tgt_lang=languages[language]  # Get the language code from the dropdown selection
-        )[0]["translation_text"]
-
-        subtitle_storage["translated"] = translated_subtitle  # Store the translated subtitle
-        
-        return f"Subtitle translated to {language} successfully!"
+# Function to process and return the video
+def display_video(video_file):
+    # Load the video using MoviePy (optional for processing)
+    clip = VideoFileClip(video_file)
     
-    except Exception as e:
-        return f"Error in translating subtitle: {e}"
-
-def download_word():
-    try:
-        # Save translated subtitles to a Word document
-        translated_subtitle = subtitle_storage.get("translated")
-        if not translated_subtitle:
-            return "No translated subtitle to save!"
-        
-        # Prepare the document
-        doc = docx.Document()
-        doc.add_heading('Translated Subtitles', 0)
-        
-        # Create timestamps and subtitles
-        for i in range(0, len(translated_subtitle), 50):
-            start_time = (i // 50) * 5  # Each subtitle lasts for 5 seconds
-            subtitle_text = translated_subtitle[i:i + 50]  # Get the next 50 characters
-            
-            # Add a formatted string with timestamp and subtitle to the document
-            doc.add_paragraph(f"{start_time}s - {subtitle_text}")
-        
-        file_path = "translated_subtitles.docx"
-        doc.save(file_path)
-
-        # Return the file for download
-        return file_path  # Return the file path to allow Gradio to serve it as a downloadable file
+    # Optionally, you can print video details or process it
+    print(f"Duration: {clip.duration} seconds")
     
-    except Exception as e:
-        return f"Error in saving subtitles as Word: {e}"
-
-def download_video():
-    try:
-        original_subtitle = subtitle_storage.get("original")
-        translated_subtitle = subtitle_storage.get("translated")
-
-        if not original_subtitle or not translated_subtitle:
-            return "No subtitles to overlay on video!"
-
-        video_path = subtitle_storage.get("video_path")
-        video = mp.VideoFileClip(video_path)
+    # Return the video file to be displayed in Gradio
+    return video_file
 
-        # Generate subtitle text without ImageMagick (using TextClip with a basic font)
-        generator = lambda txt: TextClip(txt, font="Arial-Bold", fontsize=24, color="white", method='label')  # Use 'label'
-
-        subs = []
-        subtitle_length = 5  # seconds each subtitle will be displayed
-        for i in range(0, len(translated_subtitle), 50):
-            start_time = (i // 50) * subtitle_length
-            end_time = start_time + subtitle_length  # Each subtitle lasts for 'subtitle_length' seconds
-            subtitle_text = translated_subtitle[i:i + 50]
-            subs.append(((start_time, end_time), subtitle_text))
-
-        subtitles = SubtitlesClip(subs, generator)
-
-        subtitled_video = mp.CompositeVideoClip([video, subtitles.set_position(('center', 'bottom'))])
-
-        output_video_path = "subtitled_video.mp4"
-        subtitled_video.write_videofile(output_video_path)
-
-        return f"Subtitled video is ready for download: {output_video_path}"
-
-    except Exception as e:
-        return f"Error in generating subtitled video: {e}"
-
-# Gradio UI Interface
-with gr.Blocks() as demo:
-    # Title
-    gr.Markdown("<h1 style='text-align: center;'>Video Subtitle Translator</h1>")
-    
-    # Video Upload or URL Input
-    with gr.Row():
-        video_input = gr.Video(label="Upload Video")
-        video_url_input = gr.Textbox(label="Or Enter Video URL")
-        download_video_button = gr.Button("Download Video from URL")
-        download_status = gr.Textbox(label="Download Status")
-    
-    download_video_button.click(download_video_from_link, inputs=video_url_input, outputs=download_status)
-    
-    # Add Subtitle
-    with gr.Row():
-        add_subtitle_button = gr.Button("Add Subtitle")
-        subtitle_status = gr.Textbox(label="Subtitle Status")
-    
-    add_subtitle_button.click(add_subtitle, inputs=video_input, outputs=subtitle_status)
-    
-    # Translate Subtitle
-    with gr.Row():
-        language_dropdown = gr.Dropdown(choices=list(languages.keys()), label="Choose Target Language", value="Persian")
-        translate_button = gr.Button("Translate Subtitle")
-        translate_status = gr.Textbox(label="Translation Status")
-    
-    translate_button.click(translate_subtitle, inputs=language_dropdown, outputs=translate_status)  # Update inputs
-    
-    # Download as Word
-    with gr.Row():
-        download_word_button = gr.Button("Download as Word")  # Renamed the button to avoid conflict
-        download_word_status = gr.File(label="Download Translated Word File")  # File output for Word download
-    
-    download_word_button.click(download_word, inputs=None, outputs=download_word_status)
-    
-    # Download Subtitled Video
-    with gr.Row():
-        download_video_button2 = gr.Button("Download Subtitled Video")  # Renamed the button to avoid conflict
-        download_video_status = gr.Textbox(label="Download Video Status")
-    
-    download_video_button2.click(download_video, inputs=None, outputs=download_video_status)
+# Create the Gradio interface
+interface = gr.Interface(
+    fn=display_video,
+    inputs=gr.Video(label="Upload your video"),
+    outputs=gr.Video(label="Uploaded Video"),
+    title="Video Uploader",
+)
 
-# Launch the Gradio app
-demo.launch()
+# Launch the interface
+interface.launch()