Update app.py

app.py

@@ -700,6 +700,129 @@ Deve ter parametro start e end, e cortar o vídeo enviado nesse tempo. Pra anali
             except: pass
 
 
+class GenerateElementsRequest(BaseModel):
+    video_url: str
+    context: Optional[str] = None
+    start: Optional[str] = None
+    end: Optional[str] = None
+    model: Optional[str] = "flash"
+
+
+@app.post("/generate-elements")
+async def generate_elements_endpoint(request: GenerateElementsRequest):
+    """
+    Gera elementos a partir de um vídeo (ou trecho dele).
+    Duplicação do generate-titles para personalização futura do prompt.
+    """
+    if not chatbots:
+        raise HTTPException(status_code=500, detail="Chatbot não inicializado")
+
+    temp_file = None
+    cut_file = None
+
+    try:
+        # 1. Validar e Baixar Vídeo
+        if not request.video_url:
+            raise HTTPException(status_code=400, detail="URL do vídeo é obrigatória")
+
+        print(f"📥 [GenerateElements] Baixando vídeo: {request.video_url}")
+        
+        # Baixar direto para um arquivo temporário
+        response = download_file_with_retry(request.video_url, timeout=600)
+        
+        content_type = response.headers.get('content-type', '').lower()
+        ext = '.mp4' 
+        if 'webm' in content_type: ext = '.webm'
+        elif 'mkv' in content_type: ext = '.mkv'
+        
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=ext)
+        for chunk in response.iter_content(chunk_size=1024*1024):
+            if chunk:
+                temp_file.write(chunk)
+        temp_file.close()
+
+        video_path_to_analyze = temp_file.name
+
+        # 2. Cortar Vídeo se necessário
+        if request.start and request.end:
+            print(f"✂️ [GenerateElements] Cortando vídeo de {request.start} até {request.end}...")
+            cut_file = tempfile.NamedTemporaryFile(delete=False, suffix=ext)
+            cut_file.close()
+            
+            success = cut_video(temp_file.name, cut_file.name, request.start, request.end)
+            if success:
+                video_path_to_analyze = cut_file.name
+                print(f"✅ Vídeo cortado: {video_path_to_analyze}")
+            else:
+                print("⚠️ Falha ao cortar vídeo, usando original.")
+
+        # 3. Preparar Prompt
+        contexto_add = f"\n{request.context}" if request.context else ""
+        
+        prompt = f"""Analise essa notícia e o vídeo:
+
+{contexto_add}
+
+Com base nela, gere titulos de notícias que podem ser extraidos do vídeo/notícia. Títulos de notícias.
+
+Exemplos:
+
+[
+  {{"title":"Trump repreende repórter da CNN por não sorrir"}},
+  {{"title":"Duas semanas de fortes nevascas causam caos no Japão"}},
+  {{"title":"Nova divulgação de arquivos sobre Jeffrey Epstein revela ligações com homens influentes"}},
+  {{"title":"Trump anuncia fechamento do Kennedy Center em julho para reforma de dois anos"}},
+  {{"title":"Como tecnologia de guerra foi usada em Minneapolis"}},
+  {{"title":"Trump diz ter alcançado base de acordo com a Otan sobre a Groenlândia"}},
+  {{"title":"Trump anuncia tarifas contra oito países europeus para forçar venda da Groenlândia"}},
+  {{"title":"Trump tem muitas opções para lidar com o Irã, diz porta-voz"}}
+]
+
+Mande apenas os títulos, em forma JSON. Sem texto adicional. Deve analisar todo o contexto do vídeo e verificar qual o melhor título. O título deve ser sólido, evitar emojis, dois pontos, etc. O estilo dos títulos devem ser parecidos com o JSON.
+
+Deve ter parametro start e end, e cortar o vídeo enviado nesse tempo. Pra analisar corretamente apenas a parte que o usuário quer. Considere que o jornal é imparcial na apresentação dos fatos, mas possui uma inclinação editorial claramente mais conservadora, republicana e de direita na entonação. Adapte os títulos de acordo com esse posicionamento, mantendo rigor factual e linguagem jornalística."""
+
+        # 4. Enviar para o Gemini
+        model_name = request.model or "flash"
+        chatbot = chatbots.get(model_name, chatbots.get('flash', chatbots['default']))
+        
+        print(f"🧠 [GenerateElements] Enviando para Gemini ({model_name})...")
+        
+        response_gemini = await chatbot.ask(prompt, video=video_path_to_analyze)
+        
+        if response_gemini.get("error"):
+            raise HTTPException(status_code=500, detail=f"Erro no Gemini: {response_gemini.get('content')}")
+            
+        content = response_gemini.get("content", "")
+        print(f"✅ Resposta recebida ({len(content)} chars)")
+        
+        # 5. Processar Resposta
+        titles_data = extract_json_from_text(content)
+        
+        if not titles_data:
+            print(f"⚠️ Falha ao extrair JSON. Conteúdo bruto: {content[:200]}...")
+            return JSONResponse(content={"raw_content": content, "error": "Failed to parse JSON"}, status_code=200)
+
+        return titles_data
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Erro interno: {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 cut_file and os.path.exists(cut_file.name):
+            try:
+                os.unlink(cut_file.name)
+            except: pass
+
+
 
 
 def flip_image_both_axes(image_path: str) -> str:
@@ -1289,7 +1412,7 @@ INSTRUÇÕES/CONTEXTO DO USUÁRIO: {processed_context}
             # But wait, did we shift srt_filtered before sending to Gemini?
             # NO. srt_filtered is 0-based.
             # So send 0-based to Gemini. Gemini returns 0-based.
-            # We shift cleaned_srt.v
+            # We shift cleaned_srt.
             # Optionally shift original_srt for reference
             srt_filtered = shift_srt_timestamps(srt_filtered, request.time_start)
         
@@ -1302,330 +1425,4 @@ INSTRUÇÕES/CONTEXTO DO USUÁRIO: {processed_context}
     except Exception as e:
         import traceback
         traceback.print_exc()
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-class GenerateElementsRequest(BaseModel):
-    video_url: str
-    context: Optional[str] = None
-    start: Optional[str] = None
-    end: Optional[str] = None
-    model: Optional[str] = "flash"
-
-
-@app.post("/generate-elements")
-async def generate_elements_endpoint(request: GenerateElementsRequest):
-    """
-    Gera elementos estruturados (título, nomes, metadados, descrição) para linha do tempo de vídeo.
-    """
-    if not chatbots:
-        raise HTTPException(status_code=500, detail="Chatbot não inicializado")
-
-    temp_file = None
-    cut_file = None
-
-    try:
-        # 1. Validar e Baixar Vídeo
-        if not request.video_url:
-            raise HTTPException(status_code=400, detail="URL do vídeo é obrigatória")
-
-        print(f"📥 [GenerateElements] Baixando vídeo: {request.video_url}")
-        
-        response = download_file_with_retry(request.video_url, timeout=600)
-        
-        content_type = response.headers.get('content-type', '').lower()
-        ext = '.mp4' 
-        if 'webm' in content_type: ext = '.webm'
-        elif 'mkv' in content_type: ext = '.mkv'
-        
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=ext)
-        for chunk in response.iter_content(chunk_size=1024*1024):
-            if chunk:
-                temp_file.write(chunk)
-        temp_file.close()
-
-        video_path_to_analyze = temp_file.name
-
-        # 2. Cortar Vídeo
-        if request.start and request.end:
-            print(f"✂️ [GenerateElements] Cortando vídeo de {request.start} até {request.end}...")
-            cut_file = tempfile.NamedTemporaryFile(delete=False, suffix=ext)
-            cut_file.close()
-            
-            success = cut_video(temp_file.name, cut_file.name, request.start, request.end)
-            if success:
-                video_path_to_analyze = cut_file.name
-                print(f"✅ Vídeo cortado: {video_path_to_analyze}")
-            else:
-                print("⚠️ Falha ao cortar vídeo, usando original.")
-
-        # 3. Preparar Prompt
-        contexto_add = f"\\n{request.context}" if request.context else ""
-        
-        prompt = f"""Analise essa notícia e o vídeo:
-
-{contexto_add}
-
-Analise uma notícia e seu contexto ampliado na internet, extraindo dados factuais, contexto editorial e informações complementares que ajudem a compor a narrativa jornalística. A partir dessa análise, gere exclusivamente um JSON estruturado com elementos pensados para inserção em uma linha do tempo de vídeo.
-
-Retorne apenas JSON válido, sem comentários, explicações ou formatação adicional.
-RETORNE APENAS O JSON VÁLIDO. NÃO INCLUA NENHUM TEXTO ANTES OU DEPOIS DO JSON. NÃO USE TAGS MARKDOWN ```json. APENAS O JSON RAW.
-O JSON deve ser uma lista contendo uma lista ordenada de elementos, respeitando rigorosamente a ordem de exibição no vídeo.
-
-Cada elemento deve conter obrigatoriamente:
-- type: tipo do elemento
-- start: tempo de início no vídeo (MM:SS)
-- end: tempo de término no vídeo (MM:SS)
-
-Tipos de elementos permitidos:
-
-1) title
-- type: "title"
-- text: título contextualizado da notícia, traduzido para português do Brasil
-- Duração máxima: 5 segundos
-
-2) name
-- type: "name"
-- name: nome da pessoa
-- profession: profissão ou cargo, traduzido para português do Brasil
-- Duração máxima: 5 segundos
-
-3) metadata
-- type: "metadata"
-- Pode conter um ou mais dos seguintes campos:
-  - date: data no formato ISO (YYYY-MM-DD)
-  - location: local traduzido para português do Brasil
-  - credits: créditos da imagem ou vídeo, se disponíveis
-- Deve começar exatamente no mesmo start do elemento imediatamente abaixo
-- Duração máxima: 5 segundos
-
-4) description
-- type: "description"
-- text: texto descritivo que explica fatos, contexto ou desdobramentos da notícia
-- A duração deve ser calculada com base no tamanho do texto
-- Ritmo recomendado de leitura: entre 12 e 15 caracteres por segundo
-- Evitar tempos longos para textos curtos
-
-Regras de tempo:
-- Os tempos devem ser sequenciais e coerentes
-- title, name e metadata nunca devem ultrapassar 5 segundos
-- description deve ter duração proporcional ao tamanho do texto
-- Metadata sempre deve começar exatamente junto com o elemento logo abaixo
-
-Contexto editorial:
-- Considere informações relevantes disponíveis em fontes confiáveis
-- Inclua contexto quando isso enriquecer a compreensão da notícia
-- Priorize clareza, concisão e linguagem jornalística, no estilo The New York Times.
-- Todo o conteúdo textual deve estar em português do Brasil
-- Considere que o jornal é imparcial na apresentação dos fatos, mas possui uma inclinação editorial claramente mais conservadora, republicana e de direita na entonação. Adapte os títulos e descrições de acordo com esse posicionamento, mantendo rigor factual e linguagem jornalística.
-
-# EXEMPLO ESPERADO 1:
-
-[
-      {{
-        "type": "title",
-        "start": "00:00",
-        "end": "00:05",
-        "text": "A mãe de Savannah Guthrie, apresentadora do programa 'Today', foi levada 'contra a própria vontade', segundo as autoridades."
-      }},
-      {{
-        "type": "name",
-        "start": "00:05",
-        "end": "00:10",
-        "name": "Chris Nanos",
-        "profession": "Xerife do Condado de Pima"
-      }},
-      {{
-        "type": "metadata",
-        "start": "00:10",
-        "end": "00:15",
-        "date": "2023-03-15",
-        "credits": "Nathan Congleton/NBC, via Getty Images"
-      }},
-      {{
-        "type": "description",
-        "start": "00:10",
-        "end": "00:22",
-        "text": "As autoridades informaram que o desaparecimento de Nancy Guthrie, de 84 anos, estava sendo tratado como um sequestro."
-      }},
-      {{
-        "type": "description",
-        "start": "00:22",
-        "end": "00:28",
-        "text": "Segundo o xerife, Guthrie foi vista pela última vez em sua casa, em Tucson, no sábado."
-      }},
-      {{
-        "type": "metadata",
-        "start": "00:28",
-        "end": "00:33",
-        "location": "Sydney, Austrália",
-        "date": "2015-05-04"
-      }},
-      {{
-        "type": "description",
-        "start": "00:28",
-        "end": "00:40",
-        "text": "O xerife afirmou que ela tinha limitações físicas, mas que o caso não estava relacionado à demência."
-      }},
-      {{
-        "type": "metadata",
-        "start": "00:40",
-        "end": "00:45",
-        "location": "Tucson, Arizona",
-        "date": "2026-02-02"
-      }}
-    ]
-
-# EXEMPLO ESPERADO 2
-
-[
-      {{
-        "type": "metadata",
-        "start": "00:00",
-        "end": "00:05",
-        "location": "Paramount, Califórnia",
-        "date": "2025-07-05"
-      }},
-      {{
-        "type": "title",
-        "start": "00:00",
-        "end": "00:05",
-        "text": "Este vídeo mostra o agente da Patrulha de Fronteira Gregory Bovino dando instruções a agentes federais."
-      }},
-      {{
-        "type": "description",
-        "start": "00:05",
-        "end": "00:20",
-        "text": "O momento foi registrado no verão passado, em Los Angeles, quando a repressão à imigração começou a se intensificar."
-      }},
-      {{
-        "type": "description",
-        "start": "00:20",
-        "end": "00:30",
-        "text": "O vídeo voltou a circular nesta semana após Bovino ter sido chamado de volta de Minnesota."
-      }},
-      {{
-        "type": "description",
-        "start": "00:30",
-        "end": "00:48",
-        "text": "As imagens foram divulgadas no ano passado como parte de uma ação judicial federal sobre a aplicação das leis de imigração na região de Chicago."
-      }},
-      {{
-        "type": "description",
-        "start": "00:48",
-        "end": "01:08",
-        "text": "Operações de imigração provocaram protestos na região das Cidades Gêmeas depois que dois cidadãos americanos foram mortos a tiros por agentes."
-      }},
-      {{
-        "type": "description",
-        "start": "01:08",
-        "end": "01:18",
-        "text": "O Departamento de Segurança Interna não respondeu imediatamente a um pedido de comentário."
-      }}
-    ]
-"""
-
-        # 4. Enviar para o Gemini
-        model_name = request.model or "flash"
-        chatbot = chatbots.get(model_name, chatbots.get('flash', chatbots['default']))
-        
-        print(f"🧠 [GenerateElements] Enviando para Gemini ({model_name})...")
-        
-        # Implementar Retry logic para o chatbot.ask
-        max_retries = 3
-        response_gemini = None
-        last_error = None
-        
-        for attempt in range(max_retries):
-            try:
-                if attempt > 0:
-                    print(f"🔄 [GenerateElements] Tentativa {attempt+1}/{max_retries}...")
-                    import asyncio
-                    await asyncio.sleep(2 * attempt) # Backoff
-                    
-                response_gemini = await chatbot.ask(prompt, video=video_path_to_analyze)
-                
-                if response_gemini.get("error"):
-                    error_msg = response_gemini.get("content", "")
-                    
-                    # Se for "Gemini API Error", NÃO retentar (a menos que seja um código específico transiente)
-                    if "Gemini API Error" in error_msg:
-                        # ERROR 4 (DEADLINE_EXCEEDED) e ERROR 14 (UNAVAILABLE) podem ser transientes
-                        if "Gemini API Error: 4" in error_msg or "Gemini API Error: 14" in error_msg:
-                             print(f"⚠️ [GenerateElements] Erro transiente da API do Gemini detectado: {error_msg}. Retentando...")
-                             last_error = error_msg
-                             continue
-
-                        print(f"🛑 [GenerateElements] Erro GRAVE da API do Gemini detectado: {error_msg}. Abortando retentativas.")
-                        last_error = error_msg
-                        break # Sai do loop de retentativas
-                        
-                    if "Failed to parse response body" in error_msg or "500" in error_msg:
-                         last_error = error_msg
-                         print(f"⚠️ [GenerateElements] Erro transiente detectado: {error_msg}. Retentando...")
-                         continue
-                    else:
-                        # Erro não transiente (ex: recusa de segurança), não retentar
-                        raise Exception(error_msg)
-                
-                # Sucesso
-                break
-            except Exception as e:
-                last_error = str(e)
-                print(f"⚠️ [GenerateElements] Exceção na tentativa {attempt+1}: {e}")
-                if "Failed to parse response body" in str(e):
-                    continue
-                if "Gemini API Error" in str(e):
-                     print(f"🛑 [GenerateElements] Abortando por erro de API: {e}")
-                     break
-        
-        if response_gemini is None or response_gemini.get("error"):
-            detail = response_gemini.get('content') if response_gemini else str(last_error)
-            
-            # Tentar ler o arquivo de debug se existir
-            debug_content = ""
-            debug_path = "last_gemini_response_debug.txt"
-            if os.path.exists(debug_path):
-                try:
-                    with open(debug_path, "r", encoding="utf-8") as f:
-                        debug_content = f.read()[:10000] # Aumentar limite para 10000 chars
-                        detail += f"\n\n--- DEBUG INFO (RAW GEMINI RESPONSE) ---\n{debug_content}"
-                except Exception as e:
-                    print(f"Erro ao ler arquivo de debug: {e}")
-                    detail += f"\n\n--- DEBUG INFO ---\nErro ao ler arquivo de debug: {e}"
-            else:
-                 detail += f"\n\n--- DEBUG INFO ---\nArquivo de debug não encontrado em {debug_path}"
-            
-            # Print detail to logs for visibility
-            print(f"❌ [GenerateElements] Erro final retornado ao cliente:\n{detail}")
-                
-            raise HTTPException(status_code=500, detail=f"Erro no Gemini após {max_retries} tentativas: {detail}")
-            
-        content = response_gemini.get("content", "")
-        print(f"✅ Resposta recebida ({len(content)} chars)")
-        
-        # 5. Processar Resposta
-        elements_data = extract_json_from_text(content)
-        
-        if not elements_data:
-            print(f"⚠️ Falha ao extrair JSON. Conteúdo bruto: {content[:200]}...")
-            return JSONResponse(content={"raw_content": content, "error": "Failed to parse JSON"}, status_code=200)
-
-        return elements_data
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Erro interno: {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 cut_file and os.path.exists(cut_file.name):
-            try:
-                os.unlink(cut_file.name)
-            except: pass
+        raise HTTPException(status_code=500, detail=str(e))