app.py

import os
import re
import time
import sys
import subprocess
import gradio as gr
from pydub import AudioSegment
from TTS.api import TTS
from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts
from TTS.utils.generic_utils import get_user_data_dir
from huggingface_hub import hf_hub_download

# Configuración inicial
os.environ["COQUI_TOS_AGREED"] = "1"

def check_and_install(package):
    try:
        __import__(package)
    except ImportError:
        print(f"{package} no está instalado. Instalando...")
        subprocess.check_call([sys.executable, "-m", "pip", "install", package])

def setup_mecab_and_unidic():
    check_and_install("MeCab")
    check_and_install("unidic-lite")
    
    try:
        import unidic
        mecab_dic_dir = unidic.DICDIR
        os.environ['MECABRC'] = os.path.join(mecab_dic_dir, 'mecabrc')
        print(f"MECABRC configurado en: {os.environ['MECABRC']}")
        
        # Intentar descargar UniDic si es necesario
        subprocess.check_call([sys.executable, '-m', 'unidic', 'download'])
        print("UniDic descargado correctamente")
        
        # Prueba de MeCab
        import MeCab
        tagger = MeCab.Tagger()
        result = tagger.parse("これはテストです。")
        print("Prueba de MeCab exitosa. Salida:")
        print(result)
    except Exception as e:
        print(f"Error durante la configuración de MeCab/UniDic: {e}")
        raise

print("Configurando MeCab y UniDic...")
setup_mecab_and_unidic()

# Descargar y configurar el modelo
print("Descargando y configurando el modelo...")
repo_id = "Blakus/Pedro_Lab_XTTS"
local_dir = os.path.join(get_user_data_dir("tts"), "tts_models--multilingual--multi-dataset--xtts_v2")
os.makedirs(local_dir, exist_ok=True)
files_to_download = ["config.json", "model.pth", "vocab.json"]

for file_name in files_to_download:
    print(f"Descargando {file_name} de {repo_id}")
    hf_hub_download(repo_id=repo_id, filename=file_name, local_dir=local_dir)

config_path = os.path.join(local_dir, "config.json")
checkpoint_path = os.path.join(local_dir, "model.pth")
vocab_path = os.path.join(local_dir, "vocab.json")

config = XttsConfig()
config.load_json(config_path)

model = Xtts.init_from_config(config)
model.load_checkpoint(config, checkpoint_path=checkpoint_path, vocab_path=vocab_path, eval=True, use_deepspeed=False)

print("Modelo cargado en CPU")

# Funciones auxiliares
def split_text(text):
    return re.split(r'(?<=[.!?])\s+', text)

def predict(prompt, language, reference_audio):
    try:
        if len(prompt) < 2 or len(prompt) > 600:
            return None, "El texto debe tener entre 2 y 600 caracteres."

        sentences = split_text(prompt)

        temperature = config.inference.get("temperature", 0.75)
        repetition_penalty = config.inference.get("repetition_penalty", 5.0)
        gpt_cond_len = config.inference.get("gpt_cond_len", 30)
        gpt_cond_chunk_len = config.inference.get("gpt_cond_chunk_len", 4)
        max_ref_length = config.inference.get("max_ref_length", 60)

        gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(
            audio_path=reference_audio,
            gpt_cond_len=gpt_cond_len,
            gpt_cond_chunk_len=gpt_cond_chunk_len,
            max_ref_length=max_ref_length
        )

        start_time = time.time()
        combined_audio = AudioSegment.empty()

        for sentence in sentences:
            out = model.inference(
                sentence,
                language,
                gpt_cond_latent,
                speaker_embedding,
                temperature=temperature,
                repetition_penalty=repetition_penalty,
            )
            audio_segment = AudioSegment(
                out["wav"].tobytes(),
                frame_rate=24000,
                sample_width=2,
                channels=1
            )
            combined_audio += audio_segment
            combined_audio += AudioSegment.silent(duration=500)  # 0.5 segundos de silencio

        inference_time = time.time() - start_time
        
        output_path = "output.wav"
        combined_audio.export(output_path, format="wav")

        audio_length = len(combined_audio) / 1000  # duración del audio en segundos
        real_time_factor = inference_time / audio_length

        metrics_text = f"Tiempo de generación: {inference_time:.2f} segundos\n"
        metrics_text += f"Factor de tiempo real: {real_time_factor:.2f}"

        return output_path, metrics_text

    except Exception as e:
        print(f"Error detallado: {str(e)}")
        return None, f"Error: {str(e)}"

# Configuración de la interfaz de Gradio
supported_languages = ["es", "en"]
reference_audios = [
    "serio.wav",
    "neutral.wav",
    "alegre.wav",
]

theme = gr.themes.Soft(
    primary_hue="blue",
    secondary_hue="gray",
).set(
    body_background_fill='*neutral_100',
    body_background_fill_dark='*neutral_900',
)

description = """
# Sintetizador de voz de Pedro Labattaglia 🎙️

Sintetizador de voz con la voz del locutor argentino Pedro Labattaglia. 

## Cómo usarlo:
- Elija el idioma (Español o Inglés)
- Elija un audio de referencia de la lista 
- Escriba el texto que desea sintetizar
- Presione generar voz
"""

# Interfaz de Gradio
with gr.Blocks(theme=theme) as demo:
    gr.Markdown(description)

    with gr.Row():
        gr.Image("https://i1.sndcdn.com/artworks-000237574740-gwz61j-t500x500.jpg", label="", show_label=False, width=250, height=250)

    with gr.Row():
        with gr.Column(scale=2):
            language_selector = gr.Dropdown(label="Idioma", choices=supported_languages)
            reference_audio = gr.Dropdown(label="Audio de referencia", choices=reference_audios)
            input_text = gr.Textbox(label="Texto a sintetizar", placeholder="Escribe aquí el texto que quieres convertir a voz...")
            generate_button = gr.Button("Generar voz", variant="primary")

        with gr.Column(scale=1):
            generated_audio = gr.Audio(label="Audio generado", interactive=False)
            metrics_output = gr.Textbox(label="Métricas", value="Tiempo de generación: -- segundos\nFactor de tiempo real: --")

    generate_button.click(
        predict,
        inputs=[input_text, language_selector, reference_audio],
        outputs=[generated_audio, metrics_output]
    )

if __name__ == "__main__":
    demo.launch()