Update gemini_client/enums.py

gemini_client/enums.py

@@ -1,913 +1,158 @@
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
-from typing import Optional
-import os
-import tempfile
-from pathlib import Path
-import re
-import requests
-import time
-import base64
-import io
-from PIL import Image
-
-from gemini_client import AsyncChatbot, Model, load_cookies
-
-app = FastAPI(title="Gemini Chat API", description="API para interagir com Google Gemini")
-
-# Inicializar chatbot globalmente
-
-# Inicializar chatbots globalmente
-chatbots = {}
-upscale_chatbot = None
-
-async def update_cookie_if_needed(cookie_path: str, secure_1psid: str, secure_1psidts: str, additional_cookies: dict):
-    """
-    Tenta atualizar o cookie __Secure-1PSIDTS se necessário.
-    Retorna o novo cookie ou o original se não precisar atualizar.
-    """
-    # Não tentar atualizar proativamente - deixar o sistema fazer isso quando necessário
-    # Isso evita erros 401/404 quando o cookie já expirou
-    return secure_1psidts
-
-async def init_chatbot(retry_count=0, max_retries=2):
-    """
-    Inicializa o chatbot com os cookies de forma assíncrona.
-    Tenta atualizar cookies automaticamente se falhar.
-    """
-
-    global chatbots, upscale_chatbot
-    cookie_path = os.getenv("COOKIE_PATH", "cookies.json")
-    
-    if not os.path.exists(cookie_path):
-        raise FileNotFoundError(f"Arquivo de cookies não encontrado: {cookie_path}")
-    
-    try:
-        # Carregar cookies
-        secure_1psid, secure_1psidts, additional_cookies = load_cookies(cookie_path)
-        
-        # Tentar atualizar cookie proativamente antes de inicializar
-        if retry_count == 0:
-            secure_1psidts = await update_cookie_if_needed(cookie_path, secure_1psid, secure_1psidts, additional_cookies)
-        
-        # Criar Chatbot Flash (Padrão/Rápido)
-        chatbots['flash'] = await AsyncChatbot.create(
-            secure_1psid=secure_1psid,
-            secure_1psidts=secure_1psidts,
-            model=Model.G_3_0_FLASH,
-            additional_cookies=additional_cookies,
-            cookie_path=cookie_path
-        )
-        print(f"Chatbot Flash (3.0) inicializado com sucesso")
-
-        # Criar Chatbot Thinking (Raciocínio) - Timeout maior
-        chatbots['thinking'] = await AsyncChatbot.create(
-            secure_1psid=secure_1psid,
-            secure_1psidts=secure_1psidts,
-            model=Model.G_3_0_THINKING,
-            additional_cookies=additional_cookies,
-            cookie_path=cookie_path,
-            timeout=120 # Timeout maior para thinking
-        )
-        print(f"Chatbot Thinking (3.0) inicializado com sucesso")
-
-        # Fallback/Default
-        chatbots['default'] = chatbots['flash']
-
-        # Criar instância de Upscale separada
-        upscale_chatbot = await AsyncChatbot.create(
-            secure_1psid=secure_1psid,
-            secure_1psidts=secure_1psidts,
-            model=Model.NANO_BANANA,
-            additional_cookies=additional_cookies,
-            cookie_path=cookie_path
-        )
-        print(f"Upscale Chatbot inicializado com sucesso usando modelo NANO_BANANA")
-
-    except (ValueError, PermissionError) as e:
-        error_str = str(e).lower()
-        # Se o erro é relacionado a cookie expirado, não tentar atualizar novamente
-        # O sistema já tentou atualizar automaticamente e falhou
-        print(f"Erro ao inicializar chatbot: {e}")
-        print(f"AVISO: Cookies podem estar expirados. Por favor, atualize manualmente os cookies em {cookie_path}")
-        print(f"Para atualizar: acesse https://gemini.google.com/app e copie os novos cookies __Secure-1PSID e __Secure-1PSIDTS")
-        raise
-    except Exception as e:
-        print(f"Erro ao inicializar chatbot: {e}")
-        raise
-
-# Inicializar na startup
-@app.on_event("startup")
-async def startup_event():
-    await init_chatbot()
-
-@app.get("/")
-def root():
-    """Endpoint raiz"""
-    return {"status": "ok", "message": "Gemini Chat API está funcionando"}
-
-def srt_time_to_seconds(timestamp):
-    """Converte timestamp SRT (HH:MM:SS,mmm) para segundos"""
-    try:
-        time_part, ms_part = timestamp.split(",")
-        h, m, s = map(int, time_part.split(":"))
-        ms = int(ms_part)
-        return h * 3600 + m * 60 + s + ms / 1000.0
-    except:
-        return 0.0
-
-def seconds_to_srt_time(seconds):
-    """Converte segundos para timestamp SRT (HH:MM:SS,mmm)"""
-    hours = int(seconds // 3600)
-    minutes = int((seconds % 3600) // 60)
-    secs = int(seconds % 60)
-    ms = int((seconds % 1) * 1000)
-    return f"{hours:02d}:{minutes:02d}:{secs:02d},{ms:03d}"
-
-def cut_srt_by_time(srt_content, start_time, end_time):
-    """
-    Corta legendas SRT baseado em tempo de início e fim.
-    Ajusta os timestamps para começar do zero.
-    
-    Parâmetros:
-    - srt_content: Conteúdo SRT original
-    - start_time: Tempo de início em segundos
-    - end_time: Tempo de fim em segundos
-    
-    Retorna: SRT cortado e ajustado
-    """
-    if start_time is None or end_time is None:
-        return srt_content
-    
-    # Padrão para capturar legendas
-    pattern = re.compile(r"(\d+)\s*\n([^-\n]+?) --> ([^-\n]+?)\s*\n((?:(?!^\d+\s*\n).+\n?)*)", re.MULTILINE)
-    matches = pattern.findall(srt_content)
-    
-    filtered_subtitles = []
-    for num, start, end, text in matches:
-        start_seconds = srt_time_to_seconds(start.strip())
-        end_seconds = srt_time_to_seconds(end.strip())
-        
-        # Verificar se a legenda está dentro do intervalo [start_time, end_time]
-        # Incluir legendas que se sobrepõem parcialmente
-        if end_seconds > start_time and start_seconds < end_time:
-            # Ajustar timestamps para começar do zero
-            new_start = max(0, start_seconds - start_time)
-            new_end = min(end_time - start_time, end_seconds - start_time)
-            
-            # Garantir que new_end > new_start
-            if new_end > new_start:
-                filtered_subtitles.append({
-                    'start': new_start,
-                    'end': new_end,
-                    'text': text.strip()
-                })
-    
-    # Gerar SRT cortado
-    srt_cut = ""
-    for i, sub in enumerate(filtered_subtitles, 1):
-        start_srt = seconds_to_srt_time(sub['start'])
-        end_srt = seconds_to_srt_time(sub['end'])
-        srt_cut += f"{i}\n{start_srt} --> {end_srt}\n{sub['text']}\n\n"
-    
-    return srt_cut.strip()
-
-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()
-
-def download_file_with_retry(url: str, max_retries: int = 3, timeout: int = 300):
-    """
-    Baixa arquivo com retry logic e tratamento de rate limiting.
-    
-    Parâmetros:
-    - url: URL do arquivo
-    - max_retries: Número máximo de tentativas
-    - timeout: Timeout em segundos
-    
-    Retorna: Response object do requests
-    """
-    headers = {
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-        'Accept': '*/*',
-        'Accept-Language': 'en-US,en;q=0.9',
-        'Accept-Encoding': 'gzip, deflate, br',
-        'Connection': 'keep-alive',
-        'Upgrade-Insecure-Requests': '1'
+# -*- coding: utf-8 -*-
+from enum import Enum
+
+class Endpoint(Enum):
+    """
+    Enum for Google Gemini API endpoints.
+
+    Attributes:
+        INIT (str): URL for initializing the Gemini session.
+        GENERATE (str): URL for generating chat responses.
+        ROTATE_COOKIES (str): URL for rotating authentication cookies.
+        UPLOAD (str): URL for uploading files/images.
+    """
+    INIT = "https://gemini.google.com/app"
+    GENERATE = "https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate"
+    ROTATE_COOKIES = "https://accounts.google.com/RotateCookies"
+    UPLOAD = "https://content-push.googleapis.com/upload"
+
+class Headers(Enum):
+    """
+    Enum for HTTP headers used in Gemini API requests.
+
+    Attributes:
+        GEMINI (dict): Headers for Gemini chat requests.
+        ROTATE_COOKIES (dict): Headers for rotating cookies.
+        UPLOAD (dict): Headers for file/image upload.
+    """
+    GEMINI = {
+        "Content-Type": "application/x-www-form-urlencoded;charset=utf-8",
+        "Host": "gemini.google.com",
+        "Origin": "https://gemini.google.com",
+        "Referer": "https://gemini.google.com/",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:146.0) Gecko/20100101 Firefox/146.0",
+        "Accept": "*/*",
+        "Accept-Language": "pt-BR,pt;q=0.8,en-US;q=0.5,en;q=0.3",
+        "Accept-Encoding": "gzip, deflate, br, zstd",
+        "X-Same-Domain": "1",
+        "Alt-Used": "gemini.google.com",
+        "Connection": "keep-alive",
+        "Sec-Fetch-Dest": "empty",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Site": "same-origin",
+        "TE": "trailers",
+    }
+    ROTATE_COOKIES = {
+        "Content-Type": "application/json",
     }
-    
-    for attempt in range(max_retries):
-        try:
-            if attempt > 0:
-                # Backoff exponencial: 2^attempt segundos
-                wait_time = 2 ** attempt
-                print(f"⏳ Aguardando {wait_time}s antes de tentar novamente (tentativa {attempt + 1}/{max_retries})...")
-                time.sleep(wait_time)
-            
-            print(f"📥 Tentativa {attempt + 1}/{max_retries} - Baixando arquivo de: {url}")
-            response = requests.get(url, headers=headers, timeout=timeout, stream=True)
-            
-            # Tratar erro 429 (Too Many Requests)
-            if response.status_code == 429:
-                retry_after = response.headers.get('Retry-After')
-                if retry_after:
-                    wait_time = int(retry_after)
-                    print(f"⚠️ Rate limit atingido. Aguardando {wait_time}s conforme Retry-After header...")
-                    time.sleep(wait_time)
-                elif attempt < max_retries - 1:
-                    # Se não houver Retry-After, usar backoff exponencial
-                    wait_time = (2 ** attempt) * 5  # 5s, 10s, 20s...
-                    print(f"⚠️ Rate limit atingido. Aguardando {wait_time}s antes de tentar novamente...")
-                    time.sleep(wait_time)
-                    continue
-                else:
-                    raise HTTPException(
-                        status_code=429,
-                        detail=f"Rate limit atingido após {max_retries} tentativas. Tente novamente mais tarde."
-                    )
-            
-            response.raise_for_status()
-            return response
-            
-        except requests.exceptions.HTTPError as e:
-            if e.response.status_code == 429 and attempt < max_retries - 1:
-                continue
-            elif attempt == max_retries - 1:
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"Erro ao baixar arquivo após {max_retries} tentativas: {str(e)}"
-                )
-            else:
-                raise
-        except requests.exceptions.RequestException as e:
-            if attempt == max_retries - 1:
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"Erro ao baixar arquivo após {max_retries} tentativas: {str(e)}"
-                )
-            continue
-    
-    raise HTTPException(
-        status_code=400,
-        detail=f"Falha ao baixar arquivo após {max_retries} tentativas"
+    UPLOAD = {"Push-ID": "feeds/mcudyrk2a4khkz"}
+
+class Model(Enum):
+    """
+    Enum for available Gemini model configurations.
+
+    Attributes:
+        model_name (str): Name of the model.
+        model_header (dict): Additional headers required for the model.
+        advanced_only (bool): Whether the model is available only for advanced users.
+    """
+    # Updated model definitions based on reference implementation
+    UNSPECIFIED = ("unspecified", {}, False)
+    # Gemini 3 Models (using headers provided by user)
+    G_3_0_FLASH = (
+        "gemini-3.0-flash",
+        {
+            "x-goog-ext-525001261-jspb": '[1,null,null,null,"fbb127bbb056c959",null,null,0,[4],null,null,1]',
+            "x-goog-ext-73010989-jspb": '[0]',
+            "x-goog-ext-525005358-jspb": '["F6E300D3-4DBF-4D05-AC9C-78D136AE9E57",1]',
+        },
+        False,
+    )
+    G_3_0_THINKING = (
+        "gemini-3.0-thinking",
+        {
+            "x-goog-ext-525001261-jspb": '[1,null,null,null,"5bf011840784117a",null,null,0,[4],null,null,1]',
+            "x-goog-ext-73010989-jspb": '[0]',
+            "x-goog-ext-525005358-jspb": '["C6F85698-B8D9-4901-B43A-E3990ACF38B7",1]',
+        },
+        False,
     )
 
-class ChatRequest(BaseModel):
-    message: str
-    context: Optional[str] = None
-    model: Optional[str] = "flash" # 'flash' or 'thinking'
-
-@app.post("/chat")
-async def chat_endpoint(request: ChatRequest):
-    """
-    Endpoint para conversas de texto simples.
-    """
-    if not chatbots:
-        raise HTTPException(status_code=500, detail="Chatbot não inicializado")
-    
-    try:
-        requested_model = request.model.lower() if request.model else "flash"
-        if "thinking" in requested_model:
-            selected_chatbot = chatbots.get('thinking', chatbots['default'])
-        else:
-            selected_chatbot = chatbots.get('flash', chatbots['default'])
-
-        prompt = request.message
-        if request.context:
-            prompt = f"Contexto: {request.context}\n\nMensagem: {request.message}"
-            
-        print(f"💬 Chat request ({requested_model}): {prompt[:50]}...")
-        response_gemini = await selected_chatbot.ask(prompt)
-        
-        if response_gemini.get("error"):
-            raise HTTPException(
-                status_code=500,
-                detail=f"Erro no Gemini: {response_gemini.get('content', 'Erro desconhecido')}"
-            )
-            
-        return {"response": response_gemini.get("content", "")}
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.get("/subtitle")
-async def generate_subtitle(
-    file: str,
-    context: Optional[str] = None,
-    start: Optional[float] = None,
-    end: Optional[float] = None,
-    model: Optional[str] = "flash" # 'flash' or 'thinking'
-):
-    """
-    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
-    - start: Tempo de início para cortar legendas (em segundos)
-    - end: Tempo de fim para cortar legendas (em segundos)
-    
-    Retorna:
-    - Arquivo SRT formatado (cortado se start e end forem fornecidos)
-    """
-    if not chatbots:
-        raise HTTPException(status_code=500, detail="Chatbot não inicializado")
-    
-    requested_model = model.lower() if model else "flash"
-    if "thinking" in requested_model:
-        selected_chatbot = chatbots.get('thinking', chatbots['default'])
-    else:
-        selected_chatbot = chatbots.get('flash', chatbots['default'])
-    
-    if not file:
-        raise HTTPException(status_code=400, detail="Parâmetro 'file' é obrigatório")
-    
-    temp_file = None
-    try:
-        # Baixar arquivo da URL com retry
-        response = download_file_with_retry(file, max_retries=3, timeout=300)
-        
-        # 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 selected_chatbot.ask(full_prompt, image=temp_file.name)
-        elif media_type == 'video':
-            response_gemini = await selected_chatbot.ask(full_prompt, video=temp_file.name)
-        else:  # audio
-            response_gemini = await selected_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"
-            )
-        
-        # Aplicar corte de legendas se start e end forem fornecidos
-        if start is not None and end is not None:
-            print(f"✂️ Cortando legendas: {start}s - {end}s")
-            srt_cleaned = cut_srt_by_time(srt_cleaned, start, end)
-            if not srt_cleaned or len(srt_cleaned.strip()) < 10:
-                raise HTTPException(
-                    status_code=500,
-                    detail="Nenhuma legenda encontrada no intervalo especificado"
-                )
-        
-        # Retornar SRT em JSON
-        return JSONResponse(
-            content={
-                "srt": srt_cleaned,
-                "success": True,
-                "media_type": media_type
-            }
-        )
-        
-    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
-
-
-def flip_image_both_axes(image_path: str) -> str:
-    """
-    Inverte uma imagem horizontalmente e verticalmente.
-    Usa compressão JPEG com qualidade 90 e subsampling 4:2:0 para alterar 
-    o fingerprint da imagem e evitar detecção de figuras públicas.
-    Retorna o caminho para um novo arquivo temporário com a imagem invertida.
-    """
-    with Image.open(image_path) as img:
-        # Inverter horizontalmente e verticalmente
-        flipped = img.transpose(Image.FLIP_LEFT_RIGHT).transpose(Image.FLIP_TOP_BOTTOM)
-        
-        # Determinar extensão e formato
-        suffix = Path(image_path).suffix.lower()
-        if suffix in ['.jpg', '.jpeg']:
-            out_suffix = '.jpg'
-        else:
-            out_suffix = suffix
-        
-        # Salvar em arquivo temporário
-        temp_flipped = tempfile.NamedTemporaryFile(delete=False, suffix=out_suffix)
-        temp_flipped.close()
-        
-        # Salvar com parâmetros específicos para alterar fingerprint
-        if out_suffix in ['.jpg', '.jpeg']:
-            # Usar qualidade 90 e subsampling 4:2:0 (como o Figma faz)
-            # Isso altera os artefatos de compressão JPEG
-            flipped.save(
-                temp_flipped.name, 
-                format='JPEG',
-                quality=90,
-                subsampling='4:2:0',  # Chroma subsampling diferente
-                optimize=True
-            )
-        else:
-            flipped.save(temp_flipped.name)
-        
-        return temp_flipped.name
-
-
-def flip_base64_image_both_axes(img_base64: str, content_type: str) -> str:
-    """
-    Inverte uma imagem base64 horizontalmente e verticalmente.
-    Usa compressão JPEG com qualidade 90 para alterar o fingerprint.
-    Retorna o base64 da imagem invertida.
-    """
-    # Decodificar base64 para bytes
-    img_bytes = base64.b64decode(img_base64)
-    
-    # Abrir imagem dos bytes
-    with Image.open(io.BytesIO(img_bytes)) as img:
-        # Inverter horizontalmente e verticalmente
-        flipped = img.transpose(Image.FLIP_LEFT_RIGHT).transpose(Image.FLIP_TOP_BOTTOM)
-        
-        # Salvar em buffer
-        buffer = io.BytesIO()
-        
-        # Determinar formato baseado no content_type
-        if 'jpeg' in content_type or 'jpg' in content_type:
-            # Usar qualidade 90 e subsampling 4:2:0 para alterar fingerprint
-            flipped.save(
-                buffer, 
-                format='JPEG',
-                quality=90,
-                subsampling='4:2:0',
-                optimize=True
-            )
-        elif 'webp' in content_type:
-            flipped.save(buffer, format='WEBP', quality=90)
-        else:
-            flipped.save(buffer, format='PNG')
-        
-        buffer.seek(0)
-        
-        # Converter de volta para base64
-        return base64.b64encode(buffer.read()).decode('utf-8')
-
-
-async def _try_upscale(chatbot, image_path: str, prompt: str):
-    """
-    Tenta fazer upscale de uma imagem.
-    Retorna (result, upscaled_url) ou (None, None) em caso de erro.
-    """
-    result = await chatbot.ask(prompt, image=image_path)
-    
-    if result.get("error"):
-        return None, None
-    
-    upscaled_url = None
-    if result.get("images"):
-        # Preferir imagens geradas
-        for img in result["images"]:
-            if "[Generated Image" in img.get("title", ""):
-                upscaled_url = img["url"]
-                break
-        
-        # Se não achou 'Generated Image', pega a última
-        if not upscaled_url and len(result["images"]) > 0:
-            upscaled_url = result["images"][-1]["url"]
-    
-    return result, upscaled_url
-
-
-async def _download_upscaled_image(upscaled_url: str, cookies_dict: dict) -> tuple:
-    """
-    Baixa a imagem upscaled e retorna (img_base64, content_type, download_url).
-    """
-    print(f"📥 Resolvendo redirect da URL...")
-    
-    # Primeira requisição: seguir redirect para obter URL final COM cookies
-    redirect_response = requests.get(upscaled_url, timeout=60, allow_redirects=True, 
-        cookies=cookies_dict,
-        headers={
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
-            'Referer': 'https://gemini.google.com/',
-            'Accept': 'image/*,*/*'
-        }
+    # Legacy / Aliases (using same confirmed headers for robust fallback)
+    G_2_0_FLASH = (
+        "gemini-2.0-flash",
+        {
+            "x-goog-ext-525001261-jspb": '[1,null,null,null,"fbb127bbb056c959",null,null,0,[4],null,null,1]',
+            "x-goog-ext-73010989-jspb": '[0]',
+            "x-goog-ext-525005358-jspb": '["F6E300D3-4DBF-4D05-AC9C-78D136AE9E57",1]',
+        },
+        False,
     )
-    
-    # A URL final após redirect
-    final_url = redirect_response.url
-    print(f"📍 URL após redirect: {final_url[:80]}...")
-    
-    # Remover parâmetros existentes e adicionar =s0-d-I para full resolution
-    if "?" in final_url:
-        final_url = final_url.split("?")[0]
-    # Remover qualquer =sXXX existente
-    if "=s" in final_url:
-        final_url = final_url.rsplit("=s", 1)[0]
-    
-    download_url = final_url + "=s0-d-I"
-    print(f"📥 Baixando imagem full res de: {download_url[:80]}...")
-    
-    # Segunda requisição: baixar a imagem em full resolution COM cookies
-    img_response = requests.get(download_url, timeout=60, 
-        cookies=cookies_dict,
-        headers={
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
-            'Referer': 'https://gemini.google.com/',
-            'Accept': 'image/*,*/*'
-        }
+    G_2_0_FLASH_THINKING = (
+        "gemini-2.0-flash-thinking",
+        {
+            "x-goog-ext-525001261-jspb": '[1,null,null,null,"5bf011840784117a",null,null,0,[4],null,null,1]',
+            "x-goog-ext-73010989-jspb": '[0]',
+            "x-goog-ext-525005358-jspb": '["C6F85698-B8D9-4901-B43A-E3990ACF38B7",1]',
+        },
+        False,
+    )
+    # Updating 2.5 aliases to also use the working headers to avoid confusion
+    G_2_5_FLASH = (
+        "gemini-2.5-flash",
+        {
+            "x-goog-ext-525001261-jspb": '[1,null,null,null,"fbb127bbb056c959",null,null,0,[4],null,null,1]',
+            "x-goog-ext-73010989-jspb": '[0]',
+            "x-goog-ext-525005358-jspb": '["F6E300D3-4DBF-4D05-AC9C-78D136AE9E57",1]',
+        },
+        False,
+    )
+    G_2_5_PRO = (
+        "gemini-2.5-pro",
+        {"x-goog-ext-525001261-jspb": '[1,null,null,null,"2525e3954d185b3c"]'}, # Keeping original PRO headers as we don't have new ones for Pro specifically, but user uses Flash/Thinking usually.
+        False,
+    )
+    NANO_BANANA = (
+        "gemini-nano", 
+        {
+            "x-goog-ext-525001261-jspb": '[1,null,null,null,"fbb127bbb056c959",null,null,0,[4],null,null,1]',
+            "x-goog-ext-73010989-jspb": '[0]',
+            "x-goog-ext-525005358-jspb": '["F6E300D3-4DBF-4D05-AC9C-78D136AE9E57",1]',
+        },
+        False
     )
-    img_response.raise_for_status()
-    
-    # Converter para base64
-    img_base64 = base64.b64encode(img_response.content).decode('utf-8')
-    content_type = img_response.headers.get('content-type', 'image/png')
-    
-    print(f"✅ Imagem baixada e convertida para base64 ({len(img_base64)} chars)")
-    
-    return img_base64, content_type, download_url
-
-
-@app.get("/upscale")
-async def upscale_image(
-    file: str
-):
-    """
-    Endpoint para fazer upscale 4x de uma imagem usando o Nano Banana Pro.
-    
-    Se a primeira tentativa falhar (ex: erro de figuras públicas), 
-    tenta novamente invertendo a imagem horizontalmente e verticalmente,
-    e depois inverte o resultado de volta.
-    
-    Parâmetros:
-    - file: URL da imagem
-    
-    Retorna:
-    - JSON com a imagem gerada em base64 (upscaled)
-    """
-    if upscale_chatbot is None:
-        raise HTTPException(status_code=500, detail="Upscale Chatbot não inicializado")
-    
-    if not file:
-        raise HTTPException(status_code=400, detail="Parâmetro 'file' é obrigatório")
-    
-    temp_file = None
-    temp_flipped_file = None
-    
-    try:
-        # Baixar arquivo da URL com retry
-        response = download_file_with_retry(file, max_retries=3, timeout=300)
-        
-        # Verificar se é uma imagem
-        content_type = response.headers.get('content-type', '').lower()
-        if 'image' not in content_type and not any(ext in file.lower() for ext in ['.jpg', '.jpeg', '.png', '.webp']):
-             raise HTTPException(status_code=400, detail="O arquivo fornecido não parece ser uma imagem.")
 
-        file_extension = '.jpg' # default
-        if 'png' in content_type: file_extension = '.png'
-        elif 'webp' in content_type: file_extension = '.webp'
-        
-        # 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 para upscale baixado: {temp_file.name}")
-        
-        prompt = "Upscale this image by 4x. Keep everything exactly as it is, including text, colors, texture, aspect ratio, zoom and proportions. Just increase the quality and sharpness. Do not add any new elements or modify the composition"
-        
-        # Carregar cookies para download
-        cookies_dict = {}
-        cookie_path = os.getenv("COOKIE_PATH", "cookies.json")
-        try:
-            secure_1psid, secure_1psidts, additional_cookies = load_cookies(cookie_path)
-            cookies_dict = additional_cookies.copy()
-            cookies_dict['__Secure-1PSID'] = secure_1psid
-            cookies_dict['__Secure-1PSIDTS'] = secure_1psidts
-            print(f"✅ {len(cookies_dict)} cookies carregados para download")
-        except Exception as cookie_err:
-            print(f"⚠️ Aviso: Não foi possível carregar cookies: {cookie_err}")
-        
-        # ========== PRIMEIRA TENTATIVA: Normal ==========
-        print(f"🧠 [Tentativa 1] Enviando imagem para upscale...")
-        result, upscaled_url = await _try_upscale(upscale_chatbot, temp_file.name, prompt)
-        
-        used_flip_workaround = False
-        
-        if result is None or upscaled_url is None:
-            # ========== SEGUNDA TENTATIVA: Inverter imagem ==========
-            print(f"⚠️ Primeira tentativa falhou. Tentando workaround de inversão...")
-            
-            # Inverter a imagem horizontalmente e verticalmente
-            print(f"🔄 Invertendo imagem (horizontal + vertical)...")
-            temp_flipped_file = flip_image_both_axes(temp_file.name)
-            print(f"✅ Imagem invertida salva em: {temp_flipped_file}")
-            
-            # Tentar novamente com a imagem invertida
-            print(f"🧠 [Tentativa 2] Enviando imagem INVERTIDA para upscale...")
-            result, upscaled_url = await _try_upscale(upscale_chatbot, temp_flipped_file, prompt)
-            
-            if result is None or upscaled_url is None:
-                raise HTTPException(
-                    status_code=500,
-                    detail="Nenhuma imagem de upscale foi retornada pelo modelo após múltiplas tentativas."
-                )
-            
-            used_flip_workaround = True
-            print(f"✅ Segunda tentativa (com inversão) funcionou!")
-        
-        # Baixar imagem upscaled
-        try:
-            img_base64, img_content_type, download_url = await _download_upscaled_image(upscaled_url, cookies_dict)
-        except Exception as download_error:
-            print(f"❌ Erro ao baixar imagem: {download_error}")
-            raise HTTPException(
-                status_code=500,
-                detail=f"Erro ao baixar imagem upscaled: {str(download_error)}"
-            )
-        
-        # Se usamos o workaround de inversão, precisamos inverter o resultado de volta
-        if used_flip_workaround:
-            print(f"🔄 Invertendo resultado de volta (restaurando orientação original)...")
-            img_base64 = flip_base64_image_both_axes(img_base64, img_content_type)
-            print(f"✅ Imagem restaurada para orientação original")
-            
-        return JSONResponse(
-            content={
-                "image_base64": img_base64,
-                "content_type": img_content_type,
-                "success": True,
-                "original_url": file,
-                "upscaled_url": download_url,
-                "used_flip_workaround": used_flip_workaround
-            }
-        )
 
-    except HTTPException:
-        raise
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Erro interno no upscale: {str(e)}")
-    finally:
-        # Limpar arquivos temporários
-        if temp_file and os.path.exists(temp_file.name):
-            try:
-                os.unlink(temp_file.name)
-            except:
-                pass
-        if temp_flipped_file and os.path.exists(temp_flipped_file):
-            try:
-                os.unlink(temp_flipped_file)
-            except:
-                pass
+    def __init__(self, name, header, advanced_only):
+        """
+        Initialize a Model enum member.
+
+        Args:
+            name (str): Model name.
+            header (dict): Model-specific headers.
+            advanced_only (bool): If True, model is for advanced users only.
+        """
+        self.model_name = name
+        self.model_header = header
+        self.advanced_only = advanced_only
+
+    @classmethod
+    def from_name(cls, name: str):
+        """
+        Get a Model enum member by its model name.
+
+        Args:
+            name (str): Name of the model.
+
+        Returns:
+            Model: Corresponding Model enum member.
+
+        Raises:
+            ValueError: If the model name is not found.
+        """
+        for model in cls:
+            if model.model_name == name:
+                return model
+        raise ValueError(
+            f"Unknown model name: {name}. Available models: {', '.join([model.model_name for model in cls])}"
+        )