Update app.py

app.py

@@ -1,198 +1,165 @@
 import gradio as gr
+from transformers import pipeline
 from pydub import AudioSegment
+from pydub.utils import make_chunks
 import tempfile
 import os
-import io
-
-# --- Funções de Edição com Pydub ---
-
-def get_audio_duration(audio_filepath):
-    """Retorna a duração do áudio em segundos."""
-    if not audio_filepath or not os.path.exists(audio_filepath):
-        return 0
+import math
+
+# --- Configurações ---
+MODEL_NAME = "openai/whisper-small"  # Ou "base", "small" - Cuidado com RAM/Tempo na CPU
+CHUNK_LENGTH_MS = 30_000  # 30 segundos por chunk
+MAX_FILE_SIZE_MB = 250  # Aumentado para ~120 min (ajuste conforme necessário)
+TARGET_SAMPLE_RATE = 16000
+# ---------------------
+
+print(f"Carregando modelo Whisper: {MODEL_NAME}...")
+# Inicialize o modelo Whisper
+transcriber = pipeline(
+    "automatic-speech-recognition",
+    model=MODEL_NAME,
+    device="cpu"  # Mantendo CPU conforme original
+)
+print("Modelo carregado.")
+
+# Função para dividir áudios longos
+def split_audio(audio_path, chunk_length=CHUNK_LENGTH_MS):
     try:
-        audio = AudioSegment.from_file(audio_filepath)
-        return audio.duration_seconds
+        audio = AudioSegment.from_file(audio_path)
+        print(f"Áudio carregado: Duração={audio.duration_seconds:.2f}s, Canais={audio.channels}, Taxa={audio.frame_rate}Hz")
+        chunks = make_chunks(audio, chunk_length)
+        print(f"Áudio dividido em {len(chunks)} chunks de ~{chunk_length/1000}s")
+        return chunks
     except Exception as e:
-        print(f"Erro ao ler duração do áudio: {e}")
-        return 0
-
-def apply_trim(audio_filepath, start_time_sec, end_time_sec):
-    """Corta o áudio entre start_time_sec e end_time_sec."""
-    if not audio_filepath or not os.path.exists(audio_filepath):
-        raise gr.Error("Nenhum áudio carregado para cortar.")
-    if start_time_sec >= end_time_sec:
-        raise gr.Error("O tempo de início deve ser menor que o tempo de fim.")
+        print(f"Erro ao carregar ou dividir áudio: {e}")
+        raise  # Re-lança a exceção para ser pega na função principal
 
+# Função para comprimir/preparar áudio para Whisper
+def prepare_audio(audio_path):
     try:
-        audio = AudioSegment.from_file(audio_filepath)
-        start_ms = int(start_time_sec * 1000)
-        end_ms = int(end_time_sec * 1000)
-
-        # Garante que os tempos estão dentro dos limites do áudio
-        start_ms = max(0, start_ms)
-        end_ms = min(len(audio), end_ms)
-
-        if start_ms >= end_ms:
-             raise gr.Error("Intervalo de corte inválido após ajuste aos limites.")
+        audio = AudioSegment.from_file(audio_path)
+        # Converter para mono, taxa de amostragem alvo, profundidade de bits padrão (16)
+        prepared_audio = audio.set_frame_rate(TARGET_SAMPLE_RATE).set_channels(1).set_sample_width(2)
 
-        trimmed_audio = audio[start_ms:end_ms]
-
-        # Salva o resultado em um arquivo temporário para o Gradio exibir
+        # Usar um arquivo temporário gerenciado pelo 'with' se possível
         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_f:
-            output_path = temp_f.name
-        trimmed_audio.export(output_path, format="wav")
-        print(f"Áudio cortado salvo em: {output_path}")
-        return output_path
+            prepared_path = temp_f.name
 
+        prepared_audio.export(prepared_path, format="wav")
+        print(f"Áudio preparado e salvo em: {prepared_path}")
+        return prepared_path
     except Exception as e:
-        print(f"Erro ao cortar áudio: {e}")
-        raise gr.Error(f"Erro ao cortar áudio: {e}")
+        print(f"Erro ao preparar áudio: {e}")
+        raise
 
-def apply_volume_change(audio_filepath, volume_db):
-    """Aplica uma mudança de volume em dB."""
-    if not audio_filepath or not os.path.exists(audio_filepath):
-        raise gr.Error("Nenhum áudio carregado para alterar volume.")
+# Função para transcrever o áudio (agora como gerador para feedback)
+def transcribe_audio_generator(audio_filepath):
+    if audio_filepath is None:
+        yield "Erro: Nenhum arquivo de áudio enviado."
+        return
 
     try:
-        audio = AudioSegment.from_file(audio_filepath)
-        adjusted_audio = audio + volume_db # Pydub permite somar dB diretamente
-
-        # Salva o resultado
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_f:
-            output_path = temp_f.name
-        adjusted_audio.export(output_path, format="wav")
-        print(f"Áudio com volume ajustado salvo em: {output_path}")
-        return output_path
+        file_size_bytes = os.path.getsize(audio_filepath)
+        file_size_mb = file_size_bytes / (1024 * 1024)
+        print(f"Arquivo recebido: {audio_filepath}, Tamanho: {file_size_mb:.2f} MB")
+
+        # Verificar o tamanho do arquivo
+        if file_size_bytes > MAX_FILE_SIZE_MB * 1024 * 1024:
+            yield f"Erro: O arquivo excede o limite de {MAX_FILE_SIZE_MB} MB. Tamanho atual: {file_size_mb:.2f} MB."
+            return
+
+        yield f"Iniciando pré-processamento (pode levar um tempo)... Tamanho: {file_size_mb:.2f} MB"
+
+        prepared_audio_path = None
+        try:
+            prepared_audio_path = prepare_audio(audio_filepath)
+
+            yield f"Pré-processamento concluído. Dividindo em chunks..."
+            chunks = split_audio(prepared_audio_path)
+            total_chunks = len(chunks)
+
+            if total_chunks == 0:
+                 yield "Erro: Não foi possível dividir o áudio em chunks."
+                 return
+
+            full_transcription = []
+            yield f"Iniciando transcrição de {total_chunks} chunks (Modelo: {MODEL_NAME}). Isso pode demorar bastante..."
+
+            # Processar cada parte separadamente
+            for i, chunk in enumerate(chunks):
+                # Usar arquivo temporário para o chunk
+                with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as temp_chunk_file:
+                    chunk.export(temp_chunk_file.name, format="wav")
+
+                    # Transcrever o chunk
+                    # Usar chunk_length para o pipeline pode ajudar em alguns casos
+                    result = transcriber(
+                        temp_chunk_file.name,
+                        chunk_length_s=math.ceil(CHUNK_LENGTH_MS / 1000), # Whisper espera em segundos
+                        return_timestamps=False # Mantido como False
+                    )
+                    transcription = result["text"]
+
+                    # Adicionar ao resultado geral
+                    chunk_label = f"[Chunk {i+1}/{total_chunks}]"
+                    full_transcription.append(f"{chunk_label}: {transcription}")
+
+                    # Atualizar a interface a cada chunk (ou a cada N chunks)
+                    progress_update = f"Processando: {i+1}/{total_chunks} chunks...\n\n" + "\n".join(full_transcription)
+                    yield progress_update
+
+            yield "Transcrição completa!\n\n" + "\n".join(full_transcription)
+
+        except Exception as e:
+            yield f"Erro durante o processamento: {str(e)}"
+            # Log detalhado do erro no console do servidor
+            import traceback
+            print("Erro detalhado:")
+            traceback.print_exc()
+
+        finally:
+            # Limpar o arquivo preparado se ele foi criado
+            if prepared_audio_path and os.path.exists(prepared_audio_path):
+                try:
+                    os.remove(prepared_audio_path)
+                    print(f"Arquivo temporário preparado removido: {prepared_audio_path}")
+                except OSError as e:
+                    print(f"Erro ao remover arquivo temporário {prepared_audio_path}: {e}")
+            # O arquivo original (audio_filepath) é gerenciado pelo Gradio
+            # Os arquivos de chunk são gerenciados pelo 'with tempfile.NamedTemporaryFile'
 
     except Exception as e:
-        print(f"Erro ao ajustar volume: {e}")
-        raise gr.Error(f"Erro ao ajustar volume: {e}")
+        yield f"Erro inesperado ao processar áudio: {str(e)}"
+        import traceback
+        print("Erro detalhado:")
+        traceback.print_exc()
 
-def reverse_audio(audio_filepath):
-    """Inverte o áudio."""
-    if not audio_filepath or not os.path.exists(audio_filepath):
-        raise gr.Error("Nenhum áudio carregado para inverter.")
-    try:
-        audio = AudioSegment.from_file(audio_filepath)
-        reversed_audio = audio.reverse()
-
-        # Salva o resultado
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_f:
-            output_path = temp_f.name
-        reversed_audio.export(output_path, format="wav")
-        print(f"Áudio invertido salvo em: {output_path}")
-        return output_path
-    except Exception as e:
-        print(f"Erro ao inverter áudio: {e}")
-        raise gr.Error(f"Erro ao inverter áudio: {e}")
-
-# --- Interface Gradio ---
 
+# Interface gráfica com Gradio
 with gr.Blocks() as demo:
-    gr.Markdown("# ✂️ Editor de Áudio Básico 🔊")
-
-    # Usaremos State para manter o caminho do arquivo de áudio atual (original ou editado)
-    current_audio_state = gr.State(None)
-    audio_duration_state = gr.State(0)
+    gr.Markdown(f"# 🎙️ Whisper Transcription - Áudios Longos (até {MAX_FILE_SIZE_MB} MB)")
+    gr.Markdown(f"**Atenção:** Áudios muito longos podem levar **muito tempo** para processar (potencialmente horas), especialmente com o modelo `{MODEL_NAME}` na CPU.")
 
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### 1. Carregue seu Áudio")
-            audio_input = gr.Audio(type="filepath", label="Upload ou Grave")
-            # Botão para carregar o áudio no estado
-            load_button = gr.Button("Carregar Áudio para Edição")
-
-        with gr.Column(scale=2):
-            gr.Markdown("### 2. Edite o Áudio")
-
-            with gr.Tabs():
-                with gr.TabItem("Cortar (Trim)"):
-                    trim_start_slider = gr.Slider(label="Início (segundos)", minimum=0, maximum=1, step=0.1, interactive=True)
-                    trim_end_slider = gr.Slider(label="Fim (segundos)", minimum=0, maximum=1, step=0.1, interactive=True)
-                    apply_trim_button = gr.Button("Aplicar Corte")
-
-                with gr.TabItem("Volume"):
-                    volume_slider = gr.Slider(label="Ajuste de Volume (dB)", minimum=-20, maximum=20, value=0, step=1, interactive=True)
-                    apply_volume_button = gr.Button("Aplicar Volume")
-
-                with gr.TabItem("Outros Efeitos"):
-                     reverse_button = gr.Button("Inverter Áudio")
-                     # Adicione botões para outras funções aqui (Fade In/Out, Speed, etc.)
-
-            gr.Markdown("### 3. Resultado da Edição")
-            audio_output = gr.Audio(label="Áudio Editado", type="filepath", interactive=False)
-
-
-    # --- Lógica de Interação ---
-
-    def update_sliders(audio_filepath):
-        """Atualiza os máximos dos sliders de corte com base na duração do áudio."""
-        if not audio_filepath:
-            return {
-                trim_start_slider: gr.update(maximum=1, value=0),
-                trim_end_slider: gr.update(maximum=1, value=1),
-                audio_duration_state: 0,
-                current_audio_state: None
-            }
-        duration = get_audio_duration(audio_filepath)
-        print(f"Duração detectada: {duration}s")
-        return {
-            trim_start_slider: gr.update(maximum=duration, value=0),
-            trim_end_slider: gr.update(maximum=duration, value=duration),
-            audio_duration_state: duration,
-            current_audio_state: audio_filepath # Armazena o caminho do áudio carregado
-        }
-
-    # Quando um novo áudio é carregado ou o botão é clicado, atualiza os sliders e o estado
-    load_button.click(update_sliders, inputs=[audio_input], outputs=[trim_start_slider, trim_end_slider, audio_duration_state, current_audio_state])
-    # Também atualiza se o usuário apenas fizer upload sem clicar no botão (útil)
-    audio_input.change(update_sliders, inputs=[audio_input], outputs=[trim_start_slider, trim_end_slider, audio_duration_state, current_audio_state])
-
-
-    def update_output_and_state(new_audio_path):
-        """Atualiza o componente de saída e o estado com o novo áudio editado."""
-        duration = get_audio_duration(new_audio_path)
-        return {
-            audio_output: gr.update(value=new_audio_path), # Mostra o resultado
-            current_audio_state: new_audio_path,          # Atualiza o estado para a próxima edição
-            trim_start_slider: gr.update(maximum=duration, value=0), # Atualiza sliders para nova duração
-            trim_end_slider: gr.update(maximum=duration, value=duration)
-        }
-
-    # Ações dos botões de edição
-    apply_trim_button.click(
-        apply_trim,
-        inputs=[current_audio_state, trim_start_slider, trim_end_slider],
-        outputs=[audio_output] # A saída direta vai para o componente de áudio
-    ).then(
-        update_output_and_state, # Função para atualizar o estado *depois* da edição
-        inputs=[audio_output],   # Pega o caminho do resultado do passo anterior
-        outputs=[audio_output, current_audio_state, trim_start_slider, trim_end_slider] # Atualiza tudo
-    )
+            gr.Markdown(f"### 1️⃣ Envie seu áudio (máx. {MAX_FILE_SIZE_MB} MB)")
+            audio_input = gr.Audio(type="filepath", label="Envie um arquivo de áudio")
 
-    apply_volume_button.click(
-        apply_volume_change,
-        inputs=[current_audio_state, volume_slider],
-        outputs=[audio_output]
-    ).then(
-        update_output_and_state,
-        inputs=[audio_output],
-        outputs=[audio_output, current_audio_state, trim_start_slider, trim_end_slider]
-    )
+        with gr.Column(scale=1):
+            gr.Markdown("### 2️⃣ Resultado da transcrição (atualizado durante o processo)")
+            transcription_output = gr.Textbox(label="Transcrição", lines=20, interactive=False)
 
-    reverse_button.click(
-        reverse_audio,
-        inputs=[current_audio_state],
-        outputs=[audio_output]
-    ).then(
-        update_output_and_state,
-        inputs=[audio_output],
-        outputs=[audio_output, current_audio_state, trim_start_slider, trim_end_slider]
-    )
+    transcribe_button = gr.Button("🚀 Transcrever Áudio")
 
+    # Vincular ação ao botão - Usando a função geradora
+    transcribe_button.click(
+        fn=transcribe_audio_generator,
+        inputs=[audio_input],
+        outputs=[transcription_output]
+    )
 
-# --- Execução ---
-# Lembre-se: Instale ffmpeg (sudo apt update && sudo apt install ffmpeg) se não tiver
-# pip install pydub gradio
-demo.launch(debug=True) # Debug=True ajuda a ver erros
+# Rodar a aplicação
+print("Iniciando interface Gradio...")
+# share=True pode não funcionar bem com processos muito longos em ambientes gratuitos
+demo.launch(share=False) # Recomendo testar localmente primeiro (share=False)
+print("Interface disponível.")