Update app.py

app.py

@@ -1,495 +1,63 @@
-# chat_ai_full.py
+# app.py
 
 import subprocess
 import sys
-
-def install_packages():
-    """
-    Instala todas las dependencias necesarias utilizando pip.
-    Primero desinstala el paquete 'Spanish-F5' si está instalado,
-    luego lo reinstala desde el repositorio de GitHub.
-    Finalmente, instala todas las demás dependencias listadas.
-    """
-    # Lista de paquetes a instalar
-    packages = [
-        "gradio>=3.0",
-        "numpy>=1.21.0",
-        "soundfile>=0.10.3",
-        "torchaudio>=0.10.0",
-        "cached_path>=0.1.0",
-        "transformers>=4.0.0",
-        "torch>=1.10.0",
-        "num2words>=0.5.10",
-        "click>=8.0.0"
-    ]
-    
-    # Desinstalar Spanish-F5 si está instalado
-    try:
-        print("Desinstalando 'Spanish-F5' si está instalado...")
-        subprocess.run([sys.executable, "-m", "pip", "uninstall", "-y", "Spanish-F5"], check=True)
-    except subprocess.CalledProcessError:
-        print("'Spanish-F5' no estaba instalado o hubo un error al desinstalarlo.")
-    
-    # Instalar Spanish-F5 desde GitHub
+import os
+
+def install_requirements(requirements_file="requirements.txt"):
+    """
+    Instala las dependencias listadas en el archivo requirements.txt.
+    Si el archivo no existe, crea uno con las dependencias necesarias.
+    """
+    # Verificar si el archivo requirements.txt existe
+    if not os.path.isfile(requirements_file):
+        # Crear el archivo con las dependencias necesarias
+        with open(requirements_file, "w") as f:
+            f.write("""gradio>=3.0
+numpy>=1.21.0
+soundfile>=0.10.3
+torchaudio>=0.10.0
+cached_path>=0.1.0
+transformers>=4.0.0
+torch>=1.10.0
+num2words>=0.5.10
+click>=8.0.0
+git+https://github.com/jpgallegoar/Spanish-F5.git
+""")
+        print(f"Creado archivo {requirements_file} con las dependencias necesarias.")
+
+    # Instalar las dependencias usando pip
+    print("Instalando dependencias desde requirements.txt...")
     try:
-        print("Instalando 'Spanish-F5' desde GitHub...")
-        subprocess.run([
-            sys.executable, "-m", "pip", "install",
-            "--upgrade",
-            "git+https://github.com/jpgallegoar/Spanish-F5.git",
-            "--no-cache-dir"
-        ], check=True)
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", requirements_file])
+        print("Dependencias instaladas correctamente.")
     except subprocess.CalledProcessError as e:
-        print("Error al instalar 'Spanish-F5':", e)
+        print(f"Error al instalar las dependencias: {e}")
         sys.exit(1)
-    
-    # Instalar las demás dependencias
-    for package in packages:
-        try:
-            print(f"Instalando '{package}'...")
-            subprocess.run([sys.executable, "-m", "pip", "install", package], check=True)
-        except subprocess.CalledProcessError as e:
-            print(f"Error al instalar '{package}':", e)
-            sys.exit(1)
-    
-    print("Todas las dependencias han sido instaladas correctamente.")
-
-# Instalar dependencias antes de importar
-install_packages()
-
-# Importar las bibliotecas necesarias
-import re
-import tempfile
-
-import gradio as gr
-import numpy as np
-import soundfile as sf
-import torchaudio
-from cached_path import cached_path
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import torch
-
-from f5_tts.model import DiT
-from f5_tts.infer.utils_infer import (
-    load_vocoder,
-    load_model,
-    preprocess_ref_audio_text,
-    infer_process,
-    remove_silence_for_generated_wav,
-)
-from num2words import num2words
-
-# Intentar importar 'spaces' para determinar si se está usando Hugging Face Spaces
-try:
-    import spaces
-    USING_SPACES = True
-except ImportError:
-    USING_SPACES = False
-
-# Decorador para utilizar GPU si está disponible
-def gpu_decorator(func):
-    if USING_SPACES:
-        return spaces.GPU(func)
-    else:
-        return func
-
-# Cargar el vocoder
-vocoder = load_vocoder()
-
-# Cargar el modelo F5-TTS
-F5TTS_model_cfg = dict(dim=1024, depth=22, heads=16, ff_mult=2, text_dim=512, conv_layers=4)
-F5TTS_ema_model = load_model(
-    DiT, F5TTS_model_cfg, str(cached_path("hf://jpgallegoar/F5-Spanish/model_1200000.safetensors"))
-)
-
-# Variables globales para el modelo de chat
-chat_model_state = None
-chat_tokenizer_state = None
-
-@gpu_decorator
-def generate_response(messages, model, tokenizer):
-    """
-    Genera una respuesta utilizando el modelo de chat.
-    
-    Args:
-        messages (list): Lista de mensajes en la conversación.
-        model: Modelo de lenguaje.
-        tokenizer: Tokenizer correspondiente al modelo.
-    
-    Returns:
-        str: Respuesta generada por el modelo.
-    """
-    text = tokenizer.apply_chat_template(
-        messages,
-        tokenize=False,
-        add_generation_prompt=True,
-    )
-
-    model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
-    generated_ids = model.generate(
-        **model_inputs,
-        max_new_tokens=512,
-        temperature=0.7,
-        top_p=0.95,
-    )
-
-    generated_ids = [
-        output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
-    ]
-    return tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
-
-def traducir_numero_a_texto(texto):
-    """
-    Convierte números en texto a su representación en palabras en español.
-    
-    Args:
-        texto (str): Texto que contiene números.
-    
-    Returns:
-        str: Texto con números convertidos a palabras.
-    """
-    texto_separado = re.sub(r'([A-Za-z])(\d)', r'\1 \2', texto)
-    texto_separado = re.sub(r'(\d)([A-Za-z])', r'\1 \2', texto_separado)
-    
-    def reemplazar_numero(match):
-        numero = match.group()
-        return num2words(int(numero), lang='es')
-
-    texto_traducido = re.sub(r'\b\d+\b', reemplazar_numero, texto_separado)
-
-    return texto_traducido
-
-@gpu_decorator
-def infer(
-    ref_audio_orig, ref_text, gen_text, model, remove_silence, cross_fade_duration=0.15, speed=1, show_info=gr.Info
-):
-    """
-    Genera el audio sintetizado a partir del texto.
-    
-    Args:
-        ref_audio_orig (str): Ruta al audio de referencia.
-        ref_text (str): Texto de referencia.
-        gen_text (str): Texto para generar el audio.
-        model: Modelo TTS.
-        remove_silence (bool): Si se debe eliminar silencios.
-        cross_fade_duration (float): Duración del cross-fade.
-        speed (float): Velocidad de reproducción.
-        show_info: Función para mostrar información (Gradio Info).
-    
-    Returns:
-        tuple: (sample_rate, audio_data), ruta al espectrograma.
-    """
-    ref_audio, ref_text = preprocess_ref_audio_text(ref_audio_orig, ref_text, show_info=show_info)
-
-    ema_model = F5TTS_ema_model
-
-    if not gen_text.startswith(" "):
-        gen_text = " " + gen_text
-    if not gen_text.endswith(". "):
-        gen_text += ". "
-
-    gen_text = gen_text.lower()
-    gen_text = traducir_numero_a_texto(gen_text)
-
-    final_wave, final_sample_rate, combined_spectrogram = infer_process(
-        ref_audio,
-        ref_text,
-        gen_text,
-        ema_model,
-        vocoder,
-        cross_fade_duration=cross_fade_duration,
-        speed=speed,
-        show_info=show_info,
-        progress=gr.Progress(),
-    )
-
-    # Eliminar silencios si está activado
-    if remove_silence:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as f:
-            sf.write(f.name, final_wave, final_sample_rate)
-            remove_silence_for_generated_wav(f.name)
-            final_wave, _ = torchaudio.load(f.name)
-        final_wave = final_wave.squeeze().cpu().numpy()
 
-    return (final_sample_rate, final_wave)
-
-def load_chat_model():
+def run_chat_ai():
     """
-    Carga el modelo de chat y el tokenizer.
-    
-    Returns:
-        tuple: (modelo, tokenizer)
+    Ejecuta el script chat_ai.py.
     """
-    global chat_model_state, chat_tokenizer_state
-    if chat_model_state is None:
-        model_name = "Qwen/Qwen2.5-3B-Instruct"
-        chat_model_state = AutoModelForCausalLM.from_pretrained(
-            model_name, torch_dtype=torch.float16, device_map="auto"
-        )
-        chat_tokenizer_state = AutoTokenizer.from_pretrained(model_name)
-    return chat_model_state, chat_tokenizer_state
-
-with gr.Blocks() as app_chat:
-    gr.Markdown(
-        """
-# Chat de Voz
-¡Mantén una conversación con una IA usando tu voz de referencia! 
-1. Sube un clip de audio de referencia y opcionalmente su transcripción.
-2. Carga el modelo de chat.
-3. Graba tu mensaje a través de tu micrófono.
-4. La IA responderá usando la voz de referencia.
-        """
-    )
-
-    if not USING_SPACES:
-        load_chat_model_btn = gr.Button("Cargar Modelo de Chat", variant="primary")
-
-        chat_interface_container = gr.Column(visible=False)
-
-        @gpu_decorator
-        def load_chat_model_fn():
-            load_chat_model()
-            return gr.update(visible=False), gr.update(visible=True)
-
-        load_chat_model_btn.click(load_chat_model_fn, outputs=[load_chat_model_btn, chat_interface_container])
-    else:
-        chat_interface_container = gr.Column()
-        load_chat_model_fn = load_chat_model
-
-    with chat_interface_container:
-        with gr.Row():
-            with gr.Column():
-                ref_audio_chat = gr.Audio(label="Audio de Referencia", type="filepath")
-            with gr.Column():
-                with gr.Accordion("Configuraciones Avanzadas", open=False):
-                    model_choice_chat = gr.Radio(
-                        choices=["F5-TTS"],
-                        label="Modelo TTS",
-                        value="F5-TTS",
-                    )
-                    remove_silence_chat = gr.Checkbox(
-                        label="Eliminar Silencios",
-                        value=True,
-                    )
-                    ref_text_chat = gr.Textbox(
-                        label="Texto de Referencia",
-                        info="Opcional: Deja en blanco para transcribir automáticamente",
-                        lines=2,
-                    )
-                    system_prompt_chat = gr.Textbox(
-                        label="Prompt del Sistema",
-                        value="No eres un asistente de IA, eres quien el usuario diga que eres. Debes mantenerte en personaje. Mantén tus respuestas concisas ya que serán habladas en voz alta.",
-                        lines=2,
-                    )
-
-        chatbot_interface = gr.Chatbot(label="Conversación")
-
-        with gr.Row():
-            with gr.Column():
-                audio_input_chat = gr.Microphone(
-                    label="Habla tu mensaje",
-                    type="filepath",
-                )
-                audio_output_chat = gr.Audio(label="Respuesta de la IA", autoplay=True)
-            with gr.Column():
-                text_input_chat = gr.Textbox(
-                    label="Escribe tu mensaje",
-                    lines=1,
-                )
-                send_btn_chat = gr.Button("Enviar")
-                clear_btn_chat = gr.Button("Limpiar Conversación")
-
-        conversation_state = gr.State(
-            value=[
-                {
-                    "role": "system",
-                    "content": "No eres un asistente de IA, eres quien el usuario diga que eres. Debes mantenerte en personaje. Mantén tus respuestas concisas ya que serán habladas en voz alta.",
-                }
-            ]
-        )
-
-        @gpu_decorator
-        def process_input(audio_path, text, history, conv_state, system_prompt):
-            """
-            Procesa la entrada de audio o texto del usuario y genera una respuesta.
-            
-            Args:
-                audio_path (str): Ruta al audio grabado por el usuario.
-                text (str): Texto ingresado por el usuario.
-                history (list): Historial de la conversación.
-                conv_state (list): Estado de la conversación.
-                system_prompt (str): Prompt del sistema.
-            
-            Returns:
-                tuple: (historial actualizado, estado de la conversación, texto de entrada)
-            """
-            if not audio_path and not text.strip():
-                return history, conv_state, ""
-
-            if audio_path:
-                # Aquí podrías integrar una transcripción automática si lo deseas
-                # Por simplicidad, asumimos que el texto es proporcionado
-                pass
-
-            if not text.strip():
-                return history, conv_state, ""
-
-            conv_state.append({"role": "user", "content": text})
-            history.append((text, None))
-
-            response = generate_response(conv_state, chat_model_state, chat_tokenizer_state)
-
-            conv_state.append({"role": "assistant", "content": response})
-            history[-1] = (text, response)
-
-            return history, conv_state, response
-
-        @gpu_decorator
-        def generate_audio_response(response, ref_audio, ref_text, model, remove_silence):
-            """
-            Genera el audio de respuesta para la IA.
-            
-            Args:
-                response (str): Respuesta de la IA en texto.
-                ref_audio (str): Ruta al audio de referencia.
-                ref_text (str): Texto de referencia.
-                model (str): Modelo TTS a utilizar.
-                remove_silence (bool): Si se debe eliminar silencios.
-            
-            Returns:
-                tuple: (sample_rate, audio_data)
-            """
-            if not response or not ref_audio:
-                return None
-
-            audio_result, _ = infer(
-                ref_audio,
-                ref_text,
-                response,
-                model,
-                remove_silence,
-                cross_fade_duration=0.15,
-                speed=1.0,
-                show_info=gr.Info(),
-            )
-            return audio_result
-
-        def clear_conversation_fn():
-            """
-            Limpia la conversación.
-            
-            Returns:
-                tuple: (historial vacío, estado de la conversación reiniciado)
-            """
-            return [], [
-                {
-                    "role": "system",
-                    "content": "No eres un asistente de IA, eres quien el usuario diga que eres. Debes mantenerte en personaje. Mantén tus respuestas concisas ya que serán habladas en voz alta.",
-                }
-            ]
-
-        def update_system_prompt_fn(new_prompt):
-            """
-            Actualiza el prompt del sistema y reinicia la conversación.
-            
-            Args:
-                new_prompt (str): Nuevo prompt del sistema.
-            
-            Returns:
-                tuple: (historial vacío, estado de la conversación actualizado)
-            """
-            new_conv_state = [{"role": "system", "content": new_prompt}]
-            return [], new_conv_state
-
-        # Manejar la entrada de audio
-        audio_input_chat.stop_recording(
-            process_input,
-            inputs=[audio_input_chat, text_input_chat, chatbot_interface, conversation_state, system_prompt_chat],
-            outputs=[chatbot_interface, conversation_state, text_input_chat],
-        ).then(
-            generate_audio_response,
-            inputs=[text_input_chat, ref_audio_chat, ref_text_chat, model_choice_chat, remove_silence_chat],
-            outputs=[audio_output_chat],
-        ).then(
-            lambda: None,
-            None,
-            audio_input_chat,
-        )
-
-        # Manejar la entrada de texto
-        text_input_chat.submit(
-            process_input,
-            inputs=[audio_input_chat, text_input_chat, chatbot_interface, conversation_state, system_prompt_chat],
-            outputs=[chatbot_interface, conversation_state, text_input_chat],
-        ).then(
-            generate_audio_response,
-            inputs=[text_input_chat, ref_audio_chat, ref_text_chat, model_choice_chat, remove_silence_chat],
-            outputs=[audio_output_chat],
-        ).then(
-            lambda: None,
-            None,
-            text_input_chat,
-        )
-
-        # Manejar el botón de enviar
-        send_btn_chat.click(
-            process_input,
-            inputs=[audio_input_chat, text_input_chat, chatbot_interface, conversation_state, system_prompt_chat],
-            outputs=[chatbot_interface, conversation_state, text_input_chat],
-        ).then(
-            generate_audio_response,
-            inputs=[text_input_chat, ref_audio_chat, ref_text_chat, model_choice_chat, remove_silence_chat],
-            outputs=[audio_output_chat],
-        ).then(
-            lambda: None,
-            None,
-            text_input_chat,
-        )
-
-        # Manejar el botón de limpiar conversación
-        clear_btn_chat.click(
-            clear_conversation_fn,
-            outputs=[chatbot_interface, conversation_state],
-        )
+    # Verificar si chat_ai.py existe
+    if not os.path.isfile("chat_ai.py"):
+        print("Error: 'chat_ai.py' no se encuentra en el directorio actual.")
+        sys.exit(1)
 
-        # Manejar cambios en el prompt del sistema
-        system_prompt_chat.change(
-            update_system_prompt_fn,
-            inputs=system_prompt_chat,
-            outputs=[chatbot_interface, conversation_state],
-        )
+    # Ejecutar chat_ai.py
+    print("Ejecutando 'chat_ai.py'...")
+    try:
+        subprocess.check_call([sys.executable, "chat_ai.py"])
+    except subprocess.CalledProcessError as e:
+        print(f"Error al ejecutar 'chat_ai.py': {e}")
+        sys.exit(1)
 
 def main():
     """
-    Función principal para lanzar la aplicación Gradio.
-    Maneja si se está ejecutando en Hugging Face Spaces o localmente.
+    Función principal que instala las dependencias y ejecuta chat_ai.py.
     """
-    import click
-
-    @click.command()
-    @click.option("--port", "-p", default=None, type=int, help="Puerto para ejecutar la aplicación")
-    @click.option("--host", "-H", default=None, help="Host para ejecutar la aplicación")
-    @click.option(
-        "--share",
-        "-s",
-        default=False,
-        is_flag=True,
-        help="Compartir la aplicación a través de un enlace compartido de Gradio",
-    )
-    @click.option("--api", "-a", default=True, is_flag=True, help="Permitir acceso a la API")
-    def run_app(port, host, share, api):
-        """
-        Ejecuta la aplicación Gradio con las opciones proporcionadas.
-        """
-        print("Iniciando la aplicación de Chat AI...")
-        app_chat.queue(api_open=api).launch(
-            server_name=host, 
-            server_port=port, 
-            share=share, 
-            show_api=api
-        )
-
-    run_app()
+    install_requirements()
+    run_chat_ai()
 
 if __name__ == "__main__":
     main()