Update app.py

app.py

@@ -10,6 +10,11 @@ from transformers import logging
 import math
 import json
 import tempfile
+import logging
+import concurrent.futures
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
 
 # Suprimir advertencias
 warnings.filterwarnings("ignore")
@@ -31,21 +36,34 @@ MODELS = {
         "facebook/wav2vec2-large-xlsr-53-portuguese",
         "openai/whisper-medium",
         "jonatasgrosman/wav2vec2-xlsr-53-portuguese"
+    ],
+    "fr": [
+        "jonatasgrosman/wav2vec2-large-xlsr-53-french"
     ]
 }
 
+# Cache de modelos para evitar múltiples cargas
+model_cache = {}
+
+def get_model(model_name):
+    if model_name not in model_cache:
+        model_cache[model_name] = WhisperForConditionalGeneration.from_pretrained(model_name)
+    return model_cache[model_name]
+
 # Función para verificar si ffmpeg está instalado
 def verify_ffmpeg_installation():
     try:
         subprocess.run(["ffmpeg", "-version"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
     except subprocess.CalledProcessError as e:
-        print("ffmpeg no está instalado o no se puede ejecutar correctamente.")
+        logging.error("ffmpeg no está instalado o no se puede ejecutar correctamente.")
         raise e
 
 def convert_audio_to_wav(audio_path):
     if os.path.isdir(audio_path):
         raise ValueError(f"La ruta proporcionada es un directorio, no un archivo: {audio_path}")
-    wav_path = "converted_audio.wav"
+    
+    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
+        wav_path = tmp.name
     
     # Añadir la opción '-y' para sobrescribir el archivo existente sin preguntar
     command = ["ffmpeg", "-y", "-i", audio_path, "-ac", "1", "-ar", "16000", wav_path]
@@ -53,8 +71,8 @@ def convert_audio_to_wav(audio_path):
     process = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     
     # Imprimir resultados para depuración
-    print(process.stdout.decode())  # Ver salida estándar
-    print(process.stderr.decode())  # Ver errores
+    logging.info(process.stdout.decode())
+    logging.error(process.stderr.decode())
 
     if process.returncode != 0:
         raise ValueError(f"Error al convertir el archivo de audio a wav: {process.stderr.decode()}")
@@ -68,7 +86,7 @@ def detect_language(audio_path):
         raise ValueError(f"Error al cargar el archivo de audio con librosa: {e}")
     
     processor = WhisperProcessor.from_pretrained("openai/whisper-base")
-    model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-base")
+    model = get_model("openai/whisper-base")
     
     input_features = processor(speech, sampling_rate=16000, return_tensors="pt").input_features
     predicted_ids = model.generate(input_features)
@@ -90,45 +108,26 @@ def transcribe_audio_stream(audio, model_name):
     duration = len(speech) / rate
     
     transcriptions = []
-
-    if "whisper" in model_name:
-        processor = WhisperProcessor.from_pretrained(model_name)
-        model = WhisperForConditionalGeneration.from_pretrained(model_name)
-        
-        chunk_duration = 30  # segundos
-        
-        for i in range(0, int(duration), chunk_duration):
-            end = min(i + chunk_duration, duration)
-            chunk = speech[int(i * rate):int(end * rate)]
-            
-            input_features = processor(chunk, sampling_rate=16000, return_tensors="pt").input_features
-            predicted_ids = model.generate(input_features)
-            transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
-            
-            progress = min(100, (end / duration) * 100)
-            transcriptions.append({
-                "start_time": i,
-                "end_time": end,
-                "text": transcription
-            })
-            yield transcriptions, progress
-    else:
-        transcriber = pipeline("automatic-speech-recognition", model=model_name)
+    processor = WhisperProcessor.from_pretrained(model_name)
+    model = get_model(model_name)
+    
+    chunk_duration = 30  # segundos
+    
+    for i in range(0, int(duration), chunk_duration):
+        end = min(i + chunk_duration, duration)
+        chunk = speech[int(i * rate):int(end * rate)]
         
-        chunk_duration = 10  # segundos
+        input_features = processor(chunk, sampling_rate=16000, return_tensors="pt").input_features
+        predicted_ids = model.generate(input_features)
+        transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
         
-        for i in range(0, int(duration), chunk_duration):
-            end = min(i + chunk_duration, duration)
-            chunk = speech[int(i * rate):int(end * rate)]
-            result = transcriber(chunk)
-            
-            progress = min(100, (end / duration) * 100)
-            transcriptions.append({
-                "start_time": i,
-                "end_time": end,
-                "text": result["text"]
-            })
-            yield transcriptions, progress
+        progress = min(100, (end / duration) * 100)
+        transcriptions.append({
+            "start_time": i,
+            "end_time": end,
+            "text": transcription
+        })
+        yield transcriptions, progress
 
 def detect_and_select_model(audio):
     wav_audio = convert_audio_to_wav(audio)
@@ -146,62 +145,66 @@ def save_transcription(transcriptions, file_format):
             for entry in transcriptions:
                 tmp.write(f"{entry['start_time']:.2f},{entry['end_time']:.2f},{entry['text']}\n".encode())
             file_path = tmp.name
-    print(f"Archivo de transcripción guardado en: {file_path}")
+    logging.info(f"Archivo de transcripción guardado en: {file_path}")
     return file_path
 
-def combined_interface(audio, file_format):
+def combined_interface(audio, file_format, confirmed_language, chosen_model):
     try:
-        print(f"Ruta del archivo de audio subido: {audio}")
-        verify_ffmpeg_installation()  # Verifica si ffmpeg está instalado
+        logging.info(f"Ruta del archivo de audio subido: {audio}")
+        verify_ffmpeg_installation()
 
         language, model_options = detect_and_select_model(audio)
-        selected_model = model_options[0]
-        print(f"Idioma detectado: {language}")
-        print(f"Modelos disponibles: {model_options}")
+        
+        # Si el usuario ha confirmado el idioma, lo usamos, sino, lo detectamos automáticamente
+        if not confirmed_language:
+            confirmed_language = language
+        
+        # Sugerimos un modelo, pero permitimos que el usuario elija uno
+        if not chosen_model:
+            chosen_model = model_options[0]
+
+        logging.info(f"Idioma detectado: {confirmed_language}")
+        logging.info(f"Modelos disponibles: {model_options}")
+        logging.info(f"Modelo seleccionado: {chosen_model}")
         
         # Primer yield: Añadir None para la séptima salida (Archivo de Descarga)
-        yield language, model_options, selected_model, "", 0, "Initializing...", None
+        yield confirmed_language, model_options, chosen_model, "", 0, "Initializing...", None
         
         transcriptions = []
-        for partial_transcriptions, progress in transcribe_audio_stream(audio, selected_model):
+        for partial_transcriptions, progress in transcribe_audio_stream(audio, chosen_model):
             transcriptions = partial_transcriptions
             full_transcription = " ".join([t["text"] for t in transcriptions])
             progress_int = math.floor(progress)
             status = f"Transcribing... {progress_int}% complete"
-            print(f"Progreso: {progress_int}%")
-            # Yield con None para el archivo de descarga hasta que esté completo
-            yield language, model_options, selected_model, full_transcription.strip(), progress_int, status, None
+            logging.info(f"Progreso: {progress_int}%")
+            yield confirmed_language, model_options, chosen_model, full_transcription.strip(), progress_int, status, None
         
-        print("Guardando transcripción.")
-        # Guardar transcripción
+        logging.info("Guardando transcripción.")
         file_path = save_transcription(transcriptions, file_format)
-        print(f"Transcripción guardada en: {file_path}")
         
-        # Verificar que file_path no es un directorio
         if os.path.isdir(file_path):
             raise ValueError(f"El archivo de transcripción debería ser un archivo, pero es un directorio: {file_path}")
         
-        # Verificar que el archivo existe
         if not os.path.isfile(file_path):
             raise ValueError(f"El archivo de transcripción no existe: {file_path}")
         
-        # Limpiar archivos temporales
         os.remove("converted_audio.wav")
-        print("Archivos temporales limpiados.")
+        logging.info("Archivos temporales limpiados.")
         
-        # Yield final con el archivo de descarga
-        yield language, model_options, selected_model, full_transcription.strip(), 100, "Transcription complete! Download the file below.", file_path
+        yield confirmed_language, model_options, chosen_model, full_transcription.strip(), 100, "Transcription complete! Download the file below.", file_path
         
     except Exception as e:
-        print(f"Error: {e}")
-        # Asegurarse de que el yield de error también devuelva 7 valores
+        logging.error(f"Error: {e}")
         yield str(e), [], "", "An error occurred during processing.", 0, "Error", ""
 
 iface = gr.Interface(
     fn=combined_interface,
     inputs=[
         gr.Audio(type="filepath", label="Upload Audio File"),
-        gr.Radio(choices=["JSON", "TXT"], label="Choose output format")
+        gr.Radio(choices=["JSON", "TXT"], label="Choose output format"),
+        gr.Dropdown(choices=["", "es", "en", "pt", "fr"], label="Confirm detected language (optional)"),
+        gr.Dropdown(choices=["", "openai/whisper-large-v3", "facebook/wav2vec2-large-xlsr-53-spanish",
+                             "jonatasgrosman/wav2vec2-xls-r-1b-spanish", "microsoft/wav2vec2-base-960h"], label="Choose model (optional)")
     ],
     outputs=[
         gr.Textbox(label="Detected Language"),
@@ -213,7 +216,7 @@ iface = gr.Interface(
         gr.File(label="Download Transcription")
     ],
     title="Multilingual Audio Transcriber with Real-time Display and Progress Indicator",
-    description="Upload an audio file to detect the language, select the transcription model, and get the transcription in real-time. Optimized for Spanish, English, and Portuguese.",
+    description="Upload an audio file to detect the language, confirm the detection or choose a model, and get the transcription in real-time. Optimized for Spanish, English, and Portuguese.",
     live=True
 )