new upload

.env.example

@@ -0,0 +1,6 @@
+# Required API key for AssemblyAI
+ASSEMBLYAI_API_KEY=your_api_key_here
+
+# Optional configuration
+DEBUG=False
+OUTPUT_DIR=outputs

.gitignore

@@ -0,0 +1,2 @@
+.env
+venv/

README.md

@@ -0,0 +1,89 @@
+# Video Translator 🌐
+
+A complete video translation system that converts videos into multiple languages by translating both subtitles and audio.
+
+## Features
+
+- 🎬 Video to text transcription using AssemblyAI
+- 🔤 Translation of transcripts to multiple languages
+- 🔊 Text-to-speech generation in target languages
+- 📝 Subtitle generation and embedding
+- 🎞️ Final video with translated audio and subtitles
+
+## Supported Languages
+
+- English
+- Spanish
+- French
+- German
+- Japanese
+- Hindi
+- And more...
+
+## Installation
+
+1. Clone this repository:
+```bash
+git clone https://github.com/yourusername/video-translator.git
+cd video-translator
+```
+
+2. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Install FFmpeg:
+   - On Ubuntu/Debian: `sudo apt-get install ffmpeg`
+   - On macOS (with Homebrew): `brew install ffmpeg`
+   - On Windows: Download from [FFmpeg website](https://ffmpeg.org/download.html)
+
+4. Set up your API key:
+   - Copy `.env.example` to `.env`
+   - Add your AssemblyAI API key to the `.env` file
+
+## Usage
+
+1. Run the app:
+```bash
+python app.py
+```
+
+2. Open the provided URL in your browser
+3. Upload a video file
+4. Select source and target languages
+5. Click "Translate" and wait for processing
+
+## Deployment on Hugging Face Spaces
+
+This project is configured for easy deployment to [Hugging Face Spaces](https://huggingface.co/spaces). To deploy:
+
+1. Fork this repository
+2. Create a new Space on Hugging Face
+3. Connect your GitHub repository
+4. Set the required environment variables (ASSEMBLYAI_API_KEY)
+5. Deploy!
+
+## Project Structure
+
+```
+video-translator/
+├── app.py                    # Main Gradio app entry point
+├── config.py                 # Configuration and constants
+├── src/                      # Source code
+│   ├── audio/                # Audio processing
+│   ├── video/                # Video processing
+│   ├── subtitles/            # Subtitle handling
+│   └── utils/                # Utilities and helpers
+└── outputs/                  # Output directory
+```
+
+## Environment Variables
+
+- `ASSEMBLYAI_API_KEY`: API key for AssemblyAI (required)
+- `DEBUG`: Set to "True" for debug logging (optional)
+- `OUTPUT_DIR`: Custom output directory path (optional)
+
+## License
+
+MIT License

app.py

@@ -0,0 +1,161 @@
+"""
+Main application entry point for the Video Translator.
+"""
+import os
+import tempfile
+import shutil
+from pathlib import Path
+
+import gradio as gr
+from tqdm import tqdm
+
+from src.utils.logger import get_logger
+from src.audio.extractor import extract_audio, get_video_duration
+from src.subtitles.transcriber import generate_subtitles
+from src.subtitles.translator import translate_subtitles
+from src.audio.generator import generate_translated_audio
+from src.video.processor import combine_video_audio_subtitles
+from config import LANGUAGES, OUTPUT_DIR, MAX_VIDEO_DURATION, MAX_UPLOAD_SIZE
+
+logger = get_logger(__name__)
+
+def process_video(video_file, source_lang, target_langs, progress=gr.Progress()):
+    """
+    Process video file and generate translated versions.
+    
+    Args:
+        video_file (str): Path to the uploaded video file
+        source_lang (str): Source language name
+        target_langs (list): List of target language names
+        progress (gr.Progress): Gradio progress tracker
+        
+    Returns:
+        list: List of paths to translated videos
+    """
+    try:
+        # Convert language names to codes
+        source_lang_code = LANGUAGES[source_lang]
+        target_lang_codes = [LANGUAGES[lang] for lang in target_langs]
+        
+        # Create temporary copy of uploaded file
+        temp_dir = Path(tempfile.mkdtemp(prefix="video_processing_", dir=OUTPUT_DIR / "temp"))
+        video_path = temp_dir / "input_video.mp4"
+        shutil.copy2(video_file, video_path)
+        
+        logger.info(f"Processing video: {video_path}")
+        logger.info(f"Source language: {source_lang} ({source_lang_code})")
+        logger.info(f"Target languages: {', '.join(target_langs)} ({', '.join(target_lang_codes)})")
+        
+        # Check video duration
+        progress(0.05, "Checking video duration...")
+        duration = get_video_duration(video_path)
+        if duration > MAX_VIDEO_DURATION:
+            raise ValueError(f"Video is too long ({duration:.1f} seconds). Maximum allowed duration is {MAX_VIDEO_DURATION} seconds.")
+        
+        # Extract audio
+        progress(0.1, "Extracting audio...")
+        audio_path = extract_audio(video_path)
+        
+        # Generate subtitles
+        progress(0.2, "Generating subtitles...")
+        srt_path = generate_subtitles(audio_path, source_lang_code)
+        
+        # Translate subtitles
+        progress(0.3, "Translating subtitles...")
+        translated_srt_paths = translate_subtitles(srt_path, target_lang_codes)
+        
+        # Generate translated audio
+        translated_audio_paths = {}
+        for i, (lang_code, srt_path) in enumerate(translated_srt_paths.items()):
+            progress_val = 0.3 + (0.4 * (i / len(translated_srt_paths)))
+            progress(progress_val, f"Generating {[k for k, v in LANGUAGES.items() if v == lang_code][0]} audio...")
+            audio_path = generate_translated_audio(srt_path, lang_code, duration)
+            translated_audio_paths[lang_code] = audio_path
+        
+        # Combine video, audio, and subtitles
+        output_videos = []
+        for i, (lang_code, audio_path) in enumerate(translated_audio_paths.items()):
+            progress_val = 0.7 + (0.25 * (i / len(translated_audio_paths)))
+            lang_name = [k for k, v in LANGUAGES.items() if v == lang_code][0]
+            progress(progress_val, f"Creating {lang_name} video...")
+            
+            srt_path = translated_srt_paths[lang_code]
+            output_path = combine_video_audio_subtitles(video_path, audio_path, srt_path)
+            output_videos.append(output_path)
+        
+        # Clean up
+        try:
+            shutil.rmtree(temp_dir)
+        except:
+            logger.warning(f"Failed to clean up temp directory: {temp_dir}")
+            
+        progress(1.0, "Translation complete!")
+        return output_videos
+        
+    except Exception as e:
+        logger.error(f"Video processing failed: {str(e)}", exc_info=True)
+        raise gr.Error(f"Video processing failed: {str(e)}")
+
+def create_app():
+    """
+    Create and configure the Gradio application.
+    
+    Returns:
+        gr.Blocks: Configured Gradio application
+    """
+    with gr.Blocks(title="Video Translator") as app:
+        gr.Markdown("# 🌐 Video Translator")
+        gr.Markdown("Upload a video and translate it to different languages with subtitles!")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                video_input = gr.Video(label="Upload Video")
+                source_lang = gr.Dropdown(
+                    choices=sorted(list(LANGUAGES.keys())), 
+                    value="English", 
+                    label="Source Language"
+                )
+                target_langs = gr.CheckboxGroup(
+                    choices=[lang for lang in sorted(list(LANGUAGES.keys())) if lang != "English"],
+                    value=["Spanish", "French"],
+                    label="Target Languages"
+                )
+                translate_btn = gr.Button("Translate Video", variant="primary")
+                
+            with gr.Column(scale=2):
+                output_gallery = gr.Gallery(
+                    label="Translated Videos",
+                    columns=2,
+                    object_fit="contain",
+                    height="auto"
+                )
+                
+        translate_btn.click(
+            fn=process_video,
+            inputs=[video_input, source_lang, target_langs],
+            outputs=output_gallery
+        )
+        
+        gr.Markdown("""
+        ## How it works
+        
+        1. Upload a video (max 10 minutes)
+        2. Select the source language of your video
+        3. Choose the target languages you want to translate to
+        4. Click "Translate Video" and wait for processing
+        5. Download your translated videos!
+        
+        ## Features
+        
+        - Automatic speech recognition using AssemblyAI
+        - Translation to multiple languages
+        - Generated speech in target languages
+        - Embedded subtitles
+        """)
+        
+    return app
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch(share=True, enable_queue=True)
+    logger.info("Starting Video Translator application...")

config.py

@@ -0,0 +1,74 @@
+"""
+Configuration settings for the video translator application.
+"""
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Base directory
+BASE_DIR = Path(__file__).resolve().parent
+
+# API Keys
+ASSEMBLYAI_API_KEY = os.getenv("ASSEMBLYAI_API_KEY")
+if not ASSEMBLYAI_API_KEY:
+    raise ValueError("ASSEMBLYAI_API_KEY is not set in environment variables or .env file")
+
+# Output directory
+OUTPUT_DIR = Path(os.getenv("OUTPUT_DIR", BASE_DIR / "outputs"))
+OUTPUT_DIR.mkdir(exist_ok=True)
+
+# Temp directory for processing
+TEMP_DIR = OUTPUT_DIR / "temp"
+TEMP_DIR.mkdir(exist_ok=True)
+
+# Debug mode
+DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+
+# Supported languages
+LANGUAGES = {
+    "English": "en",
+    "Spanish": "es", 
+    "French": "fr",
+    "German": "de",
+    "Japanese": "ja",
+    "Hindi": "hi",
+    "Chinese (Simplified)": "zh-CN",
+    "Russian": "ru",
+    "Italian": "it",
+    "Portuguese": "pt",
+    "Arabic": "ar",
+    "Korean": "ko"
+}
+
+# TTS voice mapping for different languages
+TTS_VOICES = {
+    "en": "en-US",
+    "es": "es-ES",
+    "fr": "fr-FR",
+    "de": "de-DE",
+    "ja": "ja-JP",
+    "hi": "hi-IN",
+    "zh-CN": "zh-CN",
+    "ru": "ru-RU",
+    "it": "it-IT",
+    "pt": "pt-BR",
+    "ar": "ar",
+    "ko": "ko"
+}
+
+# FFmpeg configurations
+FFMPEG_AUDIO_PARAMS = {
+    "format": "wav",
+    "codec": "pcm_s16le",
+    "sample_rate": 44100,
+    "channels": 2
+}
+
+# Application settings
+MAX_VIDEO_DURATION = 600  # in seconds (10 minutes)
+MAX_UPLOAD_SIZE = 500 * 1024 * 1024  # 500 MB
+SUBTITLE_FONT_SIZE = 24
+MAX_RETRY_ATTEMPTS = 3

dir_struct.txt

@@ -0,0 +1,31 @@
+video-translator/
+├── .gitignore
+├── README.md
+├── LICENSE
+├── requirements.txt
+├── app.py                    # Main Gradio app entry point
+├── config.py                 # Configuration and constants
+├── .env.example              # Example environment variables
+├── src/
+│   ├── __init__.py
+│   ├── audio/
+│   │   ├── __init__.py
+│   │   ├── extractor.py      # Audio extraction from video
+│   │   └── generator.py      # TTS generation
+│   ├── video/
+│   │   ├── __init__.py
+│   │   └── processor.py      # Video processing functions
+│   ├── subtitles/
+│   │   ├── __init__.py
+│   │   ├── transcriber.py    # Subtitle generation
+│   │   └── translator.py     # Subtitle translation
+│   └── utils/
+│       ├── __init__.py
+│       └── logger.py         # Logging configuration
+├── tests/
+│   ├── __init__.py
+│   ├── test_audio.py
+│   ├── test_subtitles.py
+│   └── test_video.py
+└── outputs/                  # Output directory (generated)
+    └── .gitkeep

requirements.txt

@@ -0,0 +1,20 @@
+# Core dependencies
+gradio==3.50.2
+python-dotenv==1.0.0
+tqdm==4.66.1
+
+# Video and audio processing
+ffmpeg-python==0.2.0
+moviepy==1.0.3
+pydub==0.25.1
+
+# Speech recognition and text-to-speech
+assemblyai==0.15.1
+gTTS==2.3.2
+
+# Translation and subtitle handling
+deep-translator==1.9.2
+pysrt==1.1.2
+
+# Utility packages
+loguru==0.7.2

src/audio/extractor.py

@@ -0,0 +1,143 @@
+"""
+Audio extraction utilities for the video translator application.
+"""
+import os
+import subprocess
+from pathlib import Path
+
+from src.utils.logger import get_logger
+from config import OUTPUT_DIR, FFMPEG_AUDIO_PARAMS
+
+logger = get_logger(__name__)
+
+def extract_audio(video_path):
+    """
+    Extract audio from video file using ffmpeg.
+    
+    Args:
+        video_path (str): Path to the input video file
+        
+    Returns:
+        Path: Path to the extracted audio file
+        
+    Raises:
+        Exception: If audio extraction fails
+    """
+    try:
+        video_path = Path(video_path)
+        logger.info(f"Extracting audio from video: {video_path}")
+        
+        # Create output filename based on input filename
+        video_name = video_path.stem
+        audio_path = OUTPUT_DIR / f"{video_name}_audio.{FFMPEG_AUDIO_PARAMS['format']}"
+        
+        # Use ffmpeg to extract audio
+        cmd = [
+            'ffmpeg',
+            '-i', str(video_path),
+            '-vn',  # No video
+            '-acodec', FFMPEG_AUDIO_PARAMS['codec'],
+            '-ar', str(FFMPEG_AUDIO_PARAMS['sample_rate']),
+            '-ac', str(FFMPEG_AUDIO_PARAMS['channels']),
+            '-y',  # Overwrite output file
+            str(audio_path)
+        ]
+        
+        logger.debug(f"Running command: {' '.join(cmd)}")
+        process = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if process.returncode != 0:
+            error_message = f"Audio extraction failed: {process.stderr}"
+            logger.error(error_message)
+            raise Exception(error_message)
+        
+        logger.info(f"Audio extraction successful: {audio_path}")
+        return audio_path
+    except Exception as e:
+        logger.error(f"Audio extraction failed: {str(e)}", exc_info=True)
+        raise Exception(f"Audio extraction failed: {str(e)}")
+
+def get_video_duration(video_path):
+    """
+    Get the duration of a video file in seconds.
+    
+    Args:
+        video_path (str): Path to the video file
+        
+    Returns:
+        float: Duration in seconds
+        
+    Raises:
+        Exception: If duration extraction fails
+    """
+    try:
+        video_path = Path(video_path)
+        logger.info(f"Getting duration for video: {video_path}")
+        
+        cmd = [
+            'ffprobe', 
+            '-v', 'error', 
+            '-show_entries', 'format=duration', 
+            '-of', 'default=noprint_wrappers=1:nokey=1', 
+            str(video_path)
+        ]
+        
+        process = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if process.returncode != 0 or not process.stdout.strip():
+            error_message = f"Failed to get video duration: {process.stderr}"
+            logger.error(error_message)
+            raise Exception(error_message)
+        
+        duration = float(process.stdout.strip())
+        logger.info(f"Video duration: {duration} seconds")
+        return duration
+    except Exception as e:
+        logger.error(f"Failed to get video duration: {str(e)}", exc_info=True)
+        raise Exception(f"Failed to get video duration: {str(e)}")
+
+def create_silent_audio(duration, output_path=None):
+    """
+    Create a silent audio file with the specified duration.
+    
+    Args:
+        duration (float): Duration in seconds
+        output_path (str, optional): Path to save the silent audio file
+        
+    Returns:
+        Path: Path to the silent audio file
+        
+    Raises:
+        Exception: If silent audio creation fails
+    """
+    try:
+        if output_path is None:
+            output_path = OUTPUT_DIR / f"silent_{int(duration)}s.wav"
+        else:
+            output_path = Path(output_path)
+            
+        logger.info(f"Creating silent audio track of {duration} seconds")
+        
+        cmd = [
+            'ffmpeg',
+            '-f', 'lavfi',
+            '-i', f'anullsrc=r={FFMPEG_AUDIO_PARAMS["sample_rate"]}:cl=stereo',
+            '-t', str(duration),
+            '-q:a', '0',
+            '-y',
+            str(output_path)
+        ]
+        
+        logger.debug(f"Running command: {' '.join(cmd)}")
+        process = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if process.returncode != 0:
+            error_message = f"Silent audio creation failed: {process.stderr}"
+            logger.error(error_message)
+            raise Exception(error_message)
+        
+        logger.info(f"Silent audio created: {output_path}")
+        return output_path
+    except Exception as e:
+        logger.error(f"Failed to create silent audio: {str(e)}", exc_info=True)
+        raise Exception(f"Failed to create silent audio: {str(e)}")

src/audio/generator.py

@@ -0,0 +1,184 @@
+"""
+Text-to-speech audio generation for translated subtitles.
+"""
+import os
+import time
+import shutil
+import tempfile
+from pathlib import Path
+from tqdm import tqdm
+import subprocess
+
+from gtts import gTTS
+import pysrt
+
+from src.utils.logger import get_logger
+from src.audio.extractor import create_silent_audio
+from config import OUTPUT_DIR, TTS_VOICES, MAX_RETRY_ATTEMPTS
+
+logger = get_logger(__name__)
+
+def generate_translated_audio(srt_path, target_lang, video_duration=180):
+    """
+    Generate translated audio using text-to-speech for each subtitle.
+    
+    Args:
+        srt_path (str): Path to the SRT subtitle file
+        target_lang (str): Target language code (e.g., 'en', 'es')
+        video_duration (float): Duration of the original video in seconds
+        
+    Returns:
+        Path: Path to the translated audio file
+        
+    Raises:
+        Exception: If audio generation fails
+    """
+    try:
+        srt_path = Path(srt_path)
+        logger.info(f"Generating translated audio for {target_lang} from {srt_path}")
+        
+        # Load subtitles
+        subs = pysrt.open(srt_path, encoding="utf-8")
+        logger.info(f"Loaded {len(subs)} subtitles from SRT file")
+        
+        # Create temporary directory for audio chunks
+        temp_dir = Path(tempfile.mkdtemp(prefix=f"audio_{target_lang}_", dir=OUTPUT_DIR / "temp"))
+        logger.debug(f"Created temporary directory: {temp_dir}")
+        
+        # Generate TTS for each subtitle
+        audio_files = []
+        timings = []
+        
+        logger.info(f"Generating speech for {len(subs)} subtitles in {target_lang}")
+        for i, sub in enumerate(tqdm(subs, desc=f"Generating {target_lang} speech")):
+            text = sub.text.strip()
+            if not text:
+                continue
+                
+            # Get timing information
+            start_time = (sub.start.hours * 3600 + 
+                         sub.start.minutes * 60 + 
+                         sub.start.seconds + 
+                         sub.start.milliseconds / 1000)
+            
+            end_time = (sub.end.hours * 3600 + 
+                       sub.end.minutes * 60 + 
+                       sub.end.seconds + 
+                       sub.end.milliseconds / 1000)
+            
+            duration = end_time - start_time
+            
+            # Generate TTS audio
+            tts_lang = TTS_VOICES.get(target_lang, target_lang)
+            audio_file = temp_dir / f"chunk_{i:04d}.mp3"
+            
+            # Add a retry mechanism
+            retry_count = 0
+            while retry_count < MAX_RETRY_ATTEMPTS:
+                try:
+                    # For certain languages, use slower speed which might improve reliability
+                    slow_option = target_lang in ["hi", "ja", "zh-CN", "ar"] 
+                    tts = gTTS(text=text, lang=target_lang, slow=slow_option)
+                    tts.save(str(audio_file))
+                    
+                    if audio_file.exists() and audio_file.stat().st_size > 0:
+                        break
+                    else:
+                        raise Exception("Generated audio file is empty")
+                        
+                except Exception as e:
+                    retry_count += 1
+                    logger.warning(f"TTS attempt {retry_count} failed for {target_lang}: {str(e)}")
+                    time.sleep(1)  # Wait before retrying
+                    
+                    # If still failing after retries, try with shorter text
+                    if retry_count == MAX_RETRY_ATTEMPTS - 1 and len(text) > 100:
+                        logger.warning(f"Trying with shortened text for {target_lang}")
+                        shortened_text = text[:100] + "..."
+                        tts = gTTS(text=shortened_text, lang=target_lang, slow=True)
+                        tts.save(str(audio_file))
+            
+            if audio_file.exists() and audio_file.stat().st_size > 0:
+                audio_files.append(audio_file)
+                timings.append((start_time, end_time, duration, audio_file))
+            else:
+                logger.warning(f"Failed to generate audio for subtitle {i}")
+        
+        # Check if we generated any audio files
+        if not audio_files:
+            logger.warning(f"No audio files were generated for {target_lang}")
+            # Create a silent audio file as fallback
+            silent_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.wav"
+            create_silent_audio(video_duration, silent_audio)
+            return silent_audio
+        
+        # Create a silent audio track as base
+        silence_file = temp_dir / "silence.wav"
+        create_silent_audio(video_duration, silence_file)
+        
+        # Create filter complex for audio mixing
+        filter_complex = []
+        input_count = 1  # Starting with 1 because 0 is the silence track
+        
+        # Start with silent track
+        filter_parts = ["[0:a]"]
+        
+        # Add each audio segment
+        for start_time, end_time, duration, audio_file in timings:
+            delay_ms = int(start_time * 1000)
+            filter_parts.append(f"[{input_count}:a]adelay={delay_ms}|{delay_ms}")
+            input_count += 1
+        
+        # Mix all audio tracks
+        filter_parts.append(f"amix=inputs={input_count}:dropout_transition=0:normalize=0[aout]")
+        filter_complex = ";".join(filter_parts)
+        
+        # Build the ffmpeg command
+        cmd = ['ffmpeg', '-y']
+        
+        # Add silent base track
+        cmd.extend(['-i', str(silence_file)])
+        
+        # Add all audio chunks
+        for audio_file in audio_files:
+            cmd.extend(['-i', str(audio_file)])
+        
+        # Add filter complex and output
+        output_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.wav"
+        cmd.extend([
+            '-filter_complex', filter_complex,
+            '-map', '[aout]',
+            output_audio
+        ])
+        
+        # Run the command
+        logger.info(f"Combining {len(audio_files)} audio segments")
+        logger.debug(f"Running command: {' '.join(cmd)}")
+        process = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if process.returncode != 0:
+            logger.error(f"Audio combination failed: {process.stderr}")
+            # Create a fallback silent audio
+            silent_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.wav"
+            create_silent_audio(video_duration, silent_audio)
+            output_audio = silent_audio
+        
+        # Clean up temporary files
+        try:
+            shutil.rmtree(temp_dir)
+            logger.debug(f"Cleaned up temporary directory: {temp_dir}")
+        except Exception as e:
+            logger.warning(f"Failed to clean up temp directory: {str(e)}")
+        
+        logger.info(f"Successfully created translated audio: {output_audio}")
+        return output_audio
+    except Exception as e:
+        logger.error(f"Audio translation failed: {str(e)}", exc_info=True)
+        
+        # Create an emergency fallback silent audio
+        try:
+            silent_audio = OUTPUT_DIR / f"translated_audio_{target_lang}.wav"
+            create_silent_audio(video_duration, silent_audio)
+            return silent_audio
+        except:
+            raise Exception(f"Audio translation failed: {str(e)}")

src/subtitles/transcriber.py

@@ -0,0 +1,63 @@
+"""
+Speech-to-text transcription for subtitle generation.
+"""
+import os
+from pathlib import Path
+import assemblyai as aai
+
+from src.utils.logger import get_logger
+from config import ASSEMBLYAI_API_KEY, OUTPUT_DIR
+
+logger = get_logger(__name__)
+
+# Configure AssemblyAI
+aai.settings.api_key = ASSEMBLYAI_API_KEY
+
+def generate_subtitles(audio_path, language_code="en"):
+    """
+    Generate subtitles using AssemblyAI's speech recognition.
+    
+    Args:
+        audio_path (str): Path to the audio file
+        language_code (str): Language code for transcription
+        
+    Returns:
+        Path: Path to the generated SRT subtitle file
+        
+    Raises:
+        Exception: If subtitle generation fails
+    """
+    try:
+        audio_path = Path(audio_path)
+        logger.info(f"Transcribing audio with AssemblyAI: {audio_path}")
+        
+        # Create output filename
+        audio_name = audio_path.stem
+        srt_path = OUTPUT_DIR / f"{audio_name}_subtitles.srt"
+        
+        # Configure transcription options
+        config = aai.TranscriptionConfig(
+            language_code=language_code,
+            punctuate=True,
+            format_text=True
+        )
+        
+        # Transcribe audio
+        transcriber = aai.Transcriber()
+        transcript = transcriber.transcribe(str(audio_path), config=config)
+        
+        if not transcript or not hasattr(transcript, 'export_subtitles_srt'):
+            error_message = "Transcription failed or returned invalid result"
+            logger.error(error_message)
+            raise Exception(error_message)
+        
+        # Export as SRT
+        logger.info(f"Saving subtitles to: {srt_path}")
+        with open(srt_path, "w", encoding="utf-8") as f:
+            f.write(transcript.export_subtitles_srt())
+            
+        logger.info(f"Subtitle generation successful: {srt_path}")
+        return srt_path
+    except Exception as e:
+        logger.error(f"Subtitle generation failed: {str(e)}", exc_info=True)
+        raise Exception(f"Subtitle generation failed: {str(e)}")

src/subtitles/translator.py

@@ -0,0 +1,78 @@
+"""
+Translation of subtitles into target languages.
+"""
+import os
+from pathlib import Path
+import time
+from tqdm import tqdm
+import pysrt
+from deep_translator import GoogleTranslator
+
+from src.utils.logger import get_logger
+from config import OUTPUT_DIR, MAX_RETRY_ATTEMPTS
+
+logger = get_logger(__name__)
+
+def translate_subtitles(srt_path, target_langs):
+    """
+    Translate subtitles to target languages.
+    
+    Args:
+        srt_path (str): Path to the SRT subtitle file
+        target_langs (list): List of target language codes
+        
+    Returns:
+        dict: Dictionary mapping language codes to translated SRT file paths
+        
+    Raises:
+        Exception: If translation fails
+    """
+    try:
+        srt_path = Path(srt_path)
+        logger.info(f"Loading subtitles from: {srt_path}")
+        
+        # Load subtitles
+        subs = pysrt.open(srt_path, encoding="utf-8")
+        logger.info(f"Loaded {len(subs)} subtitles from SRT file")
+        
+        results = {}
+        
+        for lang_code in target_langs:
+            logger.info(f"Translating to language code: {lang_code}")
+            translated_subs = subs[:]  # Create a copy
+            translator = GoogleTranslator(source="auto", target=lang_code)
+            
+            # Translate each subtitle with progress bar
+            for i, sub in enumerate(tqdm(translated_subs, desc=f"Translating to {lang_code}")):
+                retry_count = 0
+                original_text = sub.text
+                
+                while retry_count < MAX_RETRY_ATTEMPTS:
+                    try:
+                        sub.text = translator.translate(original_text)
+                        break
+                    except Exception as e:
+                        retry_count += 1
+                        logger.warning(f"Translation attempt {retry_count} failed: {str(e)}")
+                        time.sleep(1)  # Delay between retries
+                        
+                        # If final retry, preserve original text
+                        if retry_count == MAX_RETRY_ATTEMPTS:
+                            logger.warning(f"Failed to translate subtitle after {MAX_RETRY_ATTEMPTS} attempts")
+                            sub.text = original_text
+                
+                # Log progress periodically
+                if (i + 1) % 20 == 0 or i == len(translated_subs) - 1:
+                    logger.info(f"Translated {i+1}/{len(translated_subs)} subtitles to {lang_code}")
+            
+            # Save translated subtitles
+            output_path = OUTPUT_DIR / f"subtitles_{lang_code}.srt"
+            logger.info(f"Saving translated subtitles to: {output_path}")
+            translated_subs.save(str(output_path), encoding='utf-8')
+            results[lang_code] = output_path
+            
+        logger.info(f"Successfully translated subtitles to {len(results)} languages")
+        return results
+    except Exception as e:
+        logger.error(f"Translation failed: {str(e)}", exc_info=True)
+        raise Exception(f"Translation failed: {str(e)}")

src/utils/logger.py

@@ -0,0 +1,55 @@
+"""
+Centralized logging configuration for the application.
+"""
+import sys
+import os
+from loguru import logger
+from pathlib import Path
+
+from config import DEBUG, OUTPUT_DIR
+
+# Create logs directory
+LOGS_DIR = OUTPUT_DIR / "logs"
+LOGS_DIR.mkdir(exist_ok=True)
+
+# Configure logger
+logger.remove()  # Remove default handler
+
+# Add console handler
+log_level = "DEBUG" if DEBUG else "INFO"
+logger.add(
+    sys.stderr,
+    format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+    level=log_level
+)
+
+# Add file handler for errors
+logger.add(
+    LOGS_DIR / "error_{time:YYYY-MM-DD}.log",
+    format="{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}",
+    level="ERROR",
+    rotation="1 day",
+    retention="7 days"
+)
+
+# Add file handler for all logs
+logger.add(
+    LOGS_DIR / "app_{time:YYYY-MM-DD}.log",
+    format="{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}",
+    level=log_level,
+    rotation="1 day",
+    retention="3 days"
+)
+
+# Export the configured logger
+def get_logger(name):
+    """
+    Get a logger instance with the specified name.
+    
+    Args:
+        name (str): Name of the logger, typically __name__
+        
+    Returns:
+        logger: Configured logger instance
+    """
+    return logger.bind(name=name)

src/video/processor.py

@@ -0,0 +1,241 @@
+"""
+Video processing utilities for combining video, audio, and subtitles.
+"""
+import os
+import shutil
+import subprocess
+from pathlib import Path
+import tempfile
+
+from src.utils.logger import get_logger
+from config import OUTPUT_DIR, SUBTITLE_FONT_SIZE
+
+logger = get_logger(__name__)
+
+def combine_video_audio_subtitles(video_path, audio_path, srt_path, output_path=None):
+    """
+    Combine video with translated audio and subtitles.
+    
+    Args:
+        video_path (str): Path to the video file
+        audio_path (str): Path to the translated audio file
+        srt_path (str): Path to the subtitle file
+        output_path (str, optional): Path for the output video
+        
+    Returns:
+        Path: Path to the output video
+        
+    Raises:
+        Exception: If combining fails
+    """
+    try:
+        video_path = Path(video_path)
+        audio_path = Path(audio_path)
+        srt_path = Path(srt_path)
+        
+        # Generate output path if not provided
+        if output_path is None:
+            lang_code = srt_path.stem.split('_')[-1]
+            output_path = OUTPUT_DIR / f"{video_path.stem}_translated_{lang_code}.mp4"
+        else:
+            output_path = Path(output_path)
+            
+        logger.info(f"Combining video, audio, and subtitles")
+        
+        # Verify that all input files exist
+        if not video_path.exists():
+            raise FileNotFoundError(f"Video file does not exist: {video_path}")
+        if not audio_path.exists():
+            raise FileNotFoundError(f"Audio file does not exist: {audio_path}")
+        if not srt_path.exists():
+            raise FileNotFoundError(f"Subtitle file does not exist: {srt_path}")
+            
+        logger.info(f"Input files verified: Video: {video_path.stat().st_size} bytes, "
+                   f"Audio: {audio_path.stat().st_size} bytes, "
+                   f"Subtitles: {srt_path.stat().st_size} bytes")
+        
+        # Try different methods to combine
+        methods = [
+            combine_method_subtitles_filter,
+            combine_method_with_temp,
+            combine_method_no_subtitles
+        ]
+        
+        success = False
+        error_messages = []
+        
+        for i, method in enumerate(methods):
+            try:
+                logger.info(f"Trying combination method {i+1}/{len(methods)}")
+                result = method(video_path, audio_path, srt_path, output_path)
+                if result and Path(result).exists() and Path(result).stat().st_size > 0:
+                    success = True
+                    output_path = result
+                    logger.info(f"Combination method {i+1} succeeded")
+                    break
+                else:
+                    error_messages.append(f"Method {i+1} failed: Result file not valid")
+            except Exception as e:
+                error_message = f"Method {i+1} failed: {str(e)}"
+                logger.warning(error_message)
+                error_messages.append(error_message)
+        
+        if not success:
+            error_message = f"All combination methods failed: {'; '.join(error_messages)}"
+            logger.error(error_message)
+            raise Exception(error_message)
+            
+        logger.info(f"Successfully combined video, audio, and subtitles: {output_path}")
+        return output_path
+    except Exception as e:
+        logger.error(f"Combining failed: {str(e)}", exc_info=True)
+        raise Exception(f"Combining failed: {str(e)}")
+
+def combine_method_subtitles_filter(video_path, audio_path, srt_path, output_path):
+    """
+    Combine video, audio, and subtitles using ffmpeg with subtitle filter.
+    
+    Args:
+        video_path (Path): Path to the video file
+        audio_path (Path): Path to the translated audio file
+        srt_path (Path): Path to the subtitle file
+        output_path (Path): Path for the output video
+        
+    Returns:
+        Path: Path to the output video
+    """
+    logger.info(f"Using subtitles filter method")
+    
+    # Use ffmpeg to combine video, audio, and subtitles
+    cmd = [
+        'ffmpeg',
+        '-i', str(video_path),  # Video input
+        '-i', str(audio_path),  # Audio input
+        '-vf', f"subtitles={str(srt_path)}:force_style='FontSize={SUBTITLE_FONT_SIZE}'",  # Subtitle filter
+        '-map', '0:v',  # Map video from first input
+        '-map', '1:a',  # Map audio from second input
+        '-c:v', 'libx264',  # Video codec
+        '-c:a', 'aac',  # Audio codec
+        '-strict', 'experimental',
+        '-b:a', '192k',  # Audio bitrate
+        '-y',  # Overwrite output
+        str(output_path)
+    ]
+    
+    logger.debug(f"Running command: {' '.join(cmd)}")
+    process = subprocess.run(cmd, capture_output=True, text=True)
+    
+    if process.returncode != 0:
+        error_message = f"FFmpeg subtitles filter method failed: {process.stderr}"
+        logger.error(error_message)
+        raise Exception(error_message)
+    
+    return output_path
+
+def combine_method_with_temp(video_path, audio_path, srt_path, output_path):
+    """
+    Combine video, audio, and subtitles using temporary files.
+    
+    Args:
+        video_path (Path): Path to the video file
+        audio_path (Path): Path to the translated audio file
+        srt_path (Path): Path to the subtitle file
+        output_path (Path): Path for the output video
+        
+    Returns:
+        Path: Path to the output video
+    """
+    logger.info(f"Using temporary file method")
+    
+    # Create temporary directory
+    temp_dir = Path(tempfile.mkdtemp(prefix="video_combine_", dir=OUTPUT_DIR / "temp"))
+    try:
+        # Step 1: Combine video with audio
+        temp_video_audio = temp_dir / "video_with_audio.mp4"
+        cmd1 = [
+            'ffmpeg',
+            '-i', str(video_path),
+            '-i', str(audio_path),
+            '-c:v', 'copy',
+            '-c:a', 'aac',
+            '-strict', 'experimental',
+            '-map', '0:v',
+            '-map', '1:a',
+            '-y',
+            str(temp_video_audio)
+        ]
+        
+        logger.debug(f"Running command (step 1): {' '.join(cmd1)}")
+        process1 = subprocess.run(cmd1, capture_output=True, text=True)
+        
+        if process1.returncode != 0:
+            error_message = f"Step 1 failed: {process1.stderr}"
+            logger.error(error_message)
+            raise Exception(error_message)
+            
+        # Step 2: Add subtitles to the combined video
+        cmd2 = [
+            'ffmpeg',
+            '-i', str(temp_video_audio),
+            '-vf', f"subtitles={str(srt_path)}:force_style='FontSize={SUBTITLE_FONT_SIZE}'",
+            '-c:a', 'copy',
+            '-y',
+            str(output_path)
+        ]
+        
+        logger.debug(f"Running command (step 2): {' '.join(cmd2)}")
+        process2 = subprocess.run(cmd2, capture_output=True, text=True)
+        
+        if process2.returncode != 0:
+            error_message = f"Step 2 failed: {process2.stderr}"
+            logger.error(error_message)
+            raise Exception(error_message)
+            
+        return output_path
+    finally:
+        # Clean up temporary directory
+        try:
+            shutil.rmtree(temp_dir)
+            logger.debug(f"Cleaned up temporary directory: {temp_dir}")
+        except Exception as e:
+            logger.warning(f"Failed to clean up temp directory: {str(e)}")
+
+def combine_method_no_subtitles(video_path, audio_path, srt_path, output_path):
+    """
+    Fallback method: Combine only video and audio without subtitles.
+    
+    Args:
+        video_path (Path): Path to the video file
+        audio_path (Path): Path to the translated audio file
+        srt_path (Path): Path to the subtitle file (unused in this method)
+        output_path (Path): Path for the output video
+        
+    Returns:
+        Path: Path to the output video
+    """
+    logger.info(f"Using fallback method (no subtitles)")
+    
+    # Just combine video and audio as fallback
+    cmd = [
+        'ffmpeg',
+        '-i', str(video_path),
+        '-i', str(audio_path),
+        '-c:v', 'copy',
+        '-c:a', 'aac',
+        '-strict', 'experimental',
+        '-map', '0:v',
+        '-map', '1:a',
+        '-y',
+        str(output_path)
+    ]
+    
+    logger.debug(f"Running command: {' '.join(cmd)}")
+    process = subprocess.run(cmd, capture_output=True, text=True)
+    
+    if process.returncode != 0:
+        error_message = f"Fallback method failed: {process.stderr}"
+        logger.error(error_message)
+        raise Exception(error_message)
+    
+    logger.warning("Video was combined without subtitles")
+    return output_path