Delete routers/subtitle.py

routers/subtitle.py

@@ -1,497 +0,0 @@
-from fastapi import APIRouter, Query, HTTPException
-from moviepy.editor import VideoFileClip
-import tempfile
-import requests
-import os
-import shutil
-from groq import Groq
-from audio_separator.separator import Separator
-from google import genai
-from google.genai import types
-
-router = APIRouter()
-
-def download_file(url: str, suffix: str) -> str:
-    """Download genérico para arquivos de áudio e vídeo"""
-    print(f"Tentando baixar arquivo de: {url}")
-    headers = {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
-        'Accept': '*/*',
-        'Accept-Language': 'en-US,en;q=0.5',
-        'Accept-Encoding': 'gzip, deflate',
-        'Connection': 'keep-alive',
-        'Upgrade-Insecure-Requests': '1',
-    }
-    
-    try:
-        response = requests.get(url, headers=headers, stream=True, timeout=30)
-        print(f"Status da resposta: {response.status_code}")
-        response.raise_for_status()
-    except requests.exceptions.RequestException as e:
-        print(f"Erro na requisição: {e}")
-        raise HTTPException(status_code=400, detail=f"Não foi possível baixar o arquivo: {str(e)}")
-    
-    if response.status_code != 200:
-        raise HTTPException(status_code=400, detail=f"Erro ao baixar arquivo. Status: {response.status_code}")
-    
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
-    try:
-        total_size = 0
-        for chunk in response.iter_content(chunk_size=8192):
-            if chunk:
-                tmp.write(chunk)
-                total_size += len(chunk)
-        tmp.close()
-        print(f"Arquivo baixado com sucesso. Tamanho: {total_size} bytes")
-        return tmp.name
-    except Exception as e:
-        tmp.close()
-        if os.path.exists(tmp.name):
-            os.unlink(tmp.name)
-        print(f"Erro ao salvar arquivo: {e}")
-        raise HTTPException(status_code=400, detail=f"Erro ao salvar arquivo: {str(e)}")
-
-def extract_audio_from_video(video_path: str) -> str:
-    """Extrai áudio de um arquivo de vídeo e salva como WAV"""
-    print(f"Extraindo áudio do vídeo: {video_path}")
-    
-    audio_tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
-    audio_path = audio_tmp.name
-    audio_tmp.close()
-    
-    try:
-        video = VideoFileClip(video_path)
-        audio = video.audio
-        audio.write_audiofile(audio_path, verbose=False, logger=None)
-        audio.close()
-        video.close()
-        print(f"Áudio extraído com sucesso: {audio_path}")
-        return audio_path
-    except Exception as e:
-        if os.path.exists(audio_path):
-            os.unlink(audio_path)
-        print(f"Erro ao extrair áudio: {e}")
-        raise HTTPException(status_code=500, detail=f"Erro ao extrair áudio do vídeo: {str(e)}")
-
-def separate_vocals(audio_path: str) -> str:
-    """Separa vocais do áudio usando audio-separator com modelo UVR_MDXNET_KARA_2.onnx"""
-    print(f"Iniciando separação de vocais do arquivo: {audio_path}")
-    
-    # Criar diretório temporário para saída
-    temp_output_dir = tempfile.mkdtemp(prefix="vocal_separation_")
-    
-    try:
-        # Inicializar o separador
-        separator = Separator(output_dir=temp_output_dir)
-        
-        # Carregar modelo específico para vocais (UVR_MDXNET_KARA_2.onnx é melhor para vocais)
-        print("Carregando modelo UVR_MDXNET_KARA_2.onnx...")
-        separator.load_model('UVR_MDXNET_KARA_2.onnx')
-        
-        # Processar arquivo
-        print("Processando separação de vocais...")
-        separator.separate(audio_path)
-        
-        # Encontrar o arquivo de vocais gerado
-        # O audio-separator geralmente gera arquivos com sufixos específicos
-        base_name = os.path.splitext(os.path.basename(audio_path))[0]
-        
-        # Procurar pelo arquivo de vocais (pode ter diferentes sufixos dependendo do modelo)
-        possible_vocal_files = [
-            f"{base_name}_(Vocals).wav",
-            f"{base_name}_vocals.wav",
-            f"{base_name}_Vocals.wav",
-            f"{base_name}_(Vocal).wav"
-        ]
-        
-        vocal_file_path = None
-        for possible_file in possible_vocal_files:
-            full_path = os.path.join(temp_output_dir, possible_file)
-            if os.path.exists(full_path):
-                vocal_file_path = full_path
-                break
-        
-        # Se não encontrou pelos nomes padrão, procurar qualquer arquivo wav no diretório
-        if not vocal_file_path:
-            wav_files = [f for f in os.listdir(temp_output_dir) if f.endswith('.wav')]
-            if wav_files:
-                # Pegar o primeiro arquivo wav encontrado (assumindo que seja o vocal)
-                vocal_file_path = os.path.join(temp_output_dir, wav_files[0])
-        
-        if not vocal_file_path or not os.path.exists(vocal_file_path):
-            raise HTTPException(status_code=500, detail="Arquivo de vocais não foi gerado corretamente")
-        
-        # Mover arquivo de vocais para um local temporário permanente
-        vocal_temp = tempfile.NamedTemporaryFile(delete=False, suffix="_vocals.wav")
-        vocal_final_path = vocal_temp.name
-        vocal_temp.close()
-        
-        shutil.copy2(vocal_file_path, vocal_final_path)
-        print(f"Vocais separados com sucesso: {vocal_final_path}")
-        
-        return vocal_final_path
-        
-    except Exception as e:
-        print(f"Erro na separação de vocais: {e}")
-        raise HTTPException(status_code=500, detail=f"Erro ao separar vocais: {str(e)}")
-    
-    finally:
-        # Limpar diretório temporário de separação
-        if os.path.exists(temp_output_dir):
-            try:
-                shutil.rmtree(temp_output_dir)
-                print(f"Diretório temporário removido: {temp_output_dir}")
-            except Exception as cleanup_error:
-                print(f"Erro ao remover diretório temporário: {cleanup_error}")
-
-def format_time(seconds_float: float) -> str:
-    """Converte segundos para formato de tempo SRT (HH:MM:SS,mmm) - versão melhorada"""
-    # Calcula segundos totais e milissegundos
-    total_seconds = int(seconds_float)
-    milliseconds = int((seconds_float - total_seconds) * 1000)
-    
-    # Calcula horas, minutos e segundos restantes
-    hours = total_seconds // 3600
-    minutes = (total_seconds % 3600) // 60
-    seconds = total_seconds % 60
-    
-    return f"{hours:02}:{minutes:02}:{seconds:02},{milliseconds:03}"
-
-def json_to_srt(segments_data) -> str:
-    """
-    Converte dados de segmentos para formato SRT
-    """
-    if not segments_data:
-        return ""
-    
-    srt_lines = []
-    
-    for segment in segments_data:
-        segment_id = segment.get('id', 0) + 1
-        start_time = format_time(segment.get('start', 0.0))
-        end_time = format_time(segment.get('end', 0.0))
-        text = segment.get('text', '').strip()
-        
-        if text:  # Só adiciona se há texto
-            srt_lines.append(f"{segment_id}")
-            srt_lines.append(f"{start_time} --> {end_time}")
-            srt_lines.append(text)
-            srt_lines.append("")  # Linha em branco
-    
-    return '\n'.join(srt_lines)
-
-def convert_to_srt(transcription_data) -> str:
-    """
-    Função para conversão usando apenas segments
-    """
-    if hasattr(transcription_data, 'segments') and transcription_data.segments:
-        return json_to_srt(transcription_data.segments)
-    else:
-        return ""
-
-def translate_subtitle_internal(content: str) -> str:
-    """
-    Função interna para traduzir legendas usando Gemini
-    Baseada na lógica do inference_sub.py
-    """
-    try:
-        print("Iniciando tradução da legenda...")
-        
-        api_key = os.environ.get("GEMINI_API_KEY")
-        if not api_key:
-            raise HTTPException(status_code=500, detail="GEMINI_API_KEY não configurada")
-        
-        client = genai.Client(api_key=api_key)
-        model = "gemini-2.5-pro"
-        
-        # Instruções do sistema aprimoradas
-        SYSTEM_INSTRUCTIONS = """
-Você é um tradutor profissional de legendas especializado em tradução do inglês para o português brasileiro.
-Sua função é traduzir legendas mantendo a formatação SRT original intacta e seguindo os padrões da Netflix.
-REGRAS FUNDAMENTAIS:
-1. NUNCA altere os timestamps (00:00:00,000 --> 00:00:00,000)
-2. NUNCA altere os números das legendas (1, 2, 3, etc.)
-3. Mantenha a formatação SRT exata: número, timestamp, texto traduzido, linha em branco
-4. Traduza APENAS o texto das falas
-PADRÕES DE TRADUÇÃO:
-- Tradução natural para português brasileiro
-- Mantenha o tom e registro da fala original (formal/informal, gírias, etc.)
-- Preserve nomes próprios, lugares e marcas
-- Adapte expressões idiomáticas para equivalentes em português quando necessário
-- Use contrações naturais do português brasileiro (você → cê, para → pra, quando apropriado)
-FORMATAÇÃO NETFLIX:
-- Máximo de 2 linhas por legenda
-- Máximo de 42 caracteres por linha (incluindo espaços)
-- Use quebra de linha quando o texto for muito longo
-- Prefira quebras em pontos naturais da fala (após vírgulas, conjunções, etc.)
-- Centralize o texto quando possível
-PONTUAÇÃO E ESTILO:
-- Use pontuação adequada em português
-- Mantenha reticências (...) para hesitações ou falas interrompidas
-- Use travessão (–) para diálogos quando necessário
-- Evite pontos finais desnecessários em falas curtas
-Sempre retorne APENAS o conteúdo das legendas traduzidas, mantendo a formatação SRT original.
-"""
-
-        # Primeiro exemplo
-        EXAMPLE_INPUT_1 = """1
-00:00:00,000 --> 00:00:03,500
-You could argue he'd done it to curry favor with the guards.
-2
-00:00:04,379 --> 00:00:07,299
-Or maybe make a few friends among us Khans.
-3
-00:00:08,720 --> 00:00:12,199
-Me, I think he did it just to feel normal again.
-4
-00:00:13,179 --> 00:00:14,740
-If only for a short while."""
-
-        EXAMPLE_OUTPUT_1 = """1
-00:00:00,000 --> 00:00:03,500
-Você pode dizer que ele fez isso
-para agradar os guardas.
-2
-00:00:04,379 --> 00:00:07,299
-Ou talvez para fazer alguns amigos
-entre nós, os Khans.
-3
-00:00:08,720 --> 00:00:12,199
-Eu acho que ele fez isso só para se sentir
-normal de novo.
-4
-00:00:13,179 --> 00:00:14,740
-Mesmo que só por um tempo."""
-
-        # Segundo exemplo
-        EXAMPLE_INPUT_2 = """1
-00:00:15,420 --> 00:00:18,890
-I'm not saying you're wrong, but have you considered the alternatives?
-2
-00:00:19,234 --> 00:00:21,567
-What if we just... I don't know... talked to him?
-3
-00:00:22,890 --> 00:00:26,234
-Listen, Jack, this isn't some Hollywood movie where everything works out.
-4
-00:00:27,123 --> 00:00:29,456
-Sometimes you gotta make the hard choices."""
-
-        EXAMPLE_OUTPUT_2 = """1
-00:00:15,420 --> 00:00:18,890
-Não tô dizendo que você tá errado, mas
-já pensou nas alternativas?
-2
-00:00:19,234 --> 00:00:21,567
-E se a gente só... sei lá...
-conversasse com ele?
-3
-00:00:22,890 --> 00:00:26,234
-Escuta, Jack, isso não é um filme de
-Hollywood onde tudo dá certo.
-4
-00:00:27,123 --> 00:00:29,456
-Às vezes você tem que fazer
-as escolhas difíceis."""
-
-        # Terceiro exemplo com diálogos
-        EXAMPLE_INPUT_3 = """1
-00:00:30,789 --> 00:00:32,456
-- Hey, what's up?
-- Not much, just chilling.
-2
-00:00:33,567 --> 00:00:36,123
-Did you see that new Netflix show everyone's talking about?
-3
-00:00:37,234 --> 00:00:40,789
-Yeah, it's incredible! The cinematography is absolutely stunning.
-4
-00:00:41,890 --> 00:00:44,567
-I can't believe they canceled it after just one season though."""
-
-        EXAMPLE_OUTPUT_3 = """1
-00:00:30,789 --> 00:00:32,456
-– E aí, tudo bem?
-– De boa, só relaxando.
-2
-00:00:33,567 --> 00:00:36,123
-Você viu aquela série nova da Netflix
-que todo mundo tá falando?
-3
-00:00:37,234 --> 00:00:40,789
-Vi, é incrível! A cinematografia
-é absolutamente deslumbrante.
-4
-00:00:41,890 --> 00:00:44,567
-Não acredito que cancelaram depois
-de só uma temporada."""
-
-        # Estrutura de conversação correta com múltiplos exemplos
-        contents = [
-            # Primeiro exemplo: usuário envia legenda
-            types.Content(
-                role="user",
-                parts=[
-                    types.Part.from_text(text=EXAMPLE_INPUT_1)
-                ]
-            ),
-            # Primeiro exemplo: modelo responde com tradução
-            types.Content(
-                role="model",
-                parts=[
-                    types.Part.from_text(text=EXAMPLE_OUTPUT_1)
-                ]
-            ),
-            # Segundo exemplo: usuário envia outra legenda
-            types.Content(
-                role="user",
-                parts=[
-                    types.Part.from_text(text=EXAMPLE_INPUT_2)
-                ]
-            ),
-            # Segundo exemplo: modelo responde com tradução
-            types.Content(
-                role="model",
-                parts=[
-                    types.Part.from_text(text=EXAMPLE_OUTPUT_2)
-                ]
-            ),
-            # Terceiro exemplo: usuário envia legenda com diálogos
-            types.Content(
-                role="user",
-                parts=[
-                    types.Part.from_text(text=EXAMPLE_INPUT_3)
-                ]
-            ),
-            # Terceiro exemplo: modelo responde com tradução
-            types.Content(
-                role="model",
-                parts=[
-                    types.Part.from_text(text=EXAMPLE_OUTPUT_3)
-                ]
-            ),
-            # Agora o usuário envia a legenda real para ser traduzida
-            types.Content(
-                role="user",
-                parts=[
-                    types.Part.from_text(text=content)
-                ]
-            )
-        ]
-
-        config = types.GenerateContentConfig(
-            system_instruction=SYSTEM_INSTRUCTIONS,
-            response_mime_type="text/plain",
-            max_output_tokens=4096,
-            temperature=0.3,  # Menos criatividade, mais precisão na tradução
-        )
-        
-        response_text = ""
-        for chunk in client.models.generate_content_stream(
-            model=model,
-            contents=contents,
-            config=config
-        ):
-            if chunk.text:
-                response_text += chunk.text
-        
-        translated_content = response_text.strip()
-        print("Tradução concluída com sucesso")
-        return translated_content
-        
-    except Exception as e:
-        print(f"Erro na tradução interna: {e}")
-        # Retorna o conteúdo original se a tradução falhar
-        return content
-
-@router.get("/subtitle/generate-srt")
-def generate_srt_subtitle(
-    url: str = Query(..., description="URL do arquivo de áudio (.wav) ou vídeo")
-):
-    """
-    Gera legenda em formato SRT a partir de arquivo de áudio ou vídeo
-    - Se for .wav: separa vocais e transcreve
-    - Se for vídeo: extrai áudio, separa vocais e transcreve
-    - Usa modelo UVR_MDXNET_KARA_2.onnx para separação de vocais
-    - Usa segmentação natural do Whisper (segments)
-    - Detecção automática de idioma
-    - Tradução automática sempre ativada
-    """
-    local_file = None
-    audio_file = None
-    vocal_file = None
-    
-    try:
-        # Determinar tipo de arquivo pela URL
-        url_lower = url.lower()
-        is_audio = url_lower.endswith('.wav')
-        is_video = any(url_lower.endswith(ext) for ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm'])
-        
-        if not (is_audio or is_video):
-            raise HTTPException(
-                status_code=400, 
-                detail="URL deve ser de um arquivo de áudio (.wav) ou vídeo"
-            )
-        
-        if is_audio:
-            local_file = download_file(url, ".wav")
-            audio_file = local_file
-        else:
-            local_file = download_file(url, ".mp4")
-            audio_file = extract_audio_from_video(local_file)
-        
-        # Separar vocais do áudio
-        vocal_file = separate_vocals(audio_file)
-        
-        # Transcrição com configurações fixas otimizadas
-        api_key = os.getenv("GROQ_API")
-        if not api_key:
-            raise HTTPException(status_code=500, detail="GROQ_API key não configurada")
-        
-        client = Groq(api_key=api_key)
-        
-        print(f"Iniciando transcrição com modelo: whisper-large-v3")
-        with open(vocal_file, "rb") as file:
-            transcription_params = {
-                "file": (os.path.basename(vocal_file), file.read()),
-                "model": "whisper-large-v3",
-                "response_format": "verbose_json",
-                "timestamp_granularities": ["segment"],
-                "temperature": 0.0,
-                # language é automaticamente detectado (não enviado)
-            }
-            
-            transcription = client.audio.transcriptions.create(**transcription_params)
-        
-        # Converter para SRT usando segments
-        srt_content_original = convert_to_srt(transcription)
-        
-        # Traduzir sempre
-        srt_content = translate_subtitle_internal(srt_content_original) if srt_content_original else None
-        
-        return {
-            "srt": srt_content,
-            "duration": getattr(transcription, 'duration', 0),
-            "language": getattr(transcription, 'language', 'unknown'),
-            "model_used": "whisper-large-v3",
-            "processing_method": "segments",
-            "vocal_separation": "UVR_MDXNET_KARA_2.onnx",
-            "translation_applied": True,
-            "segment_count": len(transcription.segments) if hasattr(transcription, 'segments') and transcription.segments else 0,
-            "subtitle_count": len([line for line in srt_content.split('\n') if line.strip().isdigit()]) if srt_content else 0
-        }
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Erro inesperado: {str(e)}")
-    
-    finally:
-        # Limpeza de arquivos temporários
-        for temp_file in [local_file, audio_file, vocal_file]:
-            if temp_file and os.path.exists(temp_file):
-                try:
-                    os.unlink(temp_file)
-                    print(f"Arquivo temporário removido: {temp_file}")
-                except Exception as cleanup_error:
-                    print(f"Erro ao remover arquivo temporário {temp_file}: {cleanup_error}")