Upload 9 files

README.md

@@ -1,12 +1,42 @@
----
-title: Kit Whisperx Web Ui
-emoji: 🚀
-colorFrom: pink
-colorTo: yellow
-sdk: gradio
-sdk_version: 4.31.5
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# **WhisperX Local Installation Kit**
+
+## **Description**
+
+This project enables the local installation and use of WhisperX, an advanced audio transcription system based on OpenAI's Whisper but optimized for running on local hardware with or without a GPU. This project is made possible thanks to [Whisperx](https://github.com/m-bain/whisperX) and [Faster Whisper](https://github.com/SYSTRAN/faster-whisper). This document provides a general overview of the installation and links to the website where the [complete installation and usage](https://mistercontenidos.com/en/how-to-install-whisperx-locally) procedure for this project can be found.
+
+## **Requirements**
+
+- Miniconda
+- CUDA (only for NVIDIA GPU users)
+
+## **File Description**
+
+- **`environment-cuda.yml`**: Configuration file for automatic installation on systems with NVIDIA GPU.
+- **`environment-cpu.yml`**: Configuration file for automatic installation on systems without NVIDIA GPU.
+- **`app.py`**: Script to run the WhisperX user interface on Gradio.
+- **`transcription_utils.py`**: Transcription logic.
+
+## **Installation**
+
+1. **Miniconda**: [Miniconda Installation](https://docs.anaconda.com/free/miniconda/)
+2. **CUDA**: [CUDA Installation](https://developer.nvidia.com/cuda-toolkit-archive) (Only for NVIDIA GPU users)
+3. **GitHub Repository**: Download and setup of the repository. See details on our website.
+
+For a detailed step-by-step installation process, please visit our website: [View complete installation process](https://mistercontenidos.com/en/how-to-install-whisperx-locally)
+
+## **Usage**
+
+To use WhisperX after completing the installation:
+
+1. Activate the corresponding Conda environment.
+2. Run **`python app.py`** to start the Gradio user interface.
+
+## **Authors**
+
+- [MISTER CONTENTS](https://mistercontenidos.com/)
+- [Ricardo Gonzalez](https://www.linkedin.com/in/pedrocuervomkt/)
+
+## **Languages**
+
+- [Spanish](docs/README_ES.md)
+- [Portuguese](docs/README_PT.md)

app.py

@@ -0,0 +1,92 @@
+import gradio as gr
+import torch
+import time
+import os
+from src.transcription_utils import transcribe, language_options, model_options, ModelManager
+
+class TranscriptionApp:
+    def __init__(self):
+        """
+        Initializes an instance with a ModelManager for managing AI models,
+        sets default device and model based on CUDA availability, 
+        and prepares a Gradio app and outputs dictionary for UI interactions and storing results.
+        """
+        self.model_manager = ModelManager()
+        self.default_device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.default_model = "Large-v2" if torch.cuda.is_available() else "Medium"
+        self.app = gr.Blocks()
+        self.outputs = {}  
+        self.last_transcription_time = 0  
+
+        # Crear carpeta Temp si no existe
+        if not os.path.exists('Temp'):
+            os.makedirs('Temp')
+
+    def start_transcription(self, file, device, language, model):
+        """Start transcription process."""
+        start_time = time.time()
+
+        try:
+            results = transcribe(file, device, language, model, self.model_manager)
+        except ValueError as e:
+            return str(e), 0  
+
+        end_time = time.time()
+        self.last_transcription_time = round(end_time - start_time, 1)  
+
+        if results:
+            json_output, txt_path, vtt_path, srt_path = results
+            self.outputs = {
+                'TXT': txt_path,
+                'SRT': srt_path,
+                'JSON': json_output,
+                'VTT': vtt_path                
+            }
+            return self.update_output_text('TXT'), self.last_transcription_time
+        return "No transcription available.", self.last_transcription_time
+
+
+    def update_output_text(self, format_choice):
+        """Update the text area based on the format choice."""
+        if format_choice and self.outputs.get(format_choice):
+            file_path = self.outputs[format_choice]
+            try:
+                with open(file_path, 'r', encoding='utf-8') as file:
+                    return file.read()
+            except FileNotFoundError:
+                return "File not found."
+        return "No file available or format not selected."
+
+    # User interface for the transcription kit using Gradio
+    def setup_ui(self):
+        with self.app:
+            gr.Markdown("# Kit Transcriptor Whisperx")
+            gr.Markdown("❤️ Follow us on [YouTube](https://www.youtube.com/channel/UC_YzjCh-CSSCSGANvt5wBNQ?sub_confirmation=1), [GitHub](https://github.com/rgcodeai) 🌐 More on [Mister Contenidos](https://mistercontenidos.com)")  
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Supported Formats: Audio (mp3, wav) and Video (mp4, avi, mov, flv)")
+                    file_input = gr.File(label="Upload your multimedia file", type="filepath")
+                    device_dropdown = gr.Dropdown(label="Select device", choices=["cuda", "cpu"], value=self.default_device)
+                    model_dropdown = gr.Dropdown(label="Select model", choices=list(model_options.keys()), value=self.default_model)
+                    language_dropdown = gr.Dropdown(label="Select language", choices=list(language_options.keys()), value="Identify")
+                    transcribe_button = gr.Button("Start Transcription")
+                    
+                with gr.Column():
+                    transcription_time_display = gr.Textbox(label="Last Transcription Time (seconds)", interactive=False, lines=1)
+                    format_choice = gr.Radio(['TXT', 'SRT', 'VTT', 'JSON'], label="Select format to view:", value='TXT')
+                    output_text = gr.Textbox(label="File Content", interactive=False, lines=10)
+                    download_button = gr.Button("Download Transcription")
+                    format_choice.change(fn=self.update_output_text, inputs=format_choice, outputs=output_text, queue=True)
+                    download_button.click(fn=lambda x: self.outputs.get(x), inputs=format_choice, outputs=gr.File())
+
+            transcribe_button.click(fn=self.start_transcription, inputs=[file_input, device_dropdown, language_dropdown, model_dropdown], outputs=[output_text, transcription_time_display])
+
+    def launch(self):
+        """Launch the transcription application."""
+        self.setup_ui()
+        self.app.launch()
+
+
+if __name__ == '__main__':
+    app = TranscriptionApp()
+    app.launch()

docs/README_ES.md

@@ -0,0 +1,35 @@
+# WhisperX Local Installation Kit
+
+## Descripción
+Este proyecto permite la instalación y uso local de WhisperX, un avanzado transcriptor de audio basado en OpenAI Whisper pero optimizado para ejecución en hardware local con o sin GPU. Este proyecyo es posible gracias a [Whisperx](https://github.com/m-bain/whisperX) y [Faster Whisper](https://github.com/SYSTRAN/faster-whisper). En este documento se ofrece una descripción general de la instalación y la referencia al sitio web donde se encuentra el [procedimiento completo de instalación y uso](https://mistercontenidos.com/como-instalar-whisperx-en-local) de este proyecto.
+## Rrequisitos
+- Miniconda
+- CUDA (solo para usuarios con GPU NVIDIA)
+
+## Descripción de los archivos
+- `environment-cuda.yml`: Archivo de configuración para la instalación automática en sistemas con GPU NVIDIA.
+- `environment-cpu.yml`: Archivo de configuración para la instalación automática en sistemas sin GPU NVIDIA.
+- `app.py`: Script para ejecutar la interfaz de usuario de WhisperX en Gradio.
+- `transcription_utils.py`: Logica de trascripción.
+
+## Instalación
+
+1. **Miniconda**: [Instalación de Miniconda](https://docs.anaconda.com/free/miniconda/)
+2. **CUDA**: [Instalación de CUDA](https://developer.nvidia.com/cuda-toolkit-archive) (Solo para usuarios con GPU NVIDIA)
+3. **Repositorio de GitHub**: Descarga y configuración del repositorio. Ver detalles en nuestro sitio web.
+
+Para un proceso de instalación detallado paso a paso, por favor visita nuestra página web: [Ver proceso de instalación completo](https://mistercontenidos.com/como-instalar-whisperx-en-local)
+
+## Uso
+Para usar WhisperX después de completar la instalación:
+1. Activar el entorno Conda correspondiente.
+2. Ejecutar `python app.py` para iniciar la interfaz de usuario de Gradio.
+
+## Autores
+- [MISTER CONTENIDOS](https://mistercontenidos.com/)
+- [Ricardo Gonzalez](https://www.linkedin.com/in/pedrocuervomkt/)
+
+## Languages
+
+- [Ingles](README.md)
+- [Português](docs/README_PT.md)

docs/README_PT.md

@@ -0,0 +1,42 @@
+# **Kit de Instalação Local WhisperX**
+
+## **Descrição**
+
+Este projeto possibilita a instalação e uso local do WhisperX, um avançado sistema de transcrição de áudio baseado no OpenAI Whisper, mas otimizado para execução em hardware local com ou sem GPU. Este projeto é possível graças ao [Whisperx](https://github.com/m-bain/whisperX) e ao [Faster Whisper](https://github.com/SYSTRAN/faster-whisper). Este documento oferece uma visão geral da instalação e o link para o site onde está disponível o [procedimento completo de instalação e uso deste projeto.](https://mistercontenidos.com/pt/como-instalar-o-whisperx-localmente)
+
+## **Requisitos**
+
+- Miniconda
+- CUDA (apenas para usuários com GPU NVIDIA)
+
+## **Descrição dos Arquivos**
+
+- **`environment-cuda.yml`**: Arquivo de configuração para instalação automática em sistemas com GPU NVIDIA.
+- **`environment-cpu.yml`**: Arquivo de configuração para instalação automática em sistemas sem GPU NVIDIA.
+- **`app.py`**: Script para executar a interface de usuário do WhisperX no Gradio.
+- **`transcription_utils.py`**: Lógica de transcrição.
+
+## **Instalação**
+
+1. **Miniconda**: [Instalação do Miniconda](https://docs.anaconda.com/free/miniconda/)
+2. **CUDA**: [Instalação do CUDA](https://developer.nvidia.com/cuda-toolkit-archive) (Apenas para usuários com GPU NVIDIA)
+3. **Repositório do GitHub**: Download e configuração do repositório. Veja detalhes em nosso site.
+
+Para um processo de instalação detalhado passo a passo, por favor visite nosso site: [Ver processo de instalação completo](https://mistercontenidos.com/pt/como-instalar-o-whisperx-localmente)
+
+## **Uso**
+
+Para usar o WhisperX após completar a instalação:
+
+1. Ative o ambiente Conda correspondente.
+2. Execute **`python app.py`** para iniciar a interface de usuário do Gradio.
+
+## **Autores**
+
+- [MISTER CONTEÚDOS](https://mistercontenidos.com/)
+- [Ricardo Gonzalez](https://www.linkedin.com/in/pedrocuervomkt/)
+
+## **Idiomas**
+
+- [Inglês](README.md)
+- [Português](docs/pt/README_PT.md)

environment-cpu.yml

@@ -0,0 +1,14 @@
+name: whisperx-web-ui
+channels:
+  - defaults
+  - conda-forge
+  - pytorch
+dependencies:
+  - python=3.10
+  - pytorch=2.0.0
+  - torchaudio=2.0.0
+  - conda-forge::gradio
+  - conda-forge::ffmpeg
+  - pip
+  - pip:
+      - whisperx

environment-cuda.yml

@@ -0,0 +1,16 @@
+name: whisperx-web-ui
+channels:
+  - defaults
+  - conda-forge
+  - pytorch
+  - nvidia
+dependencies:
+  - python=3.10
+  - pytorch=2.0.0
+  - torchaudio=2.0.0
+  - pytorch-cuda=11.8
+  - conda-forge::gradio
+  - conda-forge::ffmpeg
+  - pip
+  - pip:
+      - whisperx

requirements.txt

@@ -0,0 +1,5 @@
+torch==2.0.0+cu118 -f https://download.pytorch.org/whl/torch_stable.html
+torchaudio==2.0.0 -f https://download.pytorch.org/whl/torch_stable.html
+gradio
+ffmpeg
+whisperx

src/transcription_utils.py

@@ -0,0 +1,176 @@
+import whisperx
+import json
+import os
+import torch
+import mimetypes
+import shutil
+
+# Define language options
+language_options = {
+    "Identify": None,
+    "English": "en", "Spanish": "es", "Chinese": "zh", "Hindi": "hi", "Arabic": "ar",
+    "Portuguese": "pt", "Bengali": "bn", "Russian": "ru", "Japanese": "ja", "Punjabi": "pa",
+    "German": "de", "Javanese": "jv", "Wu Chinese": "zh", "Malay": "ms", "Telugu": "te",
+    "Vietnamese": "vi", "Korean": "ko", "French": "fr", "Marathi": "mr", "Turkish": "tr"
+}
+
+# Available models for transcription
+model_options = {
+    "Large-v2": "large-v2",
+    "Medium": "medium",
+    "Small": "small",
+    "Base": "base"
+}
+
+# Initializes the ModelManager by setting default values and loading a model based on system capabilities (CUDA availability).
+class ModelManager:
+    def __init__(self):
+        self.current_model = None
+        self.current_model_name = None
+        self.current_device = None
+        if torch.cuda.is_available():
+            default_device = "cuda"
+            default_model = "Large-v2"
+        else:
+            default_device = "cpu"
+            default_model = "Medium"
+        self.load_model(default_model, default_device)
+
+    def load_model(self, model_choice, device):
+        if self.current_model is None or model_choice != self.current_model_name or device != self.current_device:
+            print(f"Attempting to load model: {model_choice} on device: {device}")
+            compute_type = "float32" if device == "cpu" else "float16"
+            self.current_model = whisperx.load_model(model_options[model_choice], device, compute_type=compute_type)
+            self.current_model_name = model_choice
+            self.current_device = device
+        else:
+            print(f"Using already loaded model: {self.current_model_name} on device: {self.current_device}")
+        return self.current_model
+
+# Validates if the given file path corresponds to a multimedia file (audio or video) by checking MIME types and specific file extensions.
+def validate_multimedia_file(file_path):
+    file_path = os.path.normpath(file_path)
+    mime_type, _ = mimetypes.guess_type(file_path)
+    if mime_type and (mime_type.startswith('audio') or mime_type.startswith('video')):
+        return file_path
+    else:
+        if file_path.lower().endswith(('.mp3', '.mp4', '.wav', '.avi', '.mov', '.flv')):
+            return file_path
+        else:
+            raise ValueError("The uploaded file is not a multimedia file. Please upload an appropriate audio or video file.")
+
+# Transcribes a multimedia file
+def transcribe(file_obj, device, language, model_choice, model_manager):
+    """
+    Transcribes a multimedia file using a specified model, handling file operations, 
+    language identification, and transcription alignment, and outputs transcription in multiple formats.
+    """
+    _, ext = os.path.splitext(file_obj.name)
+    temp_dir = os.path.join(os.getcwd(), 'Temp')
+    
+    if not os.path.exists(temp_dir):
+        os.makedirs(temp_dir)
+    new_file_path = os.path.join(temp_dir, f'resource{ext}')
+
+    shutil.copy(file_obj.name, new_file_path)
+
+    model = model_manager.load_model(model_choice, device)
+    
+    validated_file_path = validate_multimedia_file(new_file_path)
+    audio = whisperx.load_audio(validated_file_path)
+
+    if language == "Identify":
+        result = model.transcribe(audio)
+        language_code = result["language"]
+    else:
+        language_code = language_options[language]
+        result = model.transcribe(audio, language=language_code)
+
+    model_a, metadata = whisperx.load_align_model(language_code=language_code, device=device)
+    try:
+        aligned_segments = []
+        for segment in result["segments"]:
+            aligned_segment = whisperx.align([segment], model_a, metadata, audio, device, return_char_alignments=False)
+            aligned_segments.extend(aligned_segment["segments"])
+    except Exception as e:
+        print(f"Error during alignment: {e}")
+        return None
+
+    segments_output = {"segments": aligned_segments}
+    json_output = json.dumps(segments_output, ensure_ascii=False, indent=4)
+    json_file_path = download_json_interface(json_output, temp_dir)
+    txt_path = save_as_text(aligned_segments, temp_dir)
+    vtt_path = save_as_vtt(aligned_segments, temp_dir)
+    srt_path = save_as_srt(aligned_segments, temp_dir)
+    return json_file_path, txt_path, vtt_path, srt_path  
+
+# Saves the transcription text of audio segments to a file in the specified temporary directory and returns the file path.
+def save_as_text(segments, temp_dir):
+    txt_file_path = os.path.join(temp_dir, 'transcription_output.txt')
+    with open(txt_file_path, 'w', encoding='utf-8') as txt_file:
+        for segment in segments:
+            txt_file.write(f"{segment['text'].strip()}\n")  
+    return txt_file_path
+
+
+def save_as_vtt(segments, temp_dir):
+    """
+    Saves the transcription text as a .vtt file (Web Video Text Tracks format), 
+    which includes timestamps for each segment, in the specified temporary directory and returns the file path.
+    """
+    vtt_file_path = os.path.join(temp_dir, 'transcription_output.vtt')
+    with open(vtt_file_path, 'w', encoding='utf-8') as vtt_file:
+        vtt_file.write("WEBVTT\n\n")
+        for i, segment in enumerate(segments):
+            start = segment['start']
+            end = segment['end']
+            vtt_file.write(f"{i}\n")
+            vtt_file.write(f"{format_time(start)} --> {format_time(end)}\n")
+            vtt_file.write(f"{segment['text'].strip()}\n\n")  
+    return vtt_file_path
+
+def download_json_interface(json_data, temp_dir):
+    """
+    Reads JSON-formatted transcription data, modifies and re-saves it in a neatly 
+    formatted JSON file in the specified temporary directory, and returns the file path.
+    """
+    json_file_path = os.path.join(temp_dir, 'transcription_output.json')
+    with open(json_file_path, 'w', encoding='utf-8') as json_file:
+        json_data = json.loads(json_data)  
+        for segment in json_data['segments']:
+            segment['text'] = segment['text'].strip()
+        json_data = json.dumps(json_data, ensure_ascii=False, indent=4)  
+        json_file.write(json_data)
+    return json_file_path
+
+
+def save_as_srt(segments, temp_dir):
+    """
+    Saves the transcription text as an .srt file (SubRip Subtitle format), 
+    which includes numbered entries with start and end times and corresponding text for each segment, 
+    in the specified temporary directory and returns the file path.
+    """
+    srt_file_path = os.path.join(temp_dir, 'transcription_output.srt')
+    with open(srt_file_path, 'w', encoding='utf-8') as srt_file:
+        for i, segment in enumerate(segments):
+            start = segment['start']
+            end = segment['end']
+            srt_file.write(f"{i+1}\n")
+            srt_file.write(f"{format_time_srt(start)} --> {format_time_srt(end)}\n")
+            srt_file.write(f"{segment['text'].strip()}\n\n")  
+    return srt_file_path
+
+# Converts a time value in seconds to a formatted string in the "hours:minutes:seconds,milliseconds" format, used for timestamps in VTT files.
+def format_time(time_in_seconds):
+    hours = int(time_in_seconds // 3600)
+    minutes = int((time_in_seconds % 3600) // 60)
+    seconds = time_in_seconds % 60
+    return f"{hours:02}:{minutes:02}:{seconds:06.3f}"
+
+# Converts a time value in seconds to a formatted string suitable for SRT files, specifically in the "hours:minutes:seconds,milliseconds" format.
+def format_time_srt(time_in_seconds):
+    hours = int(time_in_seconds // 3600)
+    minutes = int((time_in_seconds % 3600) // 60)
+    seconds = int(time_in_seconds % 60)
+    milliseconds = int((time_in_seconds - int(time_in_seconds)) * 1000)
+    return f"{hours:02}:{minutes:02}:{seconds:02},{milliseconds:03}"