Update app.py

app.py

@@ -1,7 +1,7 @@
-# app.py
 import os
 import time
 import tempfile
+import uuid
 import google.generativeai as genai
 import requests
 from flask import Flask, request, render_template, send_from_directory, url_for, flash
@@ -10,43 +10,35 @@ from moviepy.audio.io.AudioFileClip import AudioFileClip
 from werkzeug.utils import secure_filename
 from dotenv import load_dotenv
 
-# Initialize Flask app
+# --- 1. INITIALIZE FLASK APP AND LOAD SECRETS ---
 load_dotenv()
 app = Flask(__name__)
 
-# Configuration
-app.config.update({
-    'GEMINI_API_KEY': os.getenv('GEMINI_API_KEY'),
-    'TTS_API_URL': os.getenv('TTS_API_URL'),
-    'UPLOAD_FOLDER': 'uploads',
-    'DOWNLOAD_FOLDER': 'downloads',
-    'MAX_CONTENT_LENGTH': 100 * 1024 * 1024,  # 100MB
-    'SECRET_KEY': os.urandom(24),
-    'ALLOWED_EXTENSIONS': {'mp4', 'mov', 'webm', 'avi'}
-})
-
-# Create directories
-os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-os.makedirs(app.config['DOWNLOAD_FOLDER'], exist_ok=True)
-
-# Initialize Gemini AI
-genai.configure(api_key=app.config['GEMINI_API_KEY'])
-
-# Voice Configuration
-VOICE_OPTIONS = {
-    "Male (Charon)": {
-        "id": "charon",
-        "description": "Deep, authoritative male voice",
-        "tone_options": ["neutral", "serious", "cheerful"]
-    },
-    "Female (Zephyr)": {
-        "id": "zephyr",
-        "description": "Soft, clear female voice",
-        "tone_options": ["neutral", "gentle", "energetic"]
-    }
-}
-
-
+# Load secrets from the loaded environment variables
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+TTS_API_URL = os.getenv("TTS_API_URL")
+
+# Check if secrets were loaded correctly
+if not GEMINI_API_KEY:
+    raise ValueError("SECURITY ERROR: GEMINI_API_KEY not found in .env file!")
+if not TTS_API_URL:
+    raise ValueError("CONFIGURATION ERROR: TTS_API_URL not found in .env file!")
+
+# Configure the Gemini API
+genai.configure(api_key=GEMINI_API_KEY)
+
+# Configure directories and app settings
+UPLOAD_FOLDER = 'uploads'
+DOWNLOAD_FOLDER = 'downloads'
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(DOWNLOAD_FOLDER, exist_ok=True)
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['DOWNLOAD_FOLDER'] = DOWNLOAD_FOLDER
+app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # 100 MB upload limit
+app.secret_key = os.urandom(24) # Secure key for flash messages
+
+# --- 2. VOICE CHOICES & GEMINI PROMPT ---
+VOICE_CHOICES = {"Male (Charon)": "Charon", "Female (Zephyr)": "Zephyr"}
 GEMINI_PROMPT = """
 You are an expert AI scriptwriter. Your task is to watch the provided video and transcribe ALL spoken dialogue into a SINGLE, CONTINUOUS block of modern, colloquial Tamil.
 
@@ -59,142 +51,103 @@ You are an expert AI scriptwriter. Your task is to watch the provided video and
 Say happily: வணக்கம்! [laugh] எப்படி இருக்கீங்க? Whisper mysteriously: அந்த ரகசியம் எனக்கு மட்டும் தான் தெரியும்.
 """
 
-def allowed_file(filename):
-    return '.' in filename and \
-           filename.rsplit('.', 1)[1].lower() in app.config['ALLOWED_EXTENSIONS']
-
-def generate_script(video_path):
-    """Generate Tamil script using Gemini AI"""
-    try:
-        print("Uploading video to Gemini...")
-        video_file = genai.upload_file(video_path, mime_type="video/mp4")
-        
-        # Wait for processing
-        while video_file.state.name == "PROCESSING":
-            time.sleep(5)
-            video_file = genai.get_file(video_file.name)
-        
-        if video_file.state.name != "ACTIVE":
-            raise Exception("Gemini processing failed")
-        
-        model = genai.GenerativeModel("models/gemini-2.5-flash")
-        response = model.generate_content([GEMINI_PROMPT, video_file])
-        genai.delete_file(video_file.name)
-        
-        return response.text.strip() if hasattr(response, 'text') else ""
-    except Exception as e:
-        print(f"Gemini Error: {str(e)}")
-        raise
-
-def generate_audio(script, voice_id, tone):
-    """Generate audio using TTS API with specific voice"""
+# --- 3. CORE LOGIC HELPER FUNCTIONS ---
+
+def generate_tamil_script(video_file_path):
+    """Generates a single, continuous Tamil script from the video using Gemini."""
+    print("Uploading file to Gemini for transcription...")
+    video_file = genai.upload_file(video_file_path, mime_type="video/mp4")
+    print("Waiting for Gemini file processing...")
+    while video_file.state.name == "PROCESSING":
+        time.sleep(5)
+        video_file = genai.get_file(video_file.name)
+    if video_file.state.name != "ACTIVE":
+        raise Exception(f"Gemini file processing failed: {video_file.state.name}")
+    print("Generating narrator script...")
+    model = genai.GenerativeModel(model_name="models/gemini-2.5-flash")
+    response = model.generate_content([GEMINI_PROMPT, video_file])
+    genai.delete_file(video_file.name)
+    if hasattr(response, 'text') and response.text:
+        return " ".join(response.text.strip().splitlines())
+    raise Exception("No valid script was generated by Gemini.")
+
+def generate_single_audio_track(dialogue_text, voice_name, is_cheerful, output_path):
+    """Generates one audio track for the entire script via TTS API."""
+    print(f"Requesting audio from TTS API (Voice: {voice_name}, Cheerful: {is_cheerful})")
+    payload = {"text": dialogue_text, "voice_name": voice_name, "cheerful": is_cheerful}
+    response = requests.post(TTS_API_URL, json=payload, timeout=300)
+    if response.status_code == 200:
+        with open(output_path, "wb") as f:
+            f.write(response.content)
+        return True
+    raise Exception(f"Error from TTS API: {response.status_code} - {response.text}")
+
+def replace_video_audio(video_path, new_audio_path, output_path):
+    """Replaces the audio of a video using the modern, correct MoviePy method."""
+    print("Replacing video audio using MoviePy...")
+    video_clip, audio_clip = None, None
     try:
-        response = requests.post(
-            app.config['TTS_API_URL'],
-            json={
-                "text": script,
-                "voice_name": voice_name,
-                "cheerful": cheerful,
-                "sample_rate": 24000,
-                "channels": 1,
-                "sample_width": 2
-            },
-            timeout=300
-        )
-        response.raise_for_status()
-        return response.content
-    except requests.exceptions.RequestException as e:
-        print(f"TTS API Error: {str(e)}")
-        raise
-
-def process_video(input_path, audio_data, output_filename):
-    """Combine video with new audio track"""
-    try:
-        with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as audio_temp:
-            audio_temp.write(audio_data)
-            audio_temp_path = audio_temp.name
-        
-        video = VideoFileClip(input_path)
-        audio = AudioFileClip(audio_temp_path)
-        
-        # Ensure audio matches video duration
-        if audio.duration > video.duration:
-            audio = audio.subclip(0, video.duration)
-        
-        video.audio = audio
-        output_path = os.path.join(app.config['DOWNLOAD_FOLDER'], output_filename)
-        video.write_videofile(
-            output_path,
-            codec='libx264',
-            audio_codec='aac',
-            threads=4,
-            logger=None
-        )
-        
-        return output_path
-    except Exception as e:
-        print(f"Video Processing Error: {str(e)}")
-        raise
+        video_clip = VideoFileClip(video_path)
+        audio_clip = AudioFileClip(new_audio_path)
+        video_clip.audio = audio_clip
+        video_clip.write_videofile(output_path, codec="libx264", audio_codec="aac", logger='bar')
     finally:
-        if 'video' in locals(): video.close()
-        if 'audio' in locals(): audio.close()
-        if os.path.exists(audio_temp_path): os.remove(audio_temp_path)
+        if audio_clip: audio_clip.close()
+        if video_clip: video_clip.close()
+
+# --- 4. FLASK WEB ROUTES ---
 
 @app.route('/', methods=['GET'])
-def home():
-    return render_template('index.html', voices=VOICE_OPTIONS)
+def index():
+    """Renders the main upload page."""
+    return render_template('index.html')
 
 @app.route('/process', methods=['POST'])
-def process():
-    if 'video' not in request.files:
-        flash('No file selected', 'error')
-        return render_template('index.html', voices=VOICE_OPTIONS)
-    
-    file = request.files['video']
-    if file.filename == '':
-        flash('No file selected', 'error')
-        return render_template('index.html', voices=VOICE_OPTIONS)
-    
-    if not allowed_file(file.filename):
-        flash('Invalid file type. Allowed: MP4, MOV, WEBM, AVI', 'error')
-        return render_template('index.html', voices=VOICE_OPTIONS)
-    
+def process_video():
+    """Handles video upload, processing, and renders the result."""
+    input_video_path, temp_audio_path = None, None
     try:
-        # Save uploaded file
+        if 'video' not in request.files or request.files['video'].filename == '':
+            flash("Please upload a video file.")
+            return render_template('index.html')
+
+        file = request.files['video']
         filename = secure_filename(file.filename)
-        input_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-        file.save(input_path)
-        
-        # Get processing options
-        voice_name = request.form.get('voice')
-        voice_id = VOICE_OPTIONS[voice_name]['id']
-        tone = request.form.get('tone', 'neutral')
+        input_video_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(input_video_path)
+
+        voice_choice = request.form['voice_choice']
+        is_cheerful = 'cheerful' in request.form
+        voice_name = VOICE_CHOICES[voice_choice]
+        script = generate_tamil_script(input_video_path)
         
-        # Generate script and audio
-        script = generate_script(input_path)
-        audio_data = generate_audio(script, voice_id, tone)
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_audio:
+            temp_audio_path = temp_audio.name
         
-        # Process video
-        output_filename = f"dubbed_{filename}"
-        output_path = process_video(input_path, audio_data, output_filename)
+        generate_single_audio_track(script, voice_name, is_cheerful, temp_audio_path)
+        final_video_name = f"dubbed_{filename}"
+        final_video_path = os.path.join(app.config['DOWNLOAD_FOLDER'], final_video_name)
+        replace_video_audio(input_video_path, temp_audio_path, final_video_path)
         
-        flash('Processing completed successfully!', 'success')
-        return render_template('result.html', 
-                            video_url=url_for('download', filename=output_filename),
-                            script=script,
-                            voice_used=voice_name,
-                            tone_used=tone)
-    
+        flash("Video processing complete!", "success")
+        return render_template('index.html', 
+                               result_video=url_for('serve_video', filename=final_video_name), 
+                               script=script)
     except Exception as e:
-        flash(f'Processing failed: {str(e)}', 'error')
-        return render_template('index.html', voices=VOICE_OPTIONS)
+        print(f"An error occurred during processing: {e}")
+        flash(f"An unexpected error occurred: {e}. Please check the console and try again.", "error")
+        return render_template('index.html')
     finally:
-        if 'input_path' in locals() and os.path.exists(input_path):
-            os.remove(input_path)
+        if input_video_path and os.path.exists(input_video_path):
+            os.remove(input_video_path)
+        if temp_audio_path and os.path.exists(temp_audio_path):
+            os.remove(temp_audio_path)
 
 @app.route('/downloads/<filename>')
-def download(filename):
+def serve_video(filename):
+    """Serves the final dubbed video."""
     return send_from_directory(app.config['DOWNLOAD_FOLDER'], filename)
 
+# --- 5. APPLICATION ENTRY POINT ---
 if __name__ == '__main__':
     app.run(host="0.0.0.0", port=7860)