Atualizar Listen Lynx com novos modelos GPT-4o e suporte a arquivos grandes

- Adicionar modelos gpt-4o-audio-preview e gpt-4o-mini-audio-preview
- Implementar sistema de chunking para arquivos >25MB
- Dividir arquivos grandes em chunks de 20MB
- Junção automática das transcrições
- Melhorar interface com seleção de modelos
- Corrigir bug de transcrição com response_format='text'
- Remover chave da API do .env (usar variáveis secretas do HF Space)

.env

@@ -0,0 +1,2 @@
+# OpenAI API Key
+# OPENAI_API_KEY será carregada das variáveis secretas do Hugging Face Space

app.py

@@ -4,6 +4,7 @@ import gradio as gr
 from openai import OpenAI
 from pydub import AudioSegment
 import tempfile
+import math
 
 # Carrega as variáveis de ambiente do arquivo .env
 load_dotenv()
@@ -11,35 +12,162 @@ load_dotenv()
 # Configura o cliente OpenAI com a chave da API do arquivo .env
 client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 
+# Constantes para controle de tamanho de arquivo
+MAX_FILE_SIZE_MB = 25
+CHUNK_SIZE_MB = 20
+CHUNK_SIZE_BYTES = CHUNK_SIZE_MB * 1024 * 1024
+
+def get_file_size_mb(file_path):
+    """Retorna o tamanho do arquivo em MB"""
+    return os.path.getsize(file_path) / (1024 * 1024)
+
 def convert_to_mp3(audio_path):
+    """Converte áudio para MP3"""
     audio = AudioSegment.from_file(audio_path)
     mp3_path = tempfile.mktemp(suffix=".mp3")
     audio.export(mp3_path, format="mp3")
     return mp3_path
 
-def transcribe_audio(audio_path):
+def split_audio_by_size(audio_path, max_size_mb=CHUNK_SIZE_MB):
+    """Divide o áudio em chunks baseado no tamanho em MB"""
+    audio = AudioSegment.from_file(audio_path)
+    
+    # Calcula o tamanho aproximado por milissegundo
+    file_size_mb = get_file_size_mb(audio_path)
+    duration_ms = len(audio)
+    mb_per_ms = file_size_mb / duration_ms
+    
+    # Calcula a duração de cada chunk em milissegundos
+    chunk_duration_ms = int(max_size_mb / mb_per_ms)
+    
+    chunks = []
+    start = 0
+    chunk_num = 0
+    
+    while start < duration_ms:
+        end = min(start + chunk_duration_ms, duration_ms)
+        chunk = audio[start:end]
+        
+        # Salva o chunk temporariamente
+        chunk_path = tempfile.mktemp(suffix=f"_chunk_{chunk_num}.mp3")
+        chunk.export(chunk_path, format="mp3")
+        chunks.append(chunk_path)
+        
+        start = end
+        chunk_num += 1
+    
+    return chunks
+
+def transcribe_single_file(audio_path, model="gpt-4o-transcribe"):
+    """Transcreve um único arquivo de áudio"""
+    try:
+        with open(audio_path, "rb") as audio_file:
+            transcription = client.audio.transcriptions.create(
+                model=model,
+                file=audio_file,
+                response_format="text"
+            )
+        return transcription
+    except Exception as e:
+        return f"Erro na transcrição: {str(e)}"
+
+def transcribe_audio(audio_path, model_choice="gpt-4o-transcribe"):
+    """Função principal de transcrição com suporte a arquivos grandes"""
     try:
         # Converter para MP3 se necessário
         file_ext = os.path.splitext(audio_path)[1].lower()
         if file_ext != ".mp3":
             audio_path = convert_to_mp3(audio_path)
 
-        with open(audio_path, "rb") as audio_file:
-            transcription = client.audio.transcriptions.create(
-                model="whisper-1",
-                file=audio_file
-            )
-        return transcription.text
+        # Verifica o tamanho do arquivo
+        file_size_mb = get_file_size_mb(audio_path)
+        
+        if file_size_mb <= MAX_FILE_SIZE_MB:
+            # Arquivo pequeno - transcrição direta
+            return transcribe_single_file(audio_path, model_choice)
+        else:
+            # Arquivo grande - dividir em chunks
+            print(f"Arquivo grande detectado ({file_size_mb:.1f}MB). Dividindo em chunks...")
+            
+            chunks = split_audio_by_size(audio_path, CHUNK_SIZE_MB)
+            transcriptions = []
+            
+            for i, chunk_path in enumerate(chunks):
+                print(f"Transcrevendo chunk {i+1}/{len(chunks)}...")
+                chunk_transcription = transcribe_single_file(chunk_path, model_choice)
+                
+                if chunk_transcription.startswith("Erro na transcrição:"):
+                    return chunk_transcription
+                
+                transcriptions.append(chunk_transcription)
+                
+                # Limpa o arquivo temporário do chunk
+                try:
+                    os.unlink(chunk_path)
+                except:
+                    pass
+            
+            # Junta todas as transcrições
+            full_transcription = " ".join(transcriptions)
+            
+            return f"[Arquivo grande processado em {len(chunks)} partes]\n\n{full_transcription}"
+            
     except Exception as e:
-        return f"Erro na transcrição: {str(e)}"
+        return f"Erro no processamento: {str(e)}"
+    finally:
+        # Limpa arquivos temporários
+        if 'audio_path' in locals() and audio_path != audio_path:
+            try:
+                os.unlink(audio_path)
+            except:
+                pass
 
 # Interface Gradio
-iface = gr.Interface(
-    fn=transcribe_audio,
-    inputs=gr.Audio(type="filepath"),
-    outputs="text",
-    title="Transcrição de Áudio com IA",
-    description="Faça upload de um arquivo de áudio para transcrevê-lo usando IA avançada."
-)
-
-iface.launch()
+with gr.Blocks(title="Listen Lynx - Transcrição de Áudio Avançada") as iface:
+    gr.Markdown("# 🎵 Listen Lynx - Transcrição de Áudio com IA")
+    gr.Markdown("Faça upload de arquivos de áudio para transcrevê-los usando os modelos mais avançados da OpenAI. Suporta arquivos grandes (até centenas de MB)!")
+    
+    with gr.Row():
+        with gr.Column():
+            audio_input = gr.Audio(
+        type="filepath",
+        label="Arquivo de Áudio"
+    )
+            
+            model_choice = gr.Dropdown(
+                choices=[
+                    ("GPT-4o Transcribe (Recomendado)", "gpt-4o-transcribe"),
+                    ("GPT-4o Mini Transcribe (Mais Rápido)", "gpt-4o-mini-transcribe"),
+                    ("Whisper-1 (Clássico)", "whisper-1")
+                ],
+                value="gpt-4o-transcribe",
+                label="Modelo de Transcrição",
+                info="GPT-4o oferece maior qualidade e correção automática de erros"
+            )
+            
+            transcribe_btn = gr.Button("🎯 Transcrever Áudio", variant="primary")
+        
+        with gr.Column():
+            output_text = gr.Textbox(
+                label="Transcrição",
+                placeholder="A transcrição aparecerá aqui...",
+                lines=15,
+                max_lines=25
+            )
+    
+    gr.Markdown("""
+    ### 📋 Informações:
+    - **Arquivos pequenos** (≤25MB): Processamento direto
+    - **Arquivos grandes** (>25MB): Divisão automática em chunks de 20MB
+    - **Modelos GPT-4o**: Correção automática de erros e melhor qualidade
+    - **Limite de upload**: Sem limite específico (processamento inteligente)
+    """)
+    
+    transcribe_btn.click(
+        fn=transcribe_audio,
+        inputs=[audio_input, model_choice],
+        outputs=output_text
+    )
+
+if __name__ == "__main__":
+    iface.launch()