Update app.py

app.py

@@ -1,16 +1,13 @@
-from fastapi import FastAPI, HTTPException, File, UploadFile, Form
-from fastapi.responses import Response, JSONResponse
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import 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
-from curl_cffi.requests import AsyncSession
+from gemini_client import AsyncChatbot, Model, load_cookies
 
 app = FastAPI(title="Gemini Chat API", description="API para interagir com Google Gemini")
 
@@ -76,6 +73,72 @@ 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:
@@ -150,7 +213,9 @@ def clean_and_validate_srt(srt_content):
 @app.get("/subtitle")
 async def generate_subtitle(
     file: str,
-    context: Optional[str] = None
+    context: Optional[str] = None,
+    start: Optional[float] = None,
+    end: Optional[float] = None
 ):
     """
     Endpoint para gerar legendas SRT a partir de um arquivo (imagem, vídeo ou áudio).
@@ -158,9 +223,11 @@ async def generate_subtitle(
     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
+    - Arquivo SRT formatado (cortado se start e end forem fornecidos)
     """
     if chatbot is None:
         raise HTTPException(status_code=500, detail="Chatbot não inicializado")
@@ -369,6 +436,16 @@ TRADUZA TUDO DE IMPORTANTE NO {media_desc_final}, que tenha dialogo... Nunca dei
                 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={
@@ -384,174 +461,6 @@ TRADUZA TUDO DE IMPORTANTE NO {media_desc_final}, que tenha dialogo... Nunca dei
         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,
-    model: Optional[str] = None
-):
-    """
-    Endpoint GET para obter resposta do Gemini.
-    
-    Parâmetros:
-    - message: A mensagem para enviar ao Gemini
-    - model: Modelo opcional (padrão: G_2_5_PRO)
-    
-    Retorna JSON com:
-    - content: Resposta do Gemini
-    - model: Modelo utilizado
-    - error: Se houve erro
-    """
-    if chatbot is None:
-        raise HTTPException(status_code=500, detail="Chatbot não inicializado")
-    
-    try:
-        # Selecionar modelo se especificado (usa o padrão por enquanto)
-        selected_model = Model.G_2_5_PRO  # Padrão
-        if model:
-            try:
-                # Validar modelo, mas usar o padrão por enquanto
-                Model.from_name(model)
-            except ValueError:
-                return JSONResponse(
-                    status_code=400,
-                    content={
-                        "error": True,
-                        "content": f"Modelo inválido: {model}",
-                        "model": None
-                    }
-                )
-        
-        # Enviar mensagem (assíncrono)
-        response = await chatbot.ask(message)
-        
-        # Retornar resposta formatada
-        return {
-            "content": response.get("content", ""),
-            "model": response.get("model", selected_model.model_name),
-            "error": response.get("error", False)
-        }
-    except Exception as e:
-        return JSONResponse(
-            status_code=500,
-            content={
-                "error": True,
-                "content": f"Erro ao processar requisição: {str(e)}",
-                "model": None
-            }
-        )
-
-@app.post("/get")
-async def post_response(
-    message: str = Form(...),
-    image: Optional[UploadFile] = File(None),
-    video: Optional[UploadFile] = File(None),
-    audio: Optional[UploadFile] = File(None),
-    model: Optional[str] = Form(None)
-):
-    """
-    Endpoint POST para obter resposta do Gemini com suporte a mídia.
-    
-    Parâmetros:
-    - message: A mensagem para enviar ao Gemini (obrigatório)
-    - image: Arquivo de imagem opcional
-    - video: Arquivo de vídeo opcional
-    - audio: Arquivo de áudio opcional
-    - model: Modelo opcional (padrão: G_2_5_PRO)
-    
-    Retorna JSON com:
-    - content: Resposta do Gemini
-    - model: Modelo utilizado
-    - error: Se houve erro
-    """
-    if chatbot is None:
-        raise HTTPException(status_code=500, detail="Chatbot não inicializado")
-    
-    # Validar que apenas um tipo de mídia é enviado
-    media_count = sum([image is not None, video is not None, audio is not None])
-    if media_count > 1:
-        return JSONResponse(
-            status_code=400,
-            content={
-                "error": True,
-                "content": "Apenas um tipo de mídia pode ser enviado por vez (image, video ou audio)",
-                "model": None
-            }
-        )
-    
-    temp_file = None
-    try:
-        # Selecionar modelo se especificado (usa o padrão por enquanto)
-        selected_model = Model.G_2_5_PRO  # Padrão
-        if model:
-            try:
-                # Validar modelo, mas usar o padrão por enquanto
-                Model.from_name(model)
-            except ValueError:
-                return JSONResponse(
-                    status_code=400,
-                    content={
-                        "error": True,
-                        "content": f"Modelo inválido: {model}",
-                        "model": None
-                    }
-                )
-        
-        # Processar mídia se fornecida
-        media_path = None
-        if image:
-            # Salvar imagem temporariamente
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=Path(image.filename).suffix if image.filename else ".jpg")
-            content = await image.read()
-            temp_file.write(content)
-            temp_file.close()
-            media_path = temp_file.name
-            
-            response = await chatbot.ask(message, image=media_path)
-        elif video:
-            # Salvar vídeo temporariamente
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=Path(video.filename).suffix if video.filename else ".mp4")
-            content = await video.read()
-            temp_file.write(content)
-            temp_file.close()
-            media_path = temp_file.name
-            
-            response = await chatbot.ask(message, video=media_path)
-        elif audio:
-            # Salvar áudio temporariamente
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=Path(audio.filename).suffix if audio.filename else ".mp3")
-            content = await audio.read()
-            temp_file.write(content)
-            temp_file.close()
-            media_path = temp_file.name
-            
-            response = await chatbot.ask(message, audio=media_path)
-        else:
-            # Apenas texto
-            response = await chatbot.ask(message)
-        
-        # Retornar resposta formatada
-        return {
-            "content": response.get("content", ""),
-            "model": response.get("model", selected_model.model_name),
-            "error": response.get("error", False)
-        }
-    except Exception as e:
-        return JSONResponse(
-            status_code=500,
-            content={
-                "error": True,
-                "content": f"Erro ao processar requisição: {str(e)}",
-                "model": None
-            }
-        )
     finally:
         # Limpar arquivo temporário
         if temp_file and os.path.exists(temp_file.name):