Update app.py

app.py

@@ -4,26 +4,22 @@ from transformers import pipeline
 from pyannote.audio import Pipeline
 from pydub import AudioSegment, effects, silence
 import os
-import datetime
-from langdetect import detect
-from langdetect.lang_detect_exception import LangDetectException
 
 # --- Configuração ---
 HF_TOKEN = os.environ.get("HF_TOKEN")
-MODEL_NAME = "openai/whisper-medium"    # modelo principal para a transcrição final
-LANG_MODEL_NAME = "openai/whisper-tiny" # modelo leve dedicado à detecção rápida
+MODEL_NAME = "openai/whisper-medium"    # mantido (não utilizado para saída MP3)
+LANG_MODEL_NAME = "openai/whisper-tiny" # mantido (não utilizado para saída MP3)
 
 device = 0 if torch.cuda.is_available() else "cpu"
 torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
 
-# --- Inicialização dos modelos ---
+# Mantidos para não quebrar a inicialização (não usados na saída)
 pipe = pipeline(
     "automatic-speech-recognition",
     model=MODEL_NAME,
     torch_dtype=torch_dtype,
     device=device,
 )
-
 lang_pipe = pipeline(
     "automatic-speech-recognition",
     model=LANG_MODEL_NAME,
@@ -41,14 +37,14 @@ else:
     pyannote_pipeline = None
     print("Aviso: O token Hugging Face não está definido. A diarização será desativada.")
 
-# --- Funções de utilidade ---
+# --- Utilitários mínimos ---
 
 def convert_to_wav(audio_path):
     """Converte qualquer arquivo de áudio para WAV mono 16 kHz."""
     try:
         audio = AudioSegment.from_file(audio_path)
         audio = audio.set_channels(1)
-        audio = audio.set_frame_rate(16000)  # padrão Whisper
+        audio = audio.set_frame_rate(16000)
         wav_path = os.path.splitext(audio_path)[0] + ".wav"
         audio.export(wav_path, format="wav")
         return wav_path
@@ -56,96 +52,6 @@ def convert_to_wav(audio_path):
         print(f"Erro ao converter para WAV: {e}")
         return None
 
-def make_speech_head_wav(input_wav_path, max_seconds=6, min_silence_len_ms=300, silence_thresh_db=None):
-    """
-    Cria um trecho inicial (até max_seconds) contendo fala.
-    - Remove o silêncio inicial.
-    - Garante captura de fala em janela.
-    """
-    try:
-        audio = AudioSegment.from_wav(input_wav_path)
-        normalized = effects.normalize(audio)
-
-        if silence_thresh_db is None:
-            silence_thresh_db = normalized.dBFS - 16  # mais permissivo
-
-        start_trim = silence.detect_leading_silence(
-            normalized,
-            silence_thresh=silence_thresh_db,
-            chunk_size=10
-        )
-        trimmed = normalized[start_trim:]
-
-        if len(trimmed) < 500:
-            clip = normalized[: max_seconds * 1000]
-        else:
-            window_ms = 6000
-            step_ms = 3000
-            pos = 0
-            selected = None
-            while pos < len(trimmed) and pos < 60000:
-                candidate = trimmed[pos: pos + window_ms]
-                nonsil = silence.detect_nonsilent(
-                    candidate,
-                    min_silence_len=min_silence_len_ms,
-                    silence_thresh=silence_thresh_db
-                )
-                if nonsil:
-                    selected = candidate
-                    break
-                pos += step_ms
-            clip = selected if selected is not None else trimmed[: window_ms]
-
-        clip = clip[: max_seconds * 1000]
-        short_path = os.path.splitext(input_wav_path)[0] + f"_head_speech_{max_seconds}s.wav"
-        clip.export(short_path, format="wav")
-        return short_path
-    except Exception as e:
-        print(f"Erro ao criar o trecho de fala: {e}")
-        return None
-
-def detect_language_on_upload(filepath):
-    """Detecta rapidamente o idioma via Whisper-tiny + LangDetect."""
-    if filepath is None:
-        return "auto"
-    try:
-        wav_filepath = convert_to_wav(filepath)
-        if not wav_filepath:
-            return "auto"
-
-        short_wav = make_speech_head_wav(wav_filepath, max_seconds=6) or wav_filepath
-
-        outputs = lang_pipe(
-            short_wav,
-            chunk_length_s=6,
-            return_timestamps=False
-        )
-
-        transcribed_text = outputs.get("text", "").strip()
-        whisper_lang = outputs.get("language")
-        if whisper_lang and isinstance(whisper_lang, str) and len(whisper_lang) <= 5:
-            return whisper_lang
-
-        if len(transcribed_text) < 10:
-            return "auto"
-
-        detected_lang = detect(transcribed_text)
-        lang_mapping = {
-            'fr': 'fr','en': 'en','es': 'es','de': 'de','it': 'it','pt': 'pt',
-            'nl': 'nl','pl': 'pl','ru': 'ru','ja': 'ja','ko': 'ko','zh-cn': 'zh','zh': 'zh'
-        }
-        return lang_mapping.get(detected_lang, "auto")
-    except (LangDetectException, Exception) as e:
-        print(f"Erro ao detectar idioma: {e}")
-        return "auto"
-
-def save_txt(content, filename):
-    if not content or content.strip() == "":
-        return None
-    with open(filename, "w", encoding="utf-8") as f:
-        f.write(content)
-    return filename
-
 def ensure_mp3_same_name_as_input(input_path, source_wav_path):
     """
     Cria um arquivo MP3 com o mesmo nome base do arquivo de entrada.
@@ -161,160 +67,63 @@ def ensure_mp3_same_name_as_input(input_path, source_wav_path):
         print(f"Erro ao exportar MP3: {e}")
         return None
 
-def transcribe_audio(filepath, diarize, language_choice):
+# --- Função principal (apenas MP3 como saída) ---
+
+def make_output_mp3(filepath, diarize, language_choice):
     """
-    Mantém o input como está. Output principal: sempre gerar um MP3 para ouvir e baixar,
-    com o mesmo nome do arquivo de entrada (extensão .mp3).
-    Também devolve os campos de texto/arquivo já existentes para compatibilidade.
+    Mantém o input como está, mas ignora para a saída:
+    - Sempre gera e retorna apenas um MP3 (mesmo nome do arquivo de entrada, .mp3).
+    Retorna duas saídas:
+    - Caminho do MP3 para download (gr.File)
+    - Caminho do MP3 para playback (gr.Audio)
     """
     if filepath is None:
-        return (
-            "Nenhum arquivo de áudio fornecido.",
-            "Por favor, envie um arquivo de áudio.",
-            "",
-            None,
-            None,
-            None,  # mp3 file (download)
-            None   # mp3 playable (audio component)
-        )
+        return None, None
 
     wav_filepath = convert_to_wav(filepath)
     if not wav_filepath:
-        return (
-            "Erro: O arquivo de áudio não pôde ser convertido.",
-            "Falha na conversão.",
-            "",
-            None,
-            None,
-            None,
-            None
-        )
-
-    whisper_params = {
-        "chunk_length_s": 30,
-        "batch_size": 24,
-        "return_timestamps": True
-    }
-    if language_choice != "auto":
-        whisper_params["generate_kwargs"] = {"language": language_choice}
-
-    outputs = pipe(wav_filepath, **whisper_params)
-    transcription = outputs.get("text", "").strip()
-
-    detected_language = outputs.get("language", "Não disponível")
-    language_info = f"Idioma detectado: {detected_language}"
-    if language_choice != "auto":
-        language_info += f" (Idioma forçado: {language_choice})"
-
-    diarized_transcription = ""
-    if diarize and pyannote_pipeline:
-        try:
-            diarization = pyannote_pipeline(wav_filepath)
-            for turn, _, speaker in diarization.itertracks(yield_label=True):
-                segment_start = turn.start
-                segment_end = turn.end
-                segment_text = ""
-                for chunk in outputs.get("chunks", []):
-                    chunk_start = chunk['timestamp'][0]
-                    chunk_end = chunk['timestamp'][1]
-                    if chunk_start is not None and chunk_end is not None:
-                        if max(segment_start, chunk_start) < min(segment_end, chunk_end):
-                            segment_text += chunk['text']
-                start_time = str(datetime.timedelta(seconds=int(segment_start)))
-                diarized_transcription += f"[{start_time}] {speaker}:{segment_text.strip()}\n"
-        except Exception as e:
-            diarized_transcription = f"Erro durante a diarização: {e}"
-    elif diarize:
-        diarized_transcription = "Diarização ativada, mas o modelo não pôde ser carregado (token ausente?)."
-    else:
-        diarized_transcription = "Diarização não ativada."
+        return None, None
 
-    transcription_file = save_txt(transcription, "transcription.txt")
-    diarization_file = save_txt(diarized_transcription, "transcription_diarized.txt")
-
-    # Sempre gerar MP3 com o mesmo nome do arquivo de entrada
     mp3_path = ensure_mp3_same_name_as_input(filepath, wav_filepath)
-
-    # Retornos: textos + arquivos .txt + arquivo MP3 (download) + MP3 tocável
-    # O gr.Audio aceita caminho de arquivo para tocar o áudio.
-    return (
-        transcription,
-        diarized_transcription,
-        language_info,
-        transcription_file,
-        diarization_file,
-        mp3_path,  # File para download
-        mp3_path   # Audio para playback
-    )
+    return mp3_path, mp3_path
 
 # --- Interface Gradio ---
 
 with gr.Blocks() as demo:
-    gr.HTML("<div style='text-align:center;'><h1>Transcrição e Diarização de Arquivos Áudio</h1></div>")
-    gr.Markdown("Transcreva e diarize automaticamente seus arquivos de áudio (WhatsApp (opus), wav, mp3, m4a, etc.) com Whisper e pyannote, diretamente neste Space.")
-
-    gr.Markdown("""
-## 🚀 Como usar o aplicativo
-
-1. Envie um arquivo de áudio (opus, wav, mp3, m4a, etc.): o idioma principal será detectado automaticamente ou permanecerá em "auto"
-2. Escolha o idioma ou deixe em "auto"
-3. Ative ou não a opção "Diarização"
-4. Clique em "Transcrever"
-5. Obtenha a transcrição e, se ativado, a versão diarizada (por locutor)
-6. Agora o output inclui sempre um MP3 com o mesmo nome do arquivo de entrada (para ouvir e baixar)
-7. Resete os arquivos antes de uma nova transcrição
-""")
+    gr.HTML("<div style='text-align:center;'><h1>Sortie MP3 (même nom que l'entrée)</h1></div>")
+    gr.Markdown("Uploadez un fichier audio. La sortie sera toujours un .mp3 avec le même nom de base, jouable et téléchargeable.")
 
     with gr.Row():
         with gr.Column():
-            audio_input = gr.Audio(type="filepath", label="Enviar um arquivo de áudio")
+            # Partie input conservée (inchangée)
+            audio_input = gr.Audio(type="filepath", label="Envoyer un fichier audio")
             language_dropdown = gr.Dropdown(
                 choices=["auto", "fr", "en", "es", "de", "it", "pt", "nl", "pl", "ru", "ja", "ko", "zh"],
                 value="auto",
-                label="Idioma (auto = detecção automática)",
-                info="Escolha o idioma ou deixe em 'auto' para detecção automática"
+                label="Langue (auto = détection automatique)",
+                info="Conservé pour compatibilité (non utilisé pour la sortie MP3)"
             )
-            diarize_checkbox = gr.Checkbox(label="Ativar Diarização", value=True)
-            submit_btn = gr.Button("Transcrever", variant="primary")
-            reset_btn = gr.Button("Resetar", variant="secondary")
+            diarize_checkbox = gr.Checkbox(label="Activer Diarisation", value=True)
+            submit_btn = gr.Button("Générer MP3", variant="primary")
+            reset_btn = gr.Button("Reset", variant="secondary")
         with gr.Column():
-            language_info_output = gr.Textbox(label="Informação sobre o idioma", lines=1)
-            transcription_file = gr.File(label="Baixar transcrição (.txt)")
-            transcription_output = gr.Textbox(label="Transcrição Completa", lines=10)
-            diarization_file = gr.File(label="Baixar transcrição diarizada (.txt)")
-            diarization_output = gr.Textbox(label="Transcrição com Diarização (por locutor)", lines=15)
-
-            # Novos componentes para MP3:
-            mp3_download = gr.File(label="Baixar áudio de saída (.mp3)")
-            mp3_playback = gr.Audio(label="Ouvir áudio de saída (.mp3)", type="filepath")
-
-    audio_input.change(
-        fn=detect_language_on_upload,
-        inputs=audio_input,
-        outputs=language_dropdown
-    )
+            # Seules sorties: MP3 en download + player
+            mp3_download = gr.File(label="Télécharger la sortie (.mp3)")
+            mp3_playback = gr.Audio(label="Écouter la sortie (.mp3)", type="filepath")
 
     submit_btn.click(
-        fn=transcribe_audio,
+        fn=make_output_mp3,
         inputs=[audio_input, diarize_checkbox, language_dropdown],
-        outputs=[
-            transcription_output, diarization_output, language_info_output,
-            transcription_file, diarization_file,
-            mp3_download, mp3_playback
-        ]
+        outputs=[mp3_download, mp3_playback]
     )
 
     def reset_fields():
-        return "", "", "", None, None, None, None, "auto", True
+        return None, None, "auto", True
 
     reset_btn.click(
         fn=reset_fields,
         inputs=[],
-        outputs=[
-            transcription_output, diarization_output, language_info_output,
-            transcription_file, diarization_file, mp3_download, mp3_playback,
-            language_dropdown, diarize_checkbox
-        ]
+        outputs=[mp3_download, mp3_playback, language_dropdown, diarize_checkbox]
     )
 
 demo.launch(share=True)