Update app.py

app.py

@@ -1,20 +1,40 @@
 import os
 import google.generativeai as genai
-from moviepy.video.io.VideoFileClip import VideoFileClip
-from moviepy.audio.io.AudioFileClip import AudioFileClip
-from moviepy.video.compositing.CompositeVideoClip import CompositeVideoClip
+from moviepy.editor import VideoFileClip, AudioFileClip, CompositeVideoClip, TextClip
 from moviepy.video.tools.subtitles import SubtitlesClip
 import tempfile
 import logging
-import gradio as gr
-from gtts import gTTS
 import srt
+import datetime
+from gtts import gTTS
+from flask import Flask, request, render_template, send_from_directory, url_for, flash, session
+from werkzeug.utils import secure_filename
+import uuid
+
+# --- Configuration ---
 
 # Suppress moviepy logs
 logging.getLogger("moviepy").setLevel(logging.ERROR)
 
 # Configure Gemini API
-genai.configure(api_key=os.environ["GEMINI_API_KEY"])
+# IMPORTANT: Set your GEMINI_API_KEY as an environment variable
+# For example, in your terminal: export GEMINI_API_KEY="YOUR_API_KEY"
+try:
+    genai.configure(api_key=os.environ["GEMINI_API_KEY"])
+except KeyError:
+    raise Exception("GEMINI_API_KEY environment variable not set. Please set it before running the app.")
+
+
+# --- Flask App Initialization ---
+app = Flask(__name__)
+app.config['SECRET_KEY'] = os.urandom(24)
+app.config['UPLOAD_FOLDER'] = os.path.join(os.getcwd(), 'temp_uploads')
+
+# Ensure the upload folder exists
+os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
+
+
+# --- Model and Language Configuration ---
 
 # Create the Gemini model
 generation_config = {
@@ -26,7 +46,7 @@ generation_config = {
 }
 
 model = genai.GenerativeModel(
-    model_name="gemini-2.0-pro-exp-02-05",
+    model_name="gemini-1.5-pro-latest", # Using a stable and capable model
     generation_config=generation_config,
 )
 
@@ -52,7 +72,7 @@ SUPPORTED_LANGUAGES = [
 
 # Language code mapping for gTTS
 LANGUAGE_CODES = {
-    "English": "en", "Chinese": "zh", "German": "de", "Spanish": "es", 
+    "English": "en", "Chinese": "zh", "German": "de", "Spanish": "es",
     "Russian": "ru", "Korean": "ko", "French": "fr", "Japanese": "ja",
     "Portuguese": "pt", "Turkish": "tr", "Polish": "pl", "Catalan": "ca",
     "Dutch": "nl", "Arabic": "ar", "Swedish": "sv", "Italian": "it",
@@ -79,235 +99,219 @@ LANGUAGE_CODES = {
     "Bashkir": "ba", "Javanese": "jv", "Sundanese": "su"
 }
 
-def extract_audio_from_video(video_file):
+
+# --- Core Processing Functions ---
+
+def time_to_seconds(time_obj):
+    """Convert datetime.time object to seconds."""
+    return time_obj.hour * 3600 + time_obj.minute * 60 + time_obj.second + time_obj.microsecond / 1e6
+
+def extract_audio_from_video(video_path, audio_path):
     """Extract audio from a video file and save it as a WAV file."""
-    video = VideoFileClip(video_file)
-    audio_file = os.path.join(tempfile.gettempdir(), "extracted_audio.wav")
-    video.audio.write_audiofile(audio_file, fps=16000, logger=None)
-    return audio_file
-
-def transcribe_audio_with_gemini(audio_file):
-    """Transcribe audio using Gemini with a magic prompt for accurate timestamps."""
-    with open(audio_file, "rb") as f:
-        audio_data = f.read()
-
-    audio_blob = {
-        'mime_type': 'audio/wav',
-        'data': audio_data
-    }
-
-    prompt = """
-    You are a professional transcriber. Transcribe this audio accurately and verbatim in the original language.
-    Include timestamps for each sentence in the following format:
-    [HH:MM:SS] Sentence 1
-    [HH:MM:SS] Sentence 2
-    ...
-    Ensure the timestamps are accurate and correspond to the start of each sentence.
-    Respond only with the transcription and timestamps. Do not add explanations or extra text.
-    """
-
-    convo = model.start_chat()
-    convo.send_message(prompt)
-    response = convo.send_message(audio_blob)
-    return response.text.strip()
-
-def generate_subtitles(transcription):
-    """Generate SRT subtitles from transcription with timestamps."""
-    lines = transcription.split("\n")
-    srt_subtitles = []
-    
-    for i, line in enumerate(lines, start=1):
-        if not line.strip():
-            continue
-        
-        if line.startswith("["):
-            timestamp = line.split("]")[0] + "]"
-            text = line.split("]")[1].strip()
-        else:
-            timestamp = "[00:00:00]"
-            text = line.strip()
-        
-        start_time = timestamp[1:-1]
-        start_seconds = time_to_seconds(start_time)
-        end_seconds = start_seconds + 5  # Placeholder duration
+    try:
+        video = VideoFileClip(video_path)
+        video.audio.write_audiofile(audio_path, fps=16000, logger=None)
+        return audio_path
+    except Exception as e:
+        logging.error(f"Error extracting audio: {e}")
+        return None
+
+def transcribe_audio_with_gemini(audio_path, source_language):
+    """Transcribe audio using Gemini with a prompt for accurate timestamps."""
+    try:
+        audio_file = genai.upload_file(path=audio_path)
+        language_prompt = f"in {source_language}" if source_language != "Auto Detect" else ""
         
-        subtitle = srt.Subtitle(
-            index=i,
-            start=datetime.timedelta(seconds=start_seconds),
-            end=datetime.timedelta(seconds=end_seconds),
-            content=text
-        )
-        srt_subtitles.append(subtitle)
-    
-    return srt.compose(srt_subtitles)
+        prompt = f"""
+        You are a professional transcriber. Transcribe this audio accurately and verbatim {language_prompt}.
+        Include timestamps for each sentence in the SRT (SubRip) format.
+        Example:
+        1
+        00:00:01,234 --> 00:00:05,678
+        This is the first sentence.
+
+        2
+        00:00:06,123 --> 00:00:09,456
+        This is the second sentence.
 
-def time_to_seconds(time_str):
-    """Convert HH:MM:SS to seconds."""
-    hh, mm, ss = map(int, time_str.split(":"))
-    return hh * 3600 + mm * 60 + ss
+        Ensure the timestamps are precise and correspond to the start and end of each spoken sentence.
+        Respond ONLY with the transcription in the SRT format. Do not add explanations or any extra text.
+        """
+        
+        response = model.generate_content([prompt, audio_file])
+        genai.delete_file(audio_file.name) # Clean up the uploaded file
+        return response.text.strip()
+    except Exception as e:
+        logging.error(f"Error during Gemini transcription: {e}")
+        return None
 
-def seconds_to_time(seconds):
-    """Convert seconds to HH:MM:SS."""
-    hh = seconds // 3600
-    mm = (seconds % 3600) // 60
-    ss = seconds % 60
-    return f"{hh:02}:{mm:02}:{ss:02}"
 
 def translate_srt(srt_text, target_language):
-    """Translate an SRT file while preserving timestamps."""
-    prompt = f"""
-    Translate the following SRT subtitles into {target_language}.
-    Preserve the SRT format (timestamps and structure).
-    Translate only the text after the timestamp.
-    Do not add explanations or extra text.
-    Ensure the translation is accurate and culturally appropriate.
-    Here is the SRT file:
-    {srt_text}
-    """
-
-    response = model.generate_content(prompt)
-    return response.text
-
-def generate_tts_audio(srt_text, language):
+    """Translate an SRT file using Gemini while preserving timestamps."""
+    try:
+        prompt = f"""
+        Translate the following SRT subtitles into {target_language}.
+        Preserve the SRT format perfectly (index numbers, timestamps, and structure).
+        Translate only the subtitle text on the lines after the timestamps.
+        Do not add any explanations or extra text. Your output must be a valid SRT file.
+        Here is the SRT file content:
+        {srt_text}
+        """
+        response = model.generate_content(prompt)
+        return response.text.strip()
+    except Exception as e:
+        logging.error(f"Error during translation: {e}")
+        return None
+
+def generate_tts_audio(srt_text, language, tts_audio_path):
     """Generate TTS audio from SRT text."""
-    # Extract all text from SRT
-    subtitles = list(srt.parse(srt_text))
-    all_text = " ".join([sub.content for sub in subtitles])
-    
-    # Get language code
-    lang_code = LANGUAGE_CODES.get(language, "en")
-    
-    # Generate TTS
-    tts = gTTS(text=all_text, lang=lang_code, slow=False)
-    audio_file = os.path.join(tempfile.gettempdir(), "tts_audio.mp3")
-    tts.save(audio_file)
-    return audio_file
+    try:
+        subtitles = list(srt.parse(srt_text))
+        all_text = " ".join([sub.content for sub in subtitles])
+        
+        lang_code = LANGUAGE_CODES.get(language, "en")
+        
+        tts = gTTS(text=all_text, lang=lang_code, slow=False)
+        tts.save(tts_audio_path)
+        return tts_audio_path
+    except Exception as e:
+        logging.error(f"Error generating TTS audio: {e}")
+        return None
 
-def add_subtitles_to_video(video_file, srt_file, output_file):
+def add_subtitles_to_video(video_path, srt_text, output_video_path):
     """Add subtitles to video and return the path to the new video."""
-    # Create subtitle clip
-    generator = lambda txt: TextClip(txt, font='Arial', fontsize=24, color='white')
-    subtitles = SubtitlesClip(srt_file, generator)
-    
-    # Load video
-    video = VideoFileClip(video_file)
-    
-    # Composite video with subtitles
-    result = CompositeVideoClip([
-        video,
-        subtitles.set_position(('center', 'bottom'))
-    ])
-    
-    # Write output
-    result.write_videofile(output_file, codec='libx264', audio_codec='aac', threads=4)
-    return output_file
-
-def process_video(video_file, language="Auto Detect", translate_to=None, add_tts=False, add_subtitles=False):
-    """Process a video file with full options."""
-    # Extract audio from the video
-    audio_file = extract_audio_from_video(video_file)
-    
-    # Transcribe audio using Gemini
-    transcription = transcribe_audio_with_gemini(audio_file)
-    
-    # Generate subtitles
-    subtitles = generate_subtitles(transcription)
+    try:
+        def generator(txt):
+             return TextClip(txt, font='Arial-Bold', fontsize=24, color='white',
+                            stroke_color='black', stroke_width=1)
+        
+        # MoviePy's SubtitlesClip requires a file path
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.srt', delete=False, encoding='utf-8') as temp_srt:
+            temp_srt.write(srt_text)
+            srt_path = temp_srt.name
+
+        video = VideoFileClip(video_path)
+        subtitles = SubtitlesClip(srt_path, generator)
+        
+        result = CompositeVideoClip([video, subtitles.set_position(('center', 'bottom'))])
+        
+        # Write output with original audio
+        result.write_videofile(output_video_path, codec='libx264', audio_codec='aac', threads=4, logger=None)
+        
+        os.remove(srt_path) # Clean up temp srt file
+        return output_video_path
+    except Exception as e:
+        logging.error(f"Error adding subtitles to video: {e}")
+        return None
+
+
+# --- Flask Routes ---
+
+@app.route('/')
+def index():
+    """Render the main page."""
+    session.clear() # Clear any old data
+    return render_template('index.html', supported_languages=SUPPORTED_LANGUAGES)
+
+@app.route('/process', methods=['POST'])
+def process():
+    """Handle the video processing request."""
+    if 'video' not in request.files:
+        flash('No video file selected. Please upload a video.', 'error')
+        return render_template('index.html', supported_languages=SUPPORTED_LANGUAGES)
+
+    video_file = request.files['video']
+    if video_file.filename == '':
+        flash('No video file selected. Please upload a video.', 'error')
+        return render_template('index.html', supported_languages=SUPPORTED_LANGUAGES)
+
+    # --- Get form options ---
+    source_language = request.form.get('source_language', 'Auto Detect')
+    translate_to = request.form.get('translate_to', 'None')
+    add_tts = 'add_tts' in request.form
+    add_subtitles = 'add_subtitles' in request.form
     
-    # Save original subtitles
-    original_srt_file = os.path.join(tempfile.gettempdir(), "original_subtitles.srt")
-    with open(original_srt_file, "w", encoding="utf-8") as f:
-        f.write(subtitles)
+    # --- Setup a unique session directory for this request ---
+    session_id = str(uuid.uuid4())
+    session['session_id'] = session_id
+    session_dir = os.path.join(app.config['UPLOAD_FOLDER'], session_id)
+    os.makedirs(session_dir, exist_ok=True)
+
+    filename = secure_filename(video_file.filename)
+    video_path = os.path.join(session_dir, filename)
+    video_file.save(video_path)
+
+    results = {}
+
+    # 1. Extract Audio
+    audio_path = os.path.join(session_dir, "extracted_audio.wav")
+    if not extract_audio_from_video(video_path, audio_path):
+        flash('Failed to extract audio from the video.', 'error')
+        return render_template('index.html', supported_languages=SUPPORTED_LANGUAGES)
+
+    # 2. Transcribe Audio
+    original_srt_text = transcribe_audio_with_gemini(audio_path, source_language)
+    if not original_srt_text:
+        flash('Failed to transcribe the audio. The API call might have failed.', 'error')
+        return render_template('index.html', supported_languages=SUPPORTED_LANGUAGES)
+
+    original_srt_path = os.path.join(session_dir, "original_subtitles.srt")
+    with open(original_srt_path, "w", encoding="utf-8") as f:
+        f.write(original_srt_text)
+    results['original_srt_file'] = "original_subtitles.srt"
     
-    # Translate subtitles if requested
-    translated_srt_file = None
+    # Keep track of the final SRT to use for TTS and video burn-in
+    final_srt_text = original_srt_text
+
+    # 3. Translate Subtitles (if requested)
     if translate_to and translate_to != "None":
-        translated_subtitles = translate_srt(subtitles, translate_to)
-        translated_srt_file = os.path.join(tempfile.gettempdir(), "translated_subtitles.srt")
-        with open(translated_srt_file, "w", encoding="utf-8") as f:
-            f.write(translated_subtitles)
+        translated_srt_text = translate_srt(original_srt_text, translate_to)
+        if translated_srt_text:
+            translated_srt_path = os.path.join(session_dir, "translated_subtitles.srt")
+            with open(translated_srt_path, "w", encoding="utf-8") as f:
+                f.write(translated_srt_text)
+            results['translated_srt_file'] = "translated_subtitles.srt"
+            final_srt_text = translated_srt_text # Use translated text for next steps
+        else:
+            flash(f'Failed to translate subtitles to {translate_to}.', 'warning')
     
-    # Generate TTS audio if requested
-    tts_audio_file = None
+    # 4. Generate TTS Audio (if requested)
     if add_tts:
-        target_lang = translate_to if translate_to and translate_to != "None" else language
-        tts_audio_file = generate_tts_audio(subtitles if not translated_srt_file else translated_subtitles, target_lang)
+        tts_lang = translate_to if translate_to and translate_to != "None" else source_language
+        # If source was auto-detect, we can't reliably guess the TTS language. Default to English.
+        if tts_lang == 'Auto Detect':
+             flash('TTS language cannot be "Auto Detect". Defaulting to English. For better results, please specify the source language.', 'warning')
+             tts_lang = 'English'
+
+        tts_audio_path = os.path.join(session_dir, "tts_audio.mp3")
+        if generate_tts_audio(final_srt_text, tts_lang, tts_audio_path):
+             results['tts_audio_file'] = "tts_audio.mp3"
+        else:
+             flash('Failed to generate Text-to-Speech audio.', 'warning')
     
-    # Create video with subtitles if requested
-    output_video_file = None
+    # 5. Add Subtitles to Video (if requested)
     if add_subtitles:
-        srt_to_use = translated_srt_file if translated_srt_file else original_srt_file
-        output_video_file = os.path.join(tempfile.gettempdir(), "output_video.mp4")
-        add_subtitles_to_video(video_file, srt_to_use, output_video_file)
-    
-    # Clean up
-    os.remove(audio_file)
-    
-    return original_srt_file, translated_srt_file, tts_audio_file, output_video_file, "Detected Language: Auto"
-
-# Define the Gradio interface
-with gr.Blocks(title="AutoSubGen Pro - AI Video Subtitle Generator") as demo:
-    # Header
-    with gr.Column():
-        gr.Markdown("# 🎥 AutoSubGen Pro")
-        gr.Markdown("### Advanced AI-Powered Video Subtitle Generator")
-        gr.Markdown("Generate, translate, and add subtitles with text-to-speech audio to your videos.")
-    
-    # Main content
-    with gr.Tab("Generate Subtitles"):
-        gr.Markdown("### Upload a video file to process")
-        with gr.Row():
-            video_input = gr.Video(label="Upload Video File", scale=2)
-            with gr.Column():
-                language_dropdown = gr.Dropdown(
-                    choices=SUPPORTED_LANGUAGES,
-                    label="Source Language",
-                    value="Auto Detect",
-                )
-                translate_to_dropdown = gr.Dropdown(
-                    choices=["None"] + SUPPORTED_LANGUAGES[1:],
-                    label="Translate To",
-                    value="None",
-                )
-                tts_checkbox = gr.Checkbox(label="Generate Text-to-Speech Audio")
-                subtitles_checkbox = gr.Checkbox(label="Add Subtitles to Video")
-        
-        generate_button = gr.Button("Process Video", variant="primary")
-        
-        with gr.Row():
-            with gr.Column():
-                original_subtitle_output = gr.File(label="Original Subtitles (SRT)")
-                translated_subtitle_output = gr.File(label="Translated Subtitles (SRT)")
-            with gr.Column():
-                tts_audio_output = gr.Audio(label="Text-to-Speech Audio", visible=False)
-                video_output = gr.Video(label="Video with Subtitles", visible=False)
-        
-        detected_language_output = gr.Textbox(label="Detected Language")
-        
-        # Show/hide outputs based on checkboxes
-        def toggle_outputs(tts, subs):
-            return [
-                gr.Audio(visible=tts),
-                gr.Video(visible=subs)
-            ]
-        
-        tts_checkbox.change(
-            fn=lambda x: gr.Audio(visible=x),
-            inputs=tts_checkbox,
-            outputs=tts_audio_output
-        )
-        
-        subtitles_checkbox.change(
-            fn=lambda x: gr.Video(visible=x),
-            inputs=subtitles_checkbox,
-            outputs=video_output
-        )
+        output_video_path = os.path.join(session_dir, "output_video.mp4")
+        if add_subtitles_to_video(video_path, final_srt_text, output_video_path):
+            results['output_video_file'] = "output_video.mp4"
+        else:
+            flash('Failed to add subtitles to the video.', 'warning')
+            
+    # Clean up original extracted audio
+    os.remove(audio_path)
     
-    # Link button to function
-    generate_button.click(
-        process_video,
-        inputs=[video_input, language_dropdown, translate_to_dropdown, tts_checkbox, subtitles_checkbox],
-        outputs=[original_subtitle_output, translated_subtitle_output, tts_audio_output, video_output, detected_language_output]
-    )
-
-# Launch the interface
-demo.launch(share=True)
+    return render_template('index.html',
+                           supported_languages=SUPPORTED_LANGUAGES,
+                           results=results,
+                           session_id=session_id)
+
+@app.route('/download/<session_id>/<path:filename>')
+def download_file(session_id, filename):
+    """Serve files from the session directory for download."""
+    directory = os.path.join(app.config['UPLOAD_FOLDER'], session_id)
+    return send_from_directory(directory, filename, as_attachment=True)
+
+
+# --- Run the App ---
+if __name__ == '__main__':
+    app.run(debug=True)