Update app.py

app.py

@@ -1,190 +1,151 @@
 import os
-import time
 import tempfile
 import uuid
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from moviepy.editor import VideoFileClip, AudioFileClip
 import google.generativeai as genai
 import requests
-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 werkzeug.utils import secure_filename
 from dotenv import load_dotenv
+from pathlib import Path
 
-# --- 1. INITIALIZE FLASK APP AND LOAD SECRETS ---
+# Load environment variables
 load_dotenv()
-app = Flask(__name__)
 
-# Load secrets from environment variables
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-TTS_API_URL = os.getenv("TTS_API_URL")
+app = FastAPI()
 
-# Validate required configurations
-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 directories
+UPLOAD_DIR = "uploads"
+DOWNLOAD_DIR = "downloads"
+Path(UPLOAD_DIR).mkdir(exist_ok=True)
+Path(DOWNLOAD_DIR).mkdir(exist_ok=True)
 
-# Configure Gemini AI
-genai.configure(api_key=GEMINI_API_KEY)
+# Mount static files
+app.mount("/downloads", StaticFiles(directory="downloads"), name="downloads")
 
-# Configure directories
-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
+# Configuration
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+TTS_API_URL = os.getenv("TTS_API_URL")
+genai.configure(api_key=GEMINI_API_KEY)
 
-# --- 2. APPLICATION CONFIGURATION ---
 VOICE_CHOICES = {
-    "Male (Charon)": "Charon",
-    "Female (Zephyr)": "Zephyr"
+    "male": "Charon",
+    "female": "Zephyr"
 }
 
 GEMINI_PROMPT = """
-You are an AI scriptwriter. Your task is to watch the provided video and transcribe ALL spoken dialogue into a SINGLE, CONTINUOUS block of modern, colloquial Tamil.
+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 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: அந்த ரகசியம் எனக்கு மட்டும் தான் தெரியும்.
+1. Combine all dialogue into one continuous script.
+2. NO timestamps or speaker labels.
+3. Add performance cues (e.g., [laugh], [sigh]) and directions (e.g., "Say happily:").
 """
 
-# --- 3. CORE APPLICATION FUNCTIONS ---
-
-def generate_tamil_script(video_file_path):
-    """Generates a Tamil script from the video using Gemini AI."""
-    print("Uploading video to Gemini for transcription...")
-    video_file = genai.upload_file(video_file_path, mime_type="video/mp4")
-    
-    # Wait for 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 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_audio_track(script_text, voice_name, is_cheerful, output_path):
-    """Generates audio from script using TTS API."""
-    print(f"Generating audio (Voice: {voice_name}, Cheerful: {is_cheerful})")
-    payload = {
-        "text": script_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"TTS API Error: {response.status_code} - {response.text}")
-
-def replace_video_audio(video_path, new_audio_path, output_path):
-    """Replaces the audio track of a video file."""
-    print("Replacing video audio...")
-    video_clip = None
-    audio_clip = None
-    
+@app.post("/process")
+async def process_video(
+    file: UploadFile = File(...),
+    voice: str = Form("male"),
+    cheerful: bool = Form(False)
+):
     try:
-        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 audio_clip:
-            audio_clip.close()
-        if video_clip:
-            video_clip.close()
-
-# --- 4. FLASK ROUTES ---
+        # Save uploaded file
+        file_ext = Path(file.filename).suffix
+        file_name = f"{uuid.uuid4()}{file_ext}"
+        file_path = os.path.join(UPLOAD_DIR, file_name)
+        
+        with open(file_path, "wb") as buffer:
+            buffer.write(await file.read())
 
-@app.route('/', methods=['GET'])
-def index():
-    """Render the main upload page."""
-    return render_template('index.html', voices=VOICE_CHOICES)
+        # Generate script using Gemini
+        script = await generate_script(file_path)
+        
+        # Generate audio
+        audio_path = os.path.join(UPLOAD_DIR, f"audio_{uuid.uuid4()}.wav")
+        await generate_audio(script, voice, cheerful, audio_path)
+        
+        # Create dubbed video
+        output_name = f"dubbed_{file_name}"
+        output_path = os.path.join(DOWNLOAD_DIR, output_name)
+        await create_dubbed_video(file_path, audio_path, output_path)
+        
+        # Cleanup
+        os.remove(file_path)
+        os.remove(audio_path)
+        
+        return {
+            "video_url": f"/downloads/{output_name}",
+            "script": script
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
-@app.route('/process', methods=['POST'])
-def process_video():
-    """Handle video upload and processing."""
-    input_video_path = None
-    temp_audio_path = None
-    
+async def generate_script(video_path: str) -> str:
     try:
-        # Validate file upload
-        if 'video' not in request.files or request.files['video'].filename == '':
-            flash("Please upload a video file.", "error")
-            return render_template('index.html', voices=VOICE_CHOICES)
+        video_file = genai.upload_file(video_path, mime_type="video/mp4")
         
-        # Save uploaded file
-        file = request.files['video']
-        filename = secure_filename(file.filename)
-        input_video_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-        file.save(input_video_path)
+        while video_file.state.name == "PROCESSING":
+            video_file = genai.get_file(video_file.name)
         
-        # Get processing options
-        voice_choice = request.form.get('voice', 'Charon')
-        is_cheerful = request.form.get('tone') == 'on'
+        if video_file.state.name != "ACTIVE":
+            raise Exception("Gemini processing failed")
         
-        # Generate script and audio
-        script = generate_tamil_script(input_video_path)
+        model = genai.GenerativeModel("models/gemini-1.5-pro-latest")
+        response = model.generate_content([GEMINI_PROMPT, video_file])
+        genai.delete_file(video_file.name)
         
-        # Create temporary audio file
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_audio:
-            temp_audio_path = temp_audio.name
+        if hasattr(response, 'text'):
+            return " ".join(response.text.strip().splitlines())
+        raise Exception("No script generated")
+    except Exception as e:
+        raise Exception(f"Script generation failed: {str(e)}")
+
+async def generate_audio(text: str, voice: str, cheerful: bool, output_path: str):
+    try:
+        voice_name = VOICE_CHOICES.get(voice, "Charon")
+        payload = {
+            "text": text,
+            "voice_name": voice_name,
+            "cheerful": cheerful
+        }
         
-        generate_audio_track(script, voice_choice, is_cheerful, temp_audio_path)
+        response = requests.post(TTS_API_URL, json=payload, timeout=300)
+        if response.status_code != 200:
+            raise Exception(f"TTS API error: {response.text}")
+            
+        with open(output_path, "wb") as f:
+            f.write(response.content)
+    except Exception as e:
+        raise Exception(f"Audio generation failed: {str(e)}")
+
+async def create_dubbed_video(video_path: str, audio_path: str, output_path: str):
+    try:
+        video = VideoFileClip(video_path)
+        audio = AudioFileClip(audio_path)
         
-        # Create dubbed video
-        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)
+        # Ensure audio matches video duration
+        if audio.duration > video.duration:
+            audio = audio.subclip(0, video.duration)
         
-        flash("Video processing complete!", "success")
-        return render_template(
-            'index.html',
-            voices=VOICE_CHOICES,
-            result_video=url_for('serve_video', filename=final_video_name),
-            script=script
+        video = video.set_audio(audio)
+        video.write_videofile(
+            output_path,
+            codec="libx264",
+            audio_codec="aac",
+            threads=4,
+            preset="fast"
         )
         
+        video.close()
+        audio.close()
     except Exception as e:
-        print(f"Processing error: {str(e)}")
-        flash(f"An error occurred: {str(e)}", "error")
-        return render_template('index.html', voices=VOICE_CHOICES)
-        
-    finally:
-        # Clean up 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):
-            os.remove(temp_audio_path)
-
-@app.route('/downloads/<filename>')
-def serve_video(filename):
-    """Serve the processed video file."""
-    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)
+        raise Exception(f"Video processing failed: {str(e)}")
+
+@app.get("/downloads/{file_name}")
+async def download_file(file_name: str):
+    file_path = os.path.join(DOWNLOAD_DIR, file_name)
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="File not found")
+    return FileResponse(file_path)