Update app.py

app.py

@@ -699,76 +699,110 @@ def groq_json_to_srt(data):
             
     return srt_output
 
-from srt_utils import apply_netflix_style_filter
+from srt_utils import apply_netflix_style_filter, process_audio_for_transcription
 
 async def get_groq_srt_base(url: str, language: Optional[str] = None, temperature: Optional[float] = 0.4):
     """
     Helper para gerar SRT base usando Groq (dando suporte a filtro Netflix).
     Retorna (srt_filtered, srt_word_level)
+    Agora faz download e pré-processamento do áudio localmente para melhorar qualidade.
     """
     if not url:
          raise HTTPException(status_code=400, detail="URL é obrigatória para processamento Groq")
 
-    # Preparar requisição para Groq (Multipart via URL)
-    groq_url = "https://api.groq.com/openai/v1/audio/transcriptions"
-    headers = {
-        "Authorization": f"Bearer {GROQ_API_KEY}"
-    }
-    
-    files = {
-        "model": (None, "whisper-large-v3"),
-        "url": (None, url),
-        "temperature": (None, str(temperature)),
-        "timestamp_granularities[]": (None, "word"),
-        "response_format": (None, "verbose_json")
-    }
-    
-    if language and language in GROQ_SUPPORTED_LANGUAGES:
-        files["language"] = (None, language)
-    else:
-        # Se language não for suportado ou None, não envia (auto-detect)
-        if language:
-            print(f"⚠️ Linguagem '{language}' não suportada ou código inválido. Enviando sem language.")
+    # 1. Baixar arquivo
+    print(f"⬇️ [Groq] Baixando arquivo para pré-processamento...")
+    try:
+        response = download_file_with_retry(url)
+    except Exception as e:
+        print(f"⚠️ Falha ao baixar arquivo para Groq: {e}")
+        raise HTTPException(status_code=400, detail=f"Falha ao baixar arquivo: {e}")
 
-    print(f"🧠 [Groq] Enviando URL para processamento (whisper-large-v3)...")
+    # Salvar temp
+    content_type = response.headers.get('content-type', '').lower()
+    ext = '.mp3' # Default fallback
+    if 'video' in content_type: ext = '.mp4'
+    elif 'audio' in content_type: ext = '.mp3'
     
-    max_retries = 3
-    for attempt in range(max_retries):
-        try:
-            response_groq = requests.post(groq_url, headers=headers, files=files, timeout=300)
+    temp_input = tempfile.NamedTemporaryFile(delete=False, suffix=ext)
+    try:
+        for chunk in response.iter_content(chunk_size=8192):
+            if chunk:
+                temp_input.write(chunk)
+        temp_input.close()
+        
+        # 2. Pré-processar (Remover ruído, filtrar voz, etc)
+        print(f"🔊 [Groq] Pré-processando áudio (Isolamento de voz + Highpass/Lowpass)...")
+        processed_file_path = process_audio_for_transcription(temp_input.name)
+        
+        # 3. Enviar para Groq
+        groq_url = "https://api.groq.com/openai/v1/audio/transcriptions"
+        headers = {
+            "Authorization": f"Bearer {GROQ_API_KEY}"
+        }
+        
+        # Abrir arquivo processado
+        with open(processed_file_path, "rb") as f:
+            files = {
+                "model": (None, "whisper-large-v3"),
+                "file": ("audio.mp3", f, "audio/mpeg"), # Mandar como file
+                "temperature": (None, str(temperature)),
+                "timestamp_granularities[]": (None, "word"),
+                "response_format": (None, "verbose_json")
+            }
             
-            if response_groq.status_code == 200:
-                result = response_groq.json()
-                break
+            if language and language in GROQ_SUPPORTED_LANGUAGES:
+                files["language"] = (None, language)
             
-            # Check for specific "context deadline exceeded" or 5xx errors
-            error_msg = response_groq.text.lower()
-            is_deadline_error = "context deadline exceeded" in error_msg
-            is_server_error = response_groq.status_code >= 500
+            print(f"🧠 [Groq] Enviando ÁUDIO PROCESSADO para API...")
             
-            if (is_deadline_error or is_server_error) and attempt < max_retries - 1:
-                wait_time = 2 * (attempt + 1)
-                print(f"⚠️ Erro transiente Groq ({response_groq.status_code}): {error_msg[:100]}... Tentando novamente em {wait_time}s...")
-                await asyncio.sleep(wait_time)
-                
-                # Reset files pointer if needed (though for URL it's fine, but if we sent file-like obj we'd need seek(0))
-                # Since we send tuples with strings/None, we don't need to reset anything for 'files' dict here.
-                continue
-                
-            raise HTTPException(status_code=response_groq.status_code, detail=f"Erro Groq: {response_groq.text}")
+            max_retries = 3
+            result = None
             
-        except requests.RequestException as e:
-            if attempt < max_retries - 1:
-                print(f"⚠️ Erro de conexão Groq: {e}. Retentando...")
-                await asyncio.sleep(2)
-                continue
-            raise HTTPException(status_code=500, detail=f"Erro de conexão com Groq: {str(e)}")
+            for attempt in range(max_retries):
+                try:
+                    # Precisamos resetar o ponteiro do arquivo se for retry? 
+                    # O requests deve ler tudo. Se falhar, na proxima tentativa, o 'f' ja foi lido.
+                    # Mover seek(0) é importante.
+                    f.seek(0)
+                    
+                    response_groq = requests.post(groq_url, headers=headers, files=files, timeout=300)
+                    
+                    if response_groq.status_code == 200:
+                        result = response_groq.json()
+                        break
+                    
+                    error_msg = response_groq.text.lower()
+                    is_deadline = "context deadline exceeded" in error_msg
+                    is_server = response_groq.status_code >= 500
+                    
+                    if (is_deadline or is_server) and attempt < max_retries - 1:
+                        wait_time = 2 * (attempt + 1)
+                        print(f"⚠️ Erro transiente Groq ({response_groq.status_code}). Retentando em {wait_time}s...")
+                        await asyncio.sleep(wait_time)
+                        continue
+                        
+                    raise HTTPException(status_code=response_groq.status_code, detail=f"Erro Groq: {response_groq.text}")
+                    
+                except requests.RequestException as e:
+                    if attempt < max_retries - 1:
+                        print(f"⚠️ Erro conexão Groq. Retentando...")
+                        await asyncio.sleep(2)
+                        continue
+                    raise HTTPException(status_code=500, detail=f"Erro conexão Groq: {e}")
 
-    
-    # Converter para SRT (Word Level)
+    finally:
+        # Cleanup
+        if os.path.exists(temp_input.name):
+            try: os.unlink(temp_input.name)
+            except: pass
+        # Se process_audio criou um arquivo novo (com sufixo .processed.mp3)
+        if 'processed_file_path' in locals() and processed_file_path != temp_input.name and os.path.exists(processed_file_path):
+             try: os.unlink(processed_file_path)
+             except: pass
+
+    # Converter para SRT
     srt_word = groq_json_to_srt(result)
-    
-    # Aplicar filtro Netflix (Merge e Fix Overlaps)
     srt_filtered = apply_netflix_style_filter(srt_word)
     
     return srt_filtered, srt_word