Update app.py

app.py

@@ -1,9 +1,12 @@
 from fastapi import FastAPI, HTTPException, File, UploadFile, Form
-from fastapi.responses import JSONResponse
+from fastapi.responses import Response, JSONResponse
 from typing import Optional
 import os
 import tempfile
 from pathlib import Path
+import re
+import requests
+import mimetypes
 
 from gemini_client import AsyncChatbot, Model, load_cookies, save_cookies
 from gemini_client.enums import Endpoint, Headers
@@ -134,6 +137,322 @@ def root():
     """Endpoint raiz"""
     return {"status": "ok", "message": "Gemini Chat API está funcionando"}
 
+def clean_and_validate_srt(srt_content):
+    """Limpa e valida conteúdo SRT seguindo o padrão do example.py"""
+    if "```" in srt_content:
+        # Remover markdown code blocks
+        parts = srt_content.split("```")
+        if len(parts) > 1:
+            # Pegar o conteúdo dentro dos blocos de código
+            for part in parts:
+                if "srt" in part.lower() or not part.strip().startswith("srt"):
+                    srt_content = part.strip()
+                    break
+    
+    # Padrão mais flexível para capturar timestamps mal formatados
+    pattern = re.compile(r"(\d+)\s*\n([^-\n]+?) --> ([^-\n]+?)\s*\n((?:(?!^\d+\s*\n).+\n?)*)", re.MULTILINE)
+    matches = pattern.findall(srt_content)
+    
+    def corrigir_timestamp(timestamp):
+        timestamp = timestamp.strip()
+        
+        # Se já está correto, retorna
+        if re.match(r"\d{2}:\d{2}:\d{2},\d{3}", timestamp):
+            return timestamp
+        
+        # Formato: MM:SS,mmm -> HH:MM:SS,mmm
+        if re.match(r"\d{2}:\d{2},\d{3}", timestamp):
+            return f"00:{timestamp}"
+        
+        # Formato: M:SS,mmm -> HH:MM:SS,mmm
+        if re.match(r"\d{1}:\d{2},\d{3}", timestamp):
+            parts = timestamp.split(":")
+            minutes = parts[0].zfill(2)
+            return f"00:{minutes}:{parts[1]}"
+        
+        # Formato: SS,mmm -> HH:MM:SS,mmm
+        if re.match(r"\d{1,2},\d{3}", timestamp):
+            seconds_ms = timestamp.split(",")
+            seconds = seconds_ms[0].zfill(2)
+            return f"00:00:{seconds},{seconds_ms[1]}"
+        
+        # Outros formatos problemáticos
+        if re.match(r"\d{2}:\d{2}:\d{3}", timestamp):
+            parts = timestamp.split(":")
+            if len(parts) == 3:
+                h, m, s_ms = parts
+                if len(s_ms) == 3:
+                    return f"{h}:{m}:00,{s_ms}"
+                elif len(s_ms) >= 4:
+                    s = s_ms[:-3]
+                    ms = s_ms[-3:]
+                    return f"{h}:{m}:{s.zfill(2)},{ms}"
+        
+        return timestamp
+    
+    srt_corrigido = ""
+    for i, (num, start, end, text) in enumerate(matches, 1):
+        text = text.strip()
+        if not text:
+            continue
+        
+        # Verificar se a legenda tem mais de 2 linhas
+        text_lines = [line.strip() for line in text.split('\n') if line.strip()]
+        if len(text_lines) > 2:
+            # Limitar a 2 linhas, juntando as extras na segunda linha
+            text = text_lines[0] + '\n' + ' '.join(text_lines[1:])
+        
+        start_corrigido = corrigir_timestamp(start)
+        end_corrigido = corrigir_timestamp(end)
+        srt_corrigido += f"{i}\n{start_corrigido} --> {end_corrigido}\n{text}\n\n"
+    
+    return srt_corrigido.strip()
+
+@app.get("/subtitle")
+async def generate_subtitle(
+    file: str,
+    context: Optional[str] = None
+):
+    """
+    Endpoint para gerar legendas SRT a partir de um arquivo (imagem, vídeo ou áudio).
+    
+    Parâmetros:
+    - file: URL do arquivo (imagem, vídeo ou áudio)
+    - context: Contexto adicional opcional para a geração de legendas
+    
+    Retorna:
+    - Arquivo SRT formatado
+    """
+    if chatbot is None:
+        raise HTTPException(status_code=500, detail="Chatbot não inicializado")
+    
+    if not file:
+        raise HTTPException(status_code=400, detail="Parâmetro 'file' é obrigatório")
+    
+    temp_file = None
+    try:
+        # Baixar arquivo da URL
+        print(f"📥 Baixando arquivo de: {file}")
+        response = requests.get(file, timeout=300, stream=True)
+        response.raise_for_status()
+        
+        # Determinar tipo de mídia e extensão
+        content_type = response.headers.get('content-type', '').lower()
+        file_extension = None
+        
+        if 'video' in content_type:
+            file_extension = '.mp4'
+            media_type = 'video'
+        elif 'audio' in content_type:
+            file_extension = '.mp3'
+            media_type = 'audio'
+        elif 'image' in content_type:
+            # Determinar extensão da imagem
+            if 'jpeg' in content_type or 'jpg' in content_type:
+                file_extension = '.jpg'
+            elif 'png' in content_type:
+                file_extension = '.png'
+            elif 'gif' in content_type:
+                file_extension = '.gif'
+            elif 'webp' in content_type:
+                file_extension = '.webp'
+            else:
+                file_extension = '.jpg'
+            media_type = 'image'
+        else:
+            # Tentar inferir do URL
+            url_lower = file.lower()
+            if any(ext in url_lower for ext in ['.mp4', '.avi', '.mov', '.webm', '.mkv']):
+                file_extension = '.mp4'
+                media_type = 'video'
+            elif any(ext in url_lower for ext in ['.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a']):
+                file_extension = '.mp3'
+                media_type = 'audio'
+            elif any(ext in url_lower for ext in ['.jpg', '.jpeg', '.png', '.gif', '.webp']):
+                file_extension = Path(file).suffix or '.jpg'
+                media_type = 'image'
+            else:
+                raise HTTPException(status_code=400, detail="Tipo de arquivo não suportado. Use imagem, vídeo ou áudio.")
+        
+        # Salvar arquivo temporariamente
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=file_extension)
+        for chunk in response.iter_content(chunk_size=8192):
+            if chunk:
+                temp_file.write(chunk)
+        temp_file.close()
+        
+        print(f"✅ Arquivo baixado: {temp_file.name} (tipo: {media_type})")
+        
+        # Preparar prompt (mesmo do example.py)
+        context_text = context.strip() if context else "N/A"
+        media_desc = 'áudio' if media_type in ['video', 'audio'] else 'conteúdo'
+        media_desc_final = 'VÍDEO' if media_type in ['video', 'audio'] else 'CONTEÚDO'
+        
+        prompt = f"Gere uma legenda em formato SRT para este {media_desc} seguindo RIGOROSAMENTE todas as especificações do sistema.\n\nContexto adicional: {context_text}"
+        
+        # System instruction (mesmo do example.py)
+        system_instruction = f"""FORMATO TÉCNICO OBRIGATÓRIO
+
+Estrutura de cada bloco:
+
+[número sequencial]
+HH:MM:SS,mmm --> HH:MM:SS,mmm
+[texto da legenda]
+[linha em branco]
+
+CRÍTICO - Formato de tempo:
+- SEMPRE usar: HH:MM:SS,mmm (exemplo: 00:01:23,456)
+- Vírgula (,) separando segundos de milissegundos
+- Duas casas para horas, minutos e segundos
+- Três casas para milissegundos
+- Nunca omitir as horas, mesmo que sejam 00
+
+PADRÃO NETFLIX - REGRAS DE TEXTO
+
+Limitações de caracteres:
+- Máximo 2 linhas por legenda
+- Máximo 42 caracteres por linha (incluindo espaços e pontuação)
+- Quebras de linha devem respeitar unidades semânticas (não partir palavras ou expressões)
+
+Separação de falas:
+- NUNCA misture falas de pessoas diferentes na mesma legenda
+- Se houver mudança de locutor, SEMPRE crie um novo bloco numerado
+- Única exceção: diálogos rápidos marcados com hífen (veja abaixo)
+
+Uso de hífen (-):
+Use APENAS para:
+1. Diálogos alternados quando o timing impede separação:
+
+   - Vamos?
+   - Vamos!
+
+2. Interrupções abruptas de fala
+3. Falas sobrepostas simultâneas
+
+NÃO use hífen para:
+- Fala única de uma pessoa
+- Marcação desnecessária de locutor
+
+NATURALIDADE E EMOÇÃO
+
+Idioma:
+- Português brasileiro natural
+- Adaptar gírias, expressões regionais e modo de falar brasileiro
+- Evitar traduções literais ou formais demais
+
+Expressão emocional:
+- Gritos, ênfase forte: LETRAS MAIÚSCULAS
+- Hesitação, pausa: reticências (...)
+- Surpresa, exclamação: ponto de exclamação (!)
+- Interrogação: ponto de interrogação (?)
+- Nunca deixe frases importantes sem pontuação
+- Exemplos:
+  - "João" → "João..." (hesitante)
+  - "João" → "João!" (chamando com urgência)
+  - "João" → "JOÃO!" (gritando)
+
+SINCRONIA TEMPORAL
+
+- Precisão de milissegundos
+- Início da legenda: EXATAMENTE quando a fala começa
+- Fim da legenda: quando a fala termina (mínimo 1 segundo de exibição)
+- Respeitar pausas naturais entre falas
+
+EXEMPLO DE FORMATAÇÃO PERFEITA
+
+1
+00:00:01,200 --> 00:00:04,000
+Oi, tudo bem?
+
+2
+00:00:04,500 --> 00:00:06,800
+Tudo ótimo, e você?
+
+3
+00:00:07,100 --> 00:00:09,500
+- Quer almoçar comigo?
+- Claro!
+
+4
+00:00:10,000 --> 00:00:12,300
+QUE LEGAL!
+
+5
+00:00:12,800 --> 00:00:15,100
+Não acredito que você aceitou...
+
+INSTRUÇÕES FINAIS
+
+- Retorne APENAS o arquivo SRT formatado
+- Sem explicações, comentários ou textos adicionais
+- Sem marcadores de código (```), apenas o conteúdo puro
+- Numere sequencialmente a partir de 1
+- Linha em branco entre cada bloco de legenda
+
+TRADUZA TUDO DE IMPORTANTE NO {media_desc_final}, que tenha dialogo... Nunca deixe passar nada."""
+        
+        # Adicionar system instruction ao prompt
+        full_prompt = f"{system_instruction}\n\n{prompt}"
+        
+        # Enviar para o Gemini
+        print(f"🧠 Enviando {media_type} para o Gemini...")
+        
+        # Determinar qual parâmetro usar baseado no tipo de mídia
+        if media_type == 'image':
+            response_gemini = await chatbot.ask(full_prompt, image=temp_file.name)
+        elif media_type == 'video':
+            response_gemini = await chatbot.ask(full_prompt, video=temp_file.name)
+        else:  # audio
+            response_gemini = await chatbot.ask(full_prompt, audio=temp_file.name)
+        
+        if response_gemini.get("error"):
+            raise HTTPException(
+                status_code=500,
+                detail=f"Erro ao gerar legendas: {response_gemini.get('content', 'Erro desconhecido')}"
+            )
+        
+        # Extrair conteúdo SRT da resposta
+        raw_srt = response_gemini.get("content", "").strip()
+        
+        if not raw_srt or len(raw_srt) < 10:
+            raise HTTPException(
+                status_code=500,
+                detail="Nenhuma legenda foi gerada - arquivo pode estar vazio ou inaudível"
+            )
+        
+        # Limpar e validar SRT
+        print("📝 Processando formato SRT...")
+        srt_cleaned = clean_and_validate_srt(raw_srt)
+        
+        if not srt_cleaned or len(srt_cleaned.strip()) < 10:
+            raise HTTPException(
+                status_code=500,
+                detail="Falha ao processar formato SRT - resposta inválida"
+            )
+        
+        # Retornar SRT como resposta de texto
+        return Response(
+            content=srt_cleaned,
+            media_type="text/plain; charset=utf-8",
+            headers={
+                "Content-Disposition": "attachment; filename=subtitles.srt"
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except requests.RequestException as e:
+        raise HTTPException(status_code=400, detail=f"Erro ao baixar arquivo: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao gerar legendas: {str(e)}")
+    finally:
+        # Limpar arquivo temporário
+        if temp_file and os.path.exists(temp_file.name):
+            try:
+                os.unlink(temp_file.name)
+            except:
+                pass
+
 @app.get("/get")
 async def get_response(
     message: str,