Update app.py

app.py

@@ -740,35 +740,65 @@ async def get_groq_srt_base(url: str, language: Optional[str] = None, temperatur
     
     processed_audio_url = None
     processed_filename = None
+    raw_word_level_text = ""
     
     try:
-        # 2. Pré-processar (Remover ruído, filtrar voz, etc)
+        # 2a. Chamada Groq com áudio ORIGINAL (raw) para word-level timestamps fiéis ao vídeo
+        groq_url = "https://api.groq.com/openai/v1/audio/transcriptions"
+        groq_headers = {
+            "Authorization": f"Bearer {GROQ_API_KEY}"
+        }
+        
+        print(f"🧠 [Groq] Enviando ÁUDIO ORIGINAL para word-level timestamps...")
+        with open(filepath, "rb") as f_raw:
+            raw_files = [
+                ("model", (None, "whisper-large-v3")),
+                ("file", ("audio.mp3", f_raw, "audio/mpeg")),
+                ("temperature", (None, str(temperature))),
+                ("response_format", (None, "verbose_json")),
+                ("timestamp_granularities[]", (None, "word"))
+            ]
+            if language and language in GROQ_SUPPORTED_LANGUAGES:
+                raw_files.append(("language", (None, language)))
+            
+            raw_result = None
+            for attempt in range(3):
+                try:
+                    f_raw.seek(0)
+                    resp_raw = requests.post(groq_url, headers=groq_headers, files=raw_files, timeout=300)
+                    if resp_raw.status_code == 200:
+                        raw_result = resp_raw.json()
+                        break
+                    if resp_raw.status_code >= 500 and attempt < 2:
+                        await asyncio.sleep(2 * (attempt + 1))
+                        continue
+                    print(f"⚠️ [Groq Raw] Erro {resp_raw.status_code}: {resp_raw.text[:200]}")
+                    break
+                except requests.RequestException as e:
+                    if attempt < 2:
+                        await asyncio.sleep(2)
+                        continue
+                    print(f"⚠️ [Groq Raw] Erro conexão: {e}")
+                    break
+        
+        if raw_result:
+            raw_word_level_text = groq_words_to_text(raw_result)
+            print(f"✅ [Groq Raw] Word-level obtido: {len(raw_result.get('words') or [])} palavras")
+        else:
+            print(f"⚠️ [Groq Raw] Falha ao obter word-level do áudio original, continuando...")
+
+        # 2b. Pré-processar (Remover ruído, filtrar voz, etc)
         print(f"🔊 [Groq] Pré-processando áudio (has_bg_music={has_bg_music})...")
-        # O process_audio cria um arquivo novo com .processed.mp3
         processed_file_path = process_audio_for_transcription(filepath, has_bg_music=has_bg_music, time_start=time_start, time_end=time_end)
         
-        # Se processou, o caminho mudou. Vamos ver.
         if processed_file_path != filepath:
-             # Vamos mover/renomear para garantir que esteja em static com nome limpo?
-             # Na verdade o process_utils salva como <input>.processed.mp3
-             # Então já está em static/
              pass
              
-        # Gerar URL pública (assumindo que o host é acessível)
-        # Como não sabemos o domínio exato, vamos retornar caminho relativo /static/...
-        # O cliente pode compor. Ou tentamos pegar do request se tivessemos acesso.
         processed_filename = os.path.basename(processed_file_path)
         processed_audio_url = f"/static/{processed_filename}"
 
-        # 3. Enviar para Groq
-        groq_url = "https://api.groq.com/openai/v1/audio/transcriptions"
-        headers = {
-            "Authorization": f"Bearer {GROQ_API_KEY}"
-        }
-        
-        # Abrir arquivo processado
+        # 3. Enviar áudio PROCESSADO para Groq (segments + word-level)
         with open(processed_file_path, "rb") as f:
-            # Usar lista de tuplas para suportar múltiplos valores de timestamp_granularities[]
             files = [
                 ("model", (None, "whisper-large-v3")),
                 ("file", ("audio.mp3", f, "audio/mpeg")),
@@ -788,12 +818,9 @@ async def get_groq_srt_base(url: str, language: Optional[str] = None, temperatur
             
             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)
+                    response_groq = requests.post(groq_url, headers=groq_headers, files=files, timeout=300)
                     
                     if response_groq.status_code == 200:
                         result = response_groq.json()
@@ -819,21 +846,16 @@ async def get_groq_srt_base(url: str, language: Optional[str] = None, temperatur
                     raise HTTPException(status_code=500, detail=f"Erro conexão Groq: {e}")
 
     finally:
-        # Cleanup? 
-        # O usuário pediu para "hospedar em arquivo temporario... mande a url".
-        # Então NÃO deletamos o arquivo processado imediatamente.
-        # Mas deletamos o original baixado para economizar espaço?
+        # Cleanup do arquivo original
         if filepath and os.path.exists(filepath) and filepath != processed_file_path:
              try: os.unlink(filepath)
              except: pass
 
     # Converter para SRT
     srt_base = groq_json_to_srt(result)
-    word_level_text = groq_words_to_text(result)
-    # srt_filtered = apply_netflix_style_filter(srt_word) 
-    # REMOVIDO FILTRO NETFLIX - Retornando raw Whisper segments
+    word_level_processed = groq_words_to_text(result)
     
-    return srt_base, srt_base, processed_audio_url, word_level_text
+    return srt_base, srt_base, processed_audio_url, raw_word_level_text, word_level_processed
 
 @app.post("/subtitle/groq")
 async def generate_subtitle_groq(request: GroqRequest):
@@ -842,7 +864,7 @@ async def generate_subtitle_groq(request: GroqRequest):
     Agora envia a URL diretamente para a API do Groq e aplica filtro Netflix.
     """
     try:
-        srt_filtered, srt_word, processed_audio_url, _word_level = await get_groq_srt_base(
+        srt_filtered, srt_word, processed_audio_url, _raw_wl, _proc_wl = await get_groq_srt_base(
             url=request.url, 
             language=request.language, 
             temperature=request.temperature,
@@ -892,7 +914,7 @@ async def generate_subtitle(request: GeminiSubtitleRequest):
         # 1. Obter SRT base + Caminho do áudio processado
         print("🚀 Iniciando pipeline completo de legendagem Gemini...")
         
-        srt_filtered, srt_word, processed_audio_url, word_level_text = await get_groq_srt_base(
+        srt_filtered, srt_word, processed_audio_url, raw_word_level, processed_word_level = await get_groq_srt_base(
             url=request.url,
             language="en", 
             temperature=0.4,
@@ -1012,8 +1034,8 @@ INSTRUÇÕES/CONTEXTO DO USUÁRIO (OPCIONAL): {processed_context}
 --- LEGENDA BASE (WHISPER) ---
 {srt_filtered}
 
---- TIMESTAMPS POR PALAVRA (WORD-LEVEL) ---
-{word_level_text}
+--- TIMESTAMPS POR PALAVRA (WORD-LEVEL, ÁUDIO ORIGINAL) ---
+{raw_word_level}
 """
         
         # 4. Enviar para Gemini
@@ -1040,7 +1062,8 @@ INSTRUÇÕES/CONTEXTO DO USUÁRIO (OPCIONAL): {processed_context}
         return JSONResponse(content={
             "srt": cleaned_srt,
             "original_srt": srt_filtered,
-            "srt_word_level": word_level_text,
+            "srt_word_level_raw": raw_word_level,
+            "srt_word_level_processed": processed_word_level,
             "used_audio_processed": True
         })