Update app.py

app.py

@@ -6,9 +6,7 @@ import google.generativeai as genai
 import requests
 import yt_dlp
 from flask import Flask, request, render_template, send_from_directory, url_for, flash
-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
 from werkzeug.utils import secure_filename
 from dotenv import load_dotenv
 
@@ -16,29 +14,41 @@ from dotenv import load_dotenv
 load_dotenv()
 app = Flask(__name__)
 
+# 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
-app.secret_key = os.urandom(24)
+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 AI scriptwriter... (The full prompt remains the same as before)
+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.
+
+**CRITICAL INSTRUCTIONS:**
+1.  **Single Script:** Combine all dialogue from all speakers into one continuous script.
+2.  **NO Timestamps or Speaker Labels:** Do NOT include any timestamps or speaker identifiers.
+3.  **Incorporate Performance:** Add English style prompts (e.g., `Say happily:`, `Whisper mysteriously:`) and performance tags (e.g., `[laugh]`, `[sigh]`) directly into the text for an expressive narration.
+
+**EXAMPLE OUTPUT:**
+Say happily: வணக்கம்! [laugh] எப்படி இருக்கீங்க? Whisper mysteriously: அந்த ரகசியம் எனக்கு மட்டும் தான் தெரியும்.
 """
 
 # --- 3. CORE LOGIC HELPER FUNCTIONS ---
@@ -46,41 +56,27 @@ You are an AI scriptwriter... (The full prompt remains the same as before)
 def download_youtube_video(url, output_folder):
     """Downloads a YouTube video to a specified folder using the yt-dlp library."""
     print(f"📥 Downloading video from YouTube URL: {url}")
-    
-    # Generate a unique filename to avoid collisions
     unique_filename = f"{uuid.uuid4()}.mp4"
     output_path_template = os.path.join(output_folder, os.path.splitext(unique_filename)[0])
-
     ydl_opts = {
         'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
-        'outtmpl': output_path_template,
-        'merge_output_format': 'mp4',
-        'quiet': True,
-        'noplaylist': True,
+        'outtmpl': output_path_template, 'merge_output_format': 'mp4',
+        'quiet': False, 'noplaylist': True, 'progress': True,
     }
-    
     try:
         with yt_dlp.YoutubeDL(ydl_opts) as ydl:
             ydl.download([url])
-        
-        # The actual filename will have a .mp4 extension
         downloaded_file_path = f"{output_path_template}.mp4"
         if os.path.exists(downloaded_file_path):
             print(f"✅ Download complete! File saved to: {downloaded_file_path}")
             return downloaded_file_path
-        else:
-            # Fallback for some edge cases where the extension might differ
-            for f in os.listdir(output_folder):
-                if f.startswith(os.path.splitext(unique_filename)[0]):
-                    return os.path.join(output_folder, f)
-            raise FileNotFoundError("Downloaded video file not found.")
-
+        raise FileNotFoundError("Downloaded video file not found after yt-dlp process.")
     except Exception as e:
         print(f"❌ An error occurred during YouTube download: {e}")
-        raise  # Re-raise the exception to be caught by the main processing block
+        raise
 
 def generate_tamil_script(video_file_path):
-    # (This function remains the same as the previous version)
+    """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...")
@@ -90,7 +86,7 @@ def generate_tamil_script(video_file_path):
     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")
+    model = genai.GenerativeModel(model_name="models/gemini-1.5-pro-latest")
     response = model.generate_content([GEMINI_PROMPT, video_file])
     genai.delete_file(video_file.name)
     if hasattr(response, 'text') and response.text:
@@ -98,7 +94,7 @@ def generate_tamil_script(video_file_path):
     raise Exception("No valid script was generated by Gemini.")
 
 def generate_single_audio_track(dialogue_text, voice_name, is_cheerful, output_path):
-    # (This function remains the same)
+    """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)
@@ -109,10 +105,9 @@ def generate_single_audio_track(dialogue_text, voice_name, is_cheerful, output_p
     raise Exception(f"Error from TTS API: {response.status_code} - {response.text}")
 
 def replace_video_audio(video_path, new_audio_path, output_path):
-    # (This function remains the same, using the correct .audio attribute)
+    """Replaces the audio of a video using the modern, correct MoviePy method."""
     print("Replacing video audio using MoviePy...")
-    video_clip = None
-    audio_clip = None
+    video_clip, audio_clip = None, None
     try:
         video_clip = VideoFileClip(video_path)
         audio_clip = AudioFileClip(new_audio_path)
@@ -132,16 +127,11 @@ def index():
 @app.route('/process', methods=['POST'])
 def process_video():
     """Handles video input (upload or URL), processing, and renders the result."""
-    input_video_path = None
-    temp_audio_path = None
-    
+    input_video_path, temp_audio_path = None, None
     try:
-        # Determine input source: YouTube URL or File Upload
         youtube_url = request.form.get('youtube_url', '').strip()
-        
         if youtube_url:
             input_video_path = download_youtube_video(youtube_url, app.config['UPLOAD_FOLDER'])
-            # Generate a secure filename based on the unique downloaded file name
             filename = os.path.basename(input_video_path)
         elif 'video' in request.files and request.files['video'].filename != '':
             file = request.files['video']
@@ -152,33 +142,28 @@ def process_video():
             flash("Please either upload a video file or provide a YouTube URL.")
             return render_template('index.html')
 
-        # Continue with the processing pipeline
         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)
         
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_audio:
             temp_audio_path = temp_audio.name
         
         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("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:
         print(f"An error occurred during processing: {e}")
-        flash(f"An unexpected error occurred: {e}. Please check the console and try again.")
+        flash(f"An unexpected error occurred: {e}. Please check the console and try again.", "error")
         return render_template('index.html')
     finally:
-        # Clean up all temporary files
         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):
@@ -191,4 +176,4 @@ def serve_video(filename):
 
 # --- 5. APPLICATION ENTRY POINT ---
 if __name__ == '__main__':
-    app.run(host="0.0.0.0", port=7860)
+