Update app.py

app.py

@@ -1,64 +1,125 @@
 import gradio as gr
 import os
 import tempfile
-from core.audio_processor import extract_audio
-from core.subtitle_gen import generate_subtitles
-from core.translator import translate_subtitles
-from core.video_merger import merge_video_subtitles
+import moviepy.editor as mp
+import assemblyai as aai
+from deep_translator import GoogleTranslator
+import pysrt
+from gtts import gTTS
+from pydub import AudioSegment
 
-# Available languages
+# Configuration
+aai.settings.api_key = os.getenv("ASSEMBLYAI_API_KEY")  # Set in HF Secrets
 LANGUAGES = {
     "English": "en",
-    "Spanish": "es",
+    "Spanish": "es", 
     "French": "fr",
     "German": "de",
     "Japanese": "ja",
     "Hindi": "hi"
 }
 
-def process_video(
-    video_file,
-    source_lang,
-    target_langs,
-    progress=gr.Progress()
-):
-    # Create temp directory
+def extract_audio(video_path, output_dir):
+    """Extract audio from video file"""
+    try:
+        video = mp.VideoFileClip(video_path)
+        audio_path = os.path.join(output_dir, "extracted_audio.wav")
+        video.audio.write_audiofile(audio_path)
+        return audio_path
+    except Exception as e:
+        raise Exception(f"Audio extraction failed: {str(e)}")
+
+def generate_subtitles(audio_path, output_dir):
+    """Generate subtitles from audio file"""
+    try:
+        transcriber = aai.Transcriber()
+        transcript = transcriber.transcribe(audio_path)
+        srt_path = os.path.join(output_dir, "subtitles.srt")
+        with open(srt_path, "w") as f:
+            f.write(transcript.export_subtitles_srt())
+        return srt_path
+    except Exception as e:
+        raise Exception(f"Subtitle generation failed: {str(e)}")
+
+def translate_subtitles(srt_path, target_langs, output_dir):
+    """Translate subtitles to multiple languages"""
+    try:
+        subs = pysrt.open(srt_path)
+        results = {}
+        
+        for lang in target_langs:
+            translated_subs = subs[:]
+            translator = GoogleTranslator(source="auto", target=lang)
+            
+            for sub in translated_subs:
+                sub.text = translator.translate(sub.text)
+            
+            output_path = os.path.join(output_dir, f"subtitles_{lang}.srt")
+            translated_subs.save(output_path, encoding='utf-8')
+            results[lang] = output_path
+            
+        return results
+    except Exception as e:
+        raise Exception(f"Translation failed: {str(e)}")
+
+def merge_video_subtitles(video_path, srt_path, output_path):
+    """Merge video with subtitles"""
+    try:
+        video = mp.VideoFileClip(video_path)
+        subs = pysrt.open(srt_path)
+        
+        subtitle_clips = []
+        for sub in subs:
+            txt_clip = mp.TextClip(
+                sub.text,
+                fontsize=24,
+                color='white',
+                font='Arial',
+                size=(video.w * 0.8, None)
+            ).set_start(sub.start.ordinal / 1000.0
+            ).set_duration((sub.end.ordinal - sub.start.ordinal) / 1000.0
+            ).set_pos(('center', 'bottom'))
+            subtitle_clips.append(txt_clip)
+        
+        final_video = mp.CompositeVideoClip([video] + subtitle_clips)
+        final_video.write_videofile(output_path, codec='libx264', audio_codec='aac')
+        return output_path
+    except Exception as e:
+        raise Exception(f"Video merging failed: {str(e)}")
+
+def process_video(video_file, source_lang, target_langs, progress=gr.Progress()):
+    """Main processing function"""
     with tempfile.TemporaryDirectory() as tmpdir:
         try:
-            progress(0.1, desc="Extracting audio...")
+            progress(0.1, "Extracting audio...")
             audio_path = extract_audio(video_file.name, tmpdir)
             
-            progress(0.3, desc="Generating subtitles...")
+            progress(0.3, "Generating subtitles...")
             srt_path = generate_subtitles(audio_path, tmpdir)
             
-            progress(0.5, desc="Translating subtitles...")
+            progress(0.5, "Translating subtitles...")
             translated_subs = translate_subtitles(
                 srt_path, 
                 [LANGUAGES[lang] for lang in target_langs],
                 tmpdir
             )
             
-            progress(0.7, desc="Generating output videos...")
+            progress(0.7, "Generating outputs...")
             output_files = []
             for lang, sub_path in translated_subs.items():
                 output_path = os.path.join(tmpdir, f"output_{lang}.mp4")
-                merge_video_subtitles(
-                    video_file.name,
-                    sub_path,
-                    output_path
-                )
+                merge_video_subtitles(video_file.name, sub_path, output_path)
                 output_files.append(output_path)
             
-            progress(1.0, desc="Done!")
+            progress(1.0, "Done!")
             return output_files
             
         except Exception as e:
             raise gr.Error(f"Processing failed: {str(e)}")
 
-# Gradio interface
+# Gradio Interface
 with gr.Blocks(title="Video Translator") as demo:
-    gr.Markdown("# 🎥 Video Translation System")
-    gr.Markdown("Upload a video to generate multilingual versions")
+    gr.Markdown("## 🎥 Video Translation System")
     
     with gr.Row():
         with gr.Column():
@@ -73,13 +134,13 @@ with gr.Blocks(title="Video Translator") as demo:
                 choices=list(LANGUAGES.keys()),
                 value=["Spanish", "French"]
             )
-            submit_btn = gr.Button("Translate Video")
+            submit_btn = gr.Button("Translate")
         
         with gr.Column():
             output_videos = gr.Files(label="Translated Videos")
     
     submit_btn.click(
-        fn=process_video,
+        process_video,
         inputs=[video_input, source_lang, target_langs],
         outputs=output_videos
     )