Update app.py

app.py

@@ -4,334 +4,313 @@ import tempfile
 import uuid
 import google.generativeai as genai
 import requests
-from flask import Flask, request, render_template, send_from_directory, url_for, flash, jsonify
+import re
+from flask import Flask, request, render_template, send_from_directory, jsonify
 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
 import threading
-from datetime import datetime, timedelta
 import logging
+from gtts import gTTS
+import io
+from pathlib import Path
 
-# Initialize Flask app and load secrets
+# Initialize Flask app
 load_dotenv()
 app = Flask(__name__)
 
 # Configuration
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-TTS_API_URL = os.getenv("TTS_API_URL")
-
-if not GEMINI_API_KEY or not TTS_API_URL:
-    raise ValueError("Missing required environment variables")
-
-genai.configure(api_key=GEMINI_API_KEY)
+TTS_API_URL = os.getenv("TTS_API_URL", "")  # Optional
+MAX_CONTENT_LENGTH = 500 * 1024 * 1024  # 500MB
+MAX_TTS_RETRIES = 3
+TTS_CHUNK_SIZE = 2000  # Characters per chunk
 
 # File storage setup
 UPLOAD_FOLDER = 'uploads'
 DOWNLOAD_FOLDER = 'downloads'
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
-os.makedirs(DOWNLOAD_FOLDER, exist_ok=True)
+Path(UPLOAD_FOLDER).mkdir(exist_ok=True)
+Path(DOWNLOAD_FOLDER).mkdir(exist_ok=True)
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 app.config['DOWNLOAD_FOLDER'] = DOWNLOAD_FOLDER
-app.config['MAX_CONTENT_LENGTH'] = 500 * 1024 * 1024  # 500MB
+app.config['MAX_CONTENT_LENGTH'] = MAX_CONTENT_LENGTH
 app.secret_key = os.urandom(24)
 
 # Processing status tracking
 processing_status = {}
-processing_times = {
-    'upload': 0,
-    'transcription': 0,
-    'tts': 0,
-    'dubbing': 0
-}
 
-# Voice options
-VOICE_CHOICES = {
-    "Male (Charon)": "Charon",
-    "Female (Zephyr)": "Zephyr"
+# Language and voice options
+LANGUAGE_MAPPING = {
+    "Arabic (Egyptian)": "ar-EG",
+    "English (US)": "en-US",
+    "Hindi (India)": "hi-IN",
+    "Tamil (India)": "ta-IN",
+    "Telugu (India)": "te-IN"
 }
 
-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.
-
-**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.
+VOICE_TYPES = {
+    "Male": "male",
+    "Female": "female"
+}
 
-**EXAMPLE OUTPUT:**
-Say happily: வணக்கம்! [laugh] எப்படி இருக்கீங்க? Whisper mysteriously: அந்த ரகசியம் எனக்கு மட்டும் தான் தெரியும்.
-"""
+GEMINI_PROMPTS = {
+    "api": """
+    You are an expert AI scriptwriter. Transcribe ALL spoken dialogue into a SINGLE, 
+    CONTINUOUS block of modern {language}. Include natural speech patterns and 
+    performance directions (e.g., [pause], [laugh]) where appropriate.
+    """,
+    "gtts": """
+    You are an expert AI scriptwriter. Transcribe ALL spoken dialogue into a SINGLE, 
+    CONTINUOUS block of modern {language}. Return ONLY the clean transcribed text.
+    """
+}
 
 # Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
-def track_processing_time(task_id, stage, duration):
-    """Track processing times for each stage"""
-    processing_times[stage] = duration
-    if task_id in processing_status:
-        processing_status[task_id]['timings'][stage] = duration
-
-def estimate_remaining_time(task_id):
-    """Estimate remaining processing time"""
-    if task_id not in processing_status:
-        return "Calculating..."
-    
-    status = processing_status[task_id]
-    completed_stages = [s for s in status['timings'] if status['timings'][s] is not None]
+def split_text_into_chunks(text, chunk_size=TTS_CHUNK_SIZE):
+    """Split text into chunks respecting sentence boundaries"""
+    sentences = re.split(r'(?<=[.!?])\s+', text)
+    chunks = []
+    current_chunk = ""
     
-    if len(completed_stages) == 0:
-        return "Starting soon..."
+    for sentence in sentences:
+        if len(current_chunk) + len(sentence) < chunk_size:
+            current_chunk += sentence + " "
+        else:
+            chunks.append(current_chunk.strip())
+            current_chunk = sentence + " "
     
-    # Weighted average based on stage complexity
-    weights = {
-        'transcription': 2.0,
-        'tts': 1.5,
-        'dubbing': 1.0
-    }
-    
-    total_weighted_time = 0
-    total_weights = 0
+    if current_chunk:
+        chunks.append(current_chunk.strip())
     
-    for stage in completed_stages:
-        weight = weights.get(stage, 1.0)
-        total_weighted_time += status['timings'][stage] * weight
-        total_weights += weight
+    return chunks
+
+def generate_tts_audio(text, language_code, voice_type, tts_provider):
+    """Generate TTS audio using selected provider with retry logic"""
+    chunks = split_text_into_chunks(text)
+    audio_segments = []
     
-    if total_weights == 0:
-        return "Estimating..."
+    for chunk in chunks:
+        for attempt in range(MAX_TTS_RETRIES):
+            try:
+                if tts_provider == "api":
+                    # Use custom TTS API
+                    payload = {
+                        "text": chunk,
+                        "language": language_code,
+                        "voice_type": voice_type
+                    }
+                    response = requests.post(TTS_API_URL, json=payload, timeout=300)
+                    
+                    if response.status_code == 200:
+                        audio_segments.append(io.BytesIO(response.content))
+                        break
+                    elif response.status_code == 429:  # Rate limit
+                        retry_after = int(response.headers.get('Retry-After', 5))
+                        logger.warning(f"TTS API rate limited. Retrying after {retry_after}s")
+                        time.sleep(retry_after)
+                        continue
+                    else:
+                        raise Exception(f"TTS API error: {response.status_code}")
+                else:
+                    # Use gTTS
+                    tts = gTTS(
+                        text=chunk,
+                        lang=language_code.split('-')[0],
+                        slow=False
+                    )
+                    buffer = io.BytesIO()
+                    tts.write_to_fp(buffer)
+                    buffer.seek(0)
+                    audio_segments.append(buffer)
+                    break
+                    
+            except Exception as e:
+                logger.warning(f"TTS attempt {attempt + 1} failed: {str(e)}")
+                if attempt == MAX_TTS_RETRIES - 1:
+                    raise Exception(f"Failed to generate TTS after {MAX_TTS_RETRIES} attempts")
+                time.sleep(2 ** attempt)  # Exponential backoff
     
-    avg_time = total_weighted_time / total_weights
-    remaining_stages = 4 - len(completed_stages)
-    return remaining_stages * avg_time
-
-def process_video_background(task_id, video_path, voice, cheerful):
-    """Background processing function with enhanced logging"""
-    try:
-        start_time = time.time()
-        processing_status[task_id] = {
-            'status': 'processing',
-            'progress': 0,
-            'message': 'Starting transcription',
-            'timings': {'upload': None, 'transcription': None, 'tts': None, 'dubbing': None},
-            'start_time': start_time,
-            'video_duration': get_video_duration(video_path)
-        }
-
-        # Stage 1: Transcription
-        processing_status[task_id]['message'] = 'Transcribing video content'
-        logger.info(f"Task {task_id}: Starting transcription")
-        script_start = time.time()
-        script = generate_tamil_script(video_path)
-        transcription_time = time.time() - script_start
-        track_processing_time(task_id, 'transcription', transcription_time)
-        processing_status[task_id]['progress'] = 25
-        processing_status[task_id]['script'] = script
-        logger.info(f"Task {task_id}: Transcription completed in {transcription_time:.1f}s")
-
-        # Stage 2: TTS Generation
-        processing_status[task_id]['message'] = 'Generating audio narration'
-        logger.info(f"Task {task_id}: Starting TTS generation")
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_audio:
-            audio_path = temp_audio.name
-        
-        tts_start = time.time()
-        generate_audio_track(script, voice, cheerful, audio_path)
-        tts_time = time.time() - tts_start
-        track_processing_time(task_id, 'tts', tts_time)
-        processing_status[task_id]['progress'] = 50
-        logger.info(f"Task {task_id}: TTS completed in {tts_time:.1f}s")
-
-        # Stage 3: Dubbing
-        processing_status[task_id]['message'] = 'Creating dubbed video'
-        logger.info(f"Task {task_id}: Starting dubbing")
-        final_filename = f"dubbed_{task_id}.mp4"
-        final_path = os.path.join(app.config['DOWNLOAD_FOLDER'], final_filename)
-        
-        dubbing_start = time.time()
-        replace_video_audio(video_path, audio_path, final_path)
-        dubbing_time = time.time() - dubbing_start
-        track_processing_time(task_id, 'dubbing', dubbing_time)
-        processing_status[task_id]['progress'] = 75
-        logger.info(f"Task {task_id}: Dubbing completed in {dubbing_time:.1f}s")
+    # Combine audio segments
+    combined_audio = io.BytesIO()
+    for segment in audio_segments:
+        combined_audio.write(segment.getvalue())
+    combined_audio.seek(0)
+    return combined_audio
 
-        # Cleanup
-        os.unlink(audio_path)
-
-        # Finalize
-        processing_status[task_id].update({
-            'status': 'complete',
-            'progress': 100,
-            'message': 'Processing complete',
-            'result_path': final_path,
-            'end_time': time.time()
-        })
-        logger.info(f"Task {task_id}: Processing completed successfully")
-
-    except Exception as e:
-        logger.error(f"Task {task_id} failed: {str(e)}")
-        processing_status[task_id].update({
-            'status': 'error',
-            'message': f'Error: {str(e)}'
-        })
-        # Cleanup temporary files
-        if 'video_path' in locals() and os.path.exists(video_path):
-            os.unlink(video_path)
-        if 'audio_path' in locals() and os.path.exists(audio_path):
-            os.unlink(audio_path)
-
-def get_video_duration(video_path):
-    """Get duration of video in seconds"""
-    try:
-        with VideoFileClip(video_path) as video:
-            return video.duration
-    except:
-        return 0
-
-def generate_tamil_script(video_path):
-    """Generate Tamil script using Gemini with retry logic"""
+def generate_transcription(video_path, prompt):
+    """Generate transcript using Gemini with retry logic"""
     max_retries = 3
-    retry_delay = 10  # seconds
-    
     for attempt in range(max_retries):
         try:
             video_file = genai.upload_file(video_path, mime_type="video/mp4")
-            
-            # Wait for file processing with timeout
-            start_wait = time.time()
-            while video_file.state.name == "PROCESSING":
-                if time.time() - start_wait > 300:  # 5 minutes timeout
-                    raise TimeoutError("Gemini processing timed out")
-                time.sleep(5)
-                video_file = genai.get_file(video_file.name)
-            
-            if video_file.state.name != "ACTIVE":
-                raise Exception(f"Gemini processing failed: {video_file.state.name}")
-            
-            model = genai.GenerativeModel(model_name="models/gemini-2.5-flash")
-            response = model.generate_content([GEMINI_PROMPT, video_file])
+            model = genai.GenerativeModel("models/gemini-pro-vision")
+            response = model.generate_content([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 generated")
+            if hasattr(response, 'text'):
+                return response.text.strip()
+            raise Exception("No valid transcription generated")
         
         except Exception as e:
-            if attempt < max_retries - 1:
-                logger.warning(f"Gemini error (attempt {attempt+1}/{max_retries}): {str(e)}")
-                time.sleep(retry_delay * (attempt + 1))
-            else:
+            if attempt == max_retries - 1:
                 raise
+            logger.warning(f"Transcription attempt {attempt + 1} failed: {str(e)}")
+            time.sleep(5 * (attempt + 1))
 
-def generate_audio_track(text, voice, cheerful, output_path):
-    """Generate audio using TTS API with retry logic"""
-    max_retries = 3
-    retry_delay = 5  # seconds
-    
-    for attempt in range(max_retries):
-        try:
-            payload = {
-                "text": text,
-                "voice_name": voice,
-                "cheerful": cheerful
-            }
-            
-            response = requests.post(TTS_API_URL, json=payload, timeout=300)
-            if response.status_code != 200:
-                raise Exception(f"TTS API error: {response.status_code} - {response.text}")
-            
-            with open(output_path, "wb") as f:
-                f.write(response.content)
-            return
-        
-        except Exception as e:
-            if attempt < max_retries - 1:
-                logger.warning(f"TTS error (attempt {attempt+1}/{max_retries}): {str(e)}")
-                time.sleep(retry_delay * (attempt + 1))
-            else:
-                raise
-
-def replace_video_audio(video_path, audio_path, output_path):
-    """Replace video audio track with enhanced error handling"""
+def dub_video(video_path, audio_buffer):
+    """Dub video with new audio"""
     video = None
     audio = None
+    temp_audio_path = None
+    
     try:
-        # Open video and audio files
+        # Save audio buffer to temp file
+        temp_audio_path = f"temp_audio_{uuid.uuid4().hex}.mp3"
+        with open(temp_audio_path, 'wb') as f:
+            f.write(audio_buffer.read())
+
+        # Process video
         video = VideoFileClip(video_path)
-        audio = AudioFileClip(audio_path)
+        audio = AudioFileClip(temp_audio_path)
         
-        # Set video audio
-        video.audio = audio
+        # Ensure audio length matches video
+        if audio.duration > video.duration:
+            audio = audio.subclip(0, video.duration)
+        
+        video = video.set_audio(audio)
+        
+        # Save output
+        output_filename = f"dubbed_{uuid.uuid4().hex}.mp4"
+        output_path = os.path.join(app.config['DOWNLOAD_FOLDER'], output_filename)
         
-        # Write output with optimized settings
         video.write_videofile(
             output_path,
             codec="libx264",
             audio_codec="aac",
-            logger=None,
             threads=4,
+            verbose=False,
             preset='medium',
             ffmpeg_params=['-crf', '23', '-movflags', '+faststart']
         )
         
-    except Exception as e:
-        logger.error(f"Video processing error: {str(e)}")
-        # Cleanup partially created file
-        if os.path.exists(output_path):
-            os.unlink(output_path)
-        raise
+        return output_path
+
     finally:
+        # Cleanup resources
         if video:
             video.close()
         if audio:
             audio.close()
+        if temp_audio_path and os.path.exists(temp_audio_path):
+            os.unlink(temp_audio_path)
+
+def process_video_background(task_id, video_path, language, voice_type, tts_provider):
+    """Background video processing"""
+    try:
+        processing_status[task_id] = {
+            'status': 'processing',
+            'progress': 0,
+            'message': 'Starting transcription',
+            'start_time': time.time()
+        }
+
+        # Stage 1: Transcription
+        processing_status[task_id]['message'] = 'Transcribing video content'
+        prompt = GEMINI_PROMPTS[tts_provider].format(language=language)
+        script = generate_transcription(video_path, prompt)
+        processing_status[task_id]['progress'] = 33
+        processing_status[task_id]['script'] = script
+
+        # Stage 2: Audio Generation
+        processing_status[task_id]['message'] = 'Generating audio narration'
+        language_code = LANGUAGE_MAPPING.get(language, "en-US")
+        audio_buffer = generate_tts_audio(script, language_code, voice_type, tts_provider)
+        processing_status[task_id]['progress'] = 66
+
+        # Stage 3: Video Dubbing
+        processing_status[task_id]['message'] = 'Creating dubbed video'
+        output_path = dub_video(video_path, audio_buffer)
+        processing_status[task_id]['progress'] = 100
+        processing_status[task_id]['status'] = 'complete'
+        processing_status[task_id]['result_path'] = output_path
+
+    except Exception as e:
+        processing_status[task_id]['status'] = 'error'
+        processing_status[task_id]['message'] = str(e)
+        logger.error(f"Processing failed: {str(e)}")
+
+    finally:
+        # Cleanup
+        if os.path.exists(video_path):
+            os.unlink(video_path)
 
 @app.route('/')
 def index():
-    """Main page"""
-    return render_template('index.html', voices=VOICE_CHOICES)
+    """Render main page"""
+    return render_template(
+        'index.html',
+        languages=list(LANGUAGE_MAPPING.keys()),
+        voice_types=list(VOICE_TYPES.keys()),
+        default_language="English (US)",
+        tts_api_available=bool(TTS_API_URL)
+    )
 
 @app.route('/upload', methods=['POST'])
 def upload_video():
-    """Handle video upload and start processing"""
+    """Handle video upload"""
     if 'video' not in request.files:
         return jsonify({'error': 'No file uploaded'}), 400
     
     file = request.files['video']
     if file.filename == '':
         return jsonify({'error': 'No file selected'}), 400
-    
-    # Generate unique task ID
-    task_id = str(uuid.uuid4())
+
+    # Validate file extension
+    allowed_extensions = {'mp4', 'mov', 'webm', 'avi'}
+    if '.' not in file.filename or file.filename.rsplit('.', 1)[1].lower() not in allowed_extensions:
+        return jsonify({'error': 'Invalid file type'}), 400
+
+    # Save file with unique name
+    task_id = uuid.uuid4().hex
     filename = secure_filename(f"{task_id}_{file.filename}")
     video_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-    file.save(video_path)
     
+    try:
+        file.save(video_path)
+    except Exception as e:
+        return jsonify({'error': f'Failed to save file: {str(e)}'}), 500
+
     # Get processing options
-    voice = request.form.get('voice', 'Charon')
-    cheerful = request.form.get('cheerful', 'false') == 'true'
-    
+    language = request.form.get('language', 'English (US)')
+    voice_type = request.form.get('voice_type', 'Male')
+    tts_provider = request.form.get('tts_provider', 'gtts')
+
+    # Validate TTS provider selection
+    if tts_provider == "api" and not TTS_API_URL:
+        return jsonify({'error': 'TTS API is not configured'}), 400
+
     # Start background processing
     processing_status[task_id] = {
         'status': 'uploaded',
         'progress': 0,
         'message': 'Starting processing',
-        'timings': {'upload': time.time(), 'transcription': None, 'tts': None, 'dubbing': None},
-        'start_time': time.time(),
-        'video_duration': get_video_duration(video_path)
+        'start_time': time.time()
     }
-    
+
     thread = threading.Thread(
         target=process_video_background,
-        args=(task_id, video_path, voice, cheerful)
+        args=(task_id, video_path, language, voice_type, tts_provider)
     )
     thread.start()
-    
-    return jsonify({
-        'task_id': task_id,
-        'video_duration': processing_status[task_id]['video_duration']
-    })
+
+    return jsonify({'task_id': task_id})
 
 @app.route('/status/<task_id>')
 def get_status(task_id):
@@ -340,70 +319,47 @@ def get_status(task_id):
         return jsonify({'error': 'Invalid task ID'}), 404
     
     status = processing_status[task_id]
-    
-    # Calculate ETA if processing
-    eta = None
-    if status['status'] == 'processing':
-        elapsed = time.time() - status['start_time']
-        remaining = estimate_remaining_time(task_id)
-        if isinstance(remaining, (int, float)):
-            eta = str(timedelta(seconds=int(remaining)))
-    
     response = {
         'status': status['status'],
         'progress': status.get('progress', 0),
         'message': status.get('message', ''),
-        'eta': eta
     }
-    
+
     if status['status'] == 'complete':
-        response['result_url'] = url_for('download', filename=os.path.basename(status['result_path']))
+        response['result_url'] = url_for(
+            'download', 
+            filename=os.path.basename(status['result_path'])
+        )
         response['script'] = status.get('script', '')
+    elif status['status'] == 'error':
+        response['error_details'] = status.get('message', 'Unknown error')
     
     return jsonify(response)
 
 @app.route('/download/<filename>')
 def download(filename):
-    """Serve processed video"""
-    return send_from_directory(app.config['DOWNLOAD_FOLDER'], filename)
-
-@app.route('/cleanup', methods=['POST'])
-def cleanup():
-    """Cleanup old files"""
+    """Serve processed video with security checks"""
     try:
-        # Cleanup uploads older than 1 hour
-        for filename in os.listdir(UPLOAD_FOLDER):
-            file_path = os.path.join(UPLOAD_FOLDER, filename)
-            if os.path.getmtime(file_path) < time.time() - 3600:
-                os.unlink(file_path)
+        # Security check
+        if not filename.startswith('dubbed_') or not filename.endswith('.mp4'):
+            return "Invalid file", 400
         
-        # Cleanup downloads older than 24 hours
-        for filename in os.listdir(DOWNLOAD_FOLDER):
-            file_path = os.path.join(DOWNLOAD_FOLDER, filename)
-            if os.path.getmtime(file_path) < time.time() - 86400:
-                os.unlink(file_path)
-                
-        return jsonify({'status': 'success', 'message': 'Cleanup completed'})
+        # Validate path
+        download_path = Path(app.config['DOWNLOAD_FOLDER']) / filename
+        if not download_path.exists():
+            return "File not found", 404
+            
+        return send_from_directory(
+            app.config['DOWNLOAD_FOLDER'],
+            filename,
+            as_attachment=True,
+            mimetype='video/mp4'
+        )
     except Exception as e:
-        return jsonify({'status': 'error', 'message': str(e)}), 500
+        logger.error(f"Download failed: {str(e)}")
+        return "Download error", 500
 
 if __name__ == '__main__':
-    # Schedule cleanup thread
-    import schedule
-    import time as t
-    def cleanup_job():
-        with app.app_context():
-            app.test_client().post('/cleanup')
-    
-    schedule.every().hour.do(cleanup_job)
-    
-    # Start scheduler in background thread
-    def scheduler_thread():
-        while True:
-            schedule.run_pending()
-            t.sleep(1)
-    
-    threading.Thread(target=scheduler_thread, daemon=True).start()
-    
-    # Start Flask app
+    if not GEMINI_API_KEY:
+        raise ValueError("GEMINI_API_KEY is required in .env file")
     app.run(host="0.0.0.0", port=7860, threaded=True)