Upload 13 files

routers/analyze.py

@@ -0,0 +1,509 @@
+import os
+import sys
+import importlib.util
+from pathlib import Path
+import re
+import json
+import time
+import logging
+import gc
+import asyncio
+import aiohttp
+from typing import Optional, Dict, Any
+from fastapi import FastAPI, APIRouter, HTTPException
+from pydantic import BaseModel
+from urllib.parse import quote
+
+# IMPORTANTE: Configurar variáveis de ambiente e PyTorch ANTES de qualquer importação que use PyTorch
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+os.environ["OMP_NUM_THREADS"] = "2"
+os.environ["MKL_NUM_THREADS"] = "2"
+
+# Configurar PyTorch ANTES de importar qualquer módulo que o use
+import torch
+torch.set_num_threads(2)
+
+# Verificar se já foi configurado antes de tentar definir interop threads
+if not hasattr(torch, '_interop_threads_set'):
+    try:
+        torch.set_num_interop_threads(1)
+        torch._interop_threads_set = True
+    except RuntimeError as e:
+        if "cannot set number of interop threads" in str(e):
+            print(f"Warning: Could not set interop threads: {e}")
+        else:
+            raise e
+
+# Supabase Config
+SUPABASE_URL = "https://iiwbixdrrhejkthxygak.supabase.co"
+SUPABASE_KEY = os.getenv("SUPA_KEY")
+SUPABASE_ROLE_KEY = os.getenv("SUPA_SERVICE_KEY")
+if not SUPABASE_KEY or not SUPABASE_ROLE_KEY:
+    raise ValueError("❌ SUPA_KEY or SUPA_SERVICE_KEY not set in environment!")
+SUPABASE_HEADERS = {
+    "apikey": SUPABASE_KEY,
+    "Authorization": f"Bearer {SUPABASE_KEY}",
+    "Content-Type": "application/json"
+}
+SUPABASE_ROLE_HEADERS = {
+    "apikey": SUPABASE_ROLE_KEY,
+    "Authorization": f"Bearer {SUPABASE_ROLE_KEY}",
+    "Content-Type": "application/json"
+}
+
+# Rewrite API URL
+REWRITE_API_URL = "https://habulaj-newapi.hf.space/rewrite-news"
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+log = logging.getLogger("news-analyze-api")
+
+http_session = None
+
+async def get_http_session():
+    global http_session
+    if http_session is None:
+        connector = aiohttp.TCPConnector(
+            limit=20,
+            limit_per_host=10,
+            ttl_dns_cache=300,
+            use_dns_cache=True,
+            keepalive_timeout=30,
+            enable_cleanup_closed=True
+        )
+        timeout = aiohttp.ClientTimeout(total=30, connect=5)
+        http_session = aiohttp.ClientSession(
+            connector=connector,
+            timeout=timeout,
+            headers={'User-Agent': 'NewsAnalyzeAPI/1.0 (https://example.com/contact)'}
+        )
+    return http_session
+
+def load_inference_module():
+    """Carrega o módulo inference.py dinamicamente"""
+    try:
+        # Assumindo que inference.py está no mesmo diretório ou em um caminho conhecido
+        inference_path = Path(__file__).parent / "inference.py"  # Ajuste o caminho conforme necessário
+        
+        if not inference_path.exists():
+            # Tenta outros caminhos possíveis
+            possible_paths = [
+                Path(__file__).parent.parent / "inference.py",
+                Path("./inference.py"),
+                Path("../inference.py")
+            ]
+            
+            for path in possible_paths:
+                if path.exists():
+                    inference_path = path
+                    break
+            else:
+                raise FileNotFoundError("inference.py não encontrado")
+        
+        spec = importlib.util.spec_from_file_location("inference", inference_path)
+        inference_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(inference_module)
+        
+        return inference_module
+    except Exception as e:
+        log.error(f"Erro ao carregar inference.py: {str(e)}")
+        return None
+
+# Carrega o módulo na inicialização
+inference_module = load_inference_module()
+
+async def rewrite_article_direct(content: str) -> Optional[Dict[str, Any]]:
+    """Reescreve o artigo chamando diretamente a função do inference.py"""
+    try:
+        if not inference_module:
+            log.error("Módulo inference não carregado, fallback para API HTTP")
+            return await rewrite_article_http(content)
+        
+        log.info(f"Reescrevendo artigo diretamente: {len(content)} caracteres")
+        
+        # Cria um objeto similar ao NewsRequest
+        class NewsRequest:
+            def __init__(self, content: str):
+                self.content = content
+        
+        news_request = NewsRequest(content)
+        
+        # Chama a função rewrite_news diretamente
+        result = await inference_module.rewrite_news(news_request)
+        
+        # Converte o resultado para dicionário
+        rewritten_data = {
+            "title": result.title,
+            "subhead": result.subhead,
+            "content": result.content,
+            "sources": getattr(result, "sources", [])
+        }
+        
+        # Validação básica da resposta
+        if all(key in rewritten_data and rewritten_data[key].strip() for key in ["title", "subhead", "content"]) and isinstance(rewritten_data["sources"], list):
+            log.info("Artigo reescrito com sucesso (chamada direta)")
+            return {
+                "success": True,
+                "data": rewritten_data,
+                "raw_response": str(rewritten_data),
+                "status_code": 200,
+                "method": "direct_call"
+            }
+        else:
+            log.error("Resposta da reescrita direta incompleta")
+            return {
+                "success": False,
+                "error": "Resposta incompleta",
+                "data": rewritten_data,
+                "raw_response": str(rewritten_data),
+                "status_code": 200,
+                "method": "direct_call",
+                "missing_keys": [key for key in ["title", "subhead", "content"] if not rewritten_data.get(key, "").strip()]
+            }
+            
+    except Exception as e:
+        log.error(f"Erro na reescrita direta: {str(e)}")
+        log.info("Tentando fallback para API HTTP")
+        return await rewrite_article_http(content)
+
+async def rewrite_article_http(content: str) -> Optional[Dict[str, Any]]:
+    """Reescreve o artigo usando a API HTTP (função original)"""
+    try:
+        session = await get_http_session()
+        
+        payload = {"content": content}
+        
+        log.info(f"Enviando artigo para reescrita (HTTP): {len(content)} caracteres")
+        
+        # Timeout maior para a API HTTP
+        timeout = aiohttp.ClientTimeout(total=120, connect=10)  # 2 minutos
+        
+        async with session.post(
+            REWRITE_API_URL,
+            json=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=timeout
+        ) as response:
+            
+            # Log detalhado do status e headers
+            log.info(f"Status da resposta HTTP: {response.status}")
+            
+            # Captura o body completo da resposta
+            response_text = await response.text()
+            log.info(f"Body completo da resposta HTTP: {response_text}")
+            
+            if response.status == 200:
+                try:
+                    # Tenta fazer parse do JSON
+                    rewritten_data = json.loads(response_text)
+                    
+                    # Validação básica da resposta
+                    if all(key in rewritten_data for key in ["title", "subhead", "content"]):
+                        log.info("Artigo reescrito com sucesso (HTTP)")
+                        return {
+                            "success": True,
+                            "data": rewritten_data,
+                            "raw_response": response_text,
+                            "status_code": response.status,
+                            "method": "http_call"
+                        }
+                    else:
+                        log.error(f"Resposta HTTP incompleta. Chaves encontradas: {list(rewritten_data.keys())}")
+                        return {
+                            "success": False,
+                            "error": "Resposta incompleta",
+                            "data": rewritten_data,
+                            "raw_response": response_text,
+                            "status_code": response.status,
+                            "method": "http_call",
+                            "missing_keys": [key for key in ["title", "subhead", "content"] if key not in rewritten_data]
+                        }
+                        
+                except json.JSONDecodeError as e:
+                    log.error(f"Erro ao fazer parse do JSON: {str(e)}")
+                    return {
+                        "success": False,
+                        "error": f"JSON inválido: {str(e)}",
+                        "raw_response": response_text,
+                        "status_code": response.status,
+                        "method": "http_call"
+                    }
+            else:
+                log.error(f"Erro na API HTTP: {response.status}")
+                return {
+                    "success": False,
+                    "error": f"HTTP {response.status}",
+                    "raw_response": response_text,
+                    "status_code": response.status,
+                    "method": "http_call"
+                }
+                
+    except asyncio.TimeoutError:
+        log.error("Timeout na API HTTP")
+        return {
+            "success": False,
+            "error": "Timeout",
+            "raw_response": "Timeout occurred",
+            "status_code": 0,
+            "method": "http_call"
+        }
+    except Exception as e:
+        log.error(f"Erro na API HTTP: {str(e)}")
+        return {
+            "success": False,
+            "error": str(e),
+            "raw_response": "Exception occurred",
+            "status_code": 0,
+            "method": "http_call"
+        }
+
+async def rewrite_article(content: str) -> Optional[Dict[str, Any]]:
+    """Reescreve o artigo - tenta chamada direta primeiro, depois HTTP"""
+    
+    # Tenta chamada direta primeiro
+    result = await rewrite_article_direct(content)
+    
+    # Se a chamada direta falhou e não foi um fallback, tenta HTTP
+    if not result or (not result.get("success") and result.get("method") == "direct_call"):
+        log.info("Chamada direta falhou, tentando API HTTP")
+        result = await rewrite_article_http(content)
+    
+    return result
+
+async def fetch_brazil_interest_news():
+    """Busca uma notícia com brazil_interest=true e title_pt vazio"""
+    try:
+        session = await get_http_session()
+        url = f"{SUPABASE_URL}/rest/v1/news"
+        params = {
+            "brazil_interest": "eq.true",
+            "title_pt": "is.null",
+            "limit": "1",
+            "order": "created_at.asc"
+        }
+        
+        async with session.get(url, headers=SUPABASE_HEADERS, params=params) as response:
+            if response.status != 200:
+                raise HTTPException(status_code=500, detail="Erro ao buscar notícia")
+            
+            data = await response.json()
+            if not data:
+                raise HTTPException(status_code=404, detail="Nenhuma notícia com brazil_interest=true e title_pt vazio disponível")
+            
+            return data[0]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro Supabase: {str(e)}")
+
+async def update_news_rewrite(news_id: int, rewritten_data: Dict[str, str]):
+    """Atualiza a notícia com os dados reescritos e conta as fontes"""
+    try:
+        session = await get_http_session()
+        url = f"{SUPABASE_URL}/rest/v1/news"
+        params = {"id": f"eq.{news_id}"}
+        
+        # Conta as fontes - se vazio ou None, usa 1 como padrão
+        sources_list = rewritten_data.get("sources", [])
+        sources_count = len(sources_list) if sources_list else 1
+        
+        # Log para debug
+        log.info(f"Fontes encontradas: {sources_list}")
+        log.info(f"Contagem de fontes: {sources_count}")
+        
+        payload = {
+            "title_pt": rewritten_data.get("title", ""),
+            "text_pt": rewritten_data.get("content", ""),
+            "subhead_pt": rewritten_data.get("subhead", ""),
+            "sources": sources_count  # Adiciona a contagem de fontes
+        }
+        
+        async with session.patch(url, headers=SUPABASE_ROLE_HEADERS, json=payload, params=params) as response:
+            if response.status not in [200, 201, 204]:
+                response_text = await response.text()
+                log.error(f"Erro ao atualizar notícia - Status: {response.status}, Response: {response_text}")
+                raise HTTPException(status_code=500, detail=f"Erro ao atualizar notícia - Status: {response.status}")
+            
+            log.info(f"Notícia {news_id} atualizada com sucesso - Status: {response.status}, Fontes: {sources_count}")
+            
+    except Exception as e:
+        log.error(f"Erro ao atualizar notícia {news_id}: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Erro ao atualizar: {str(e)}")
+
+def fix_wikipedia_image_url(url: str) -> str:
+    if not url or not url.startswith('//upload.wikimedia.org'):
+        return url
+    
+    if url.startswith('//'):
+        url = 'https:' + url
+    
+    url = url.replace('/thumb/', '/')
+    parts = url.split('/')
+    if len(parts) >= 2:
+        filename = parts[-1]
+        if 'px-' in filename:
+            filename = filename.split('px-', 1)[1]
+        base_parts = parts[:-2]
+        url = '/'.join(base_parts) + '/' + filename
+    
+    return url
+
+def extract_birth_death_years(description: str) -> tuple[Optional[int], Optional[int]]:
+    if not description:
+        return None, None
+    
+    pattern = r'\((?:born\s+)?(\d{4})(?:[–-](\d{4}))?\)'
+    match = re.search(pattern, description)
+    
+    if match:
+        birth_year = int(match.group(1))
+        death_year = int(match.group(2)) if match.group(2) else None
+        if death_year is None:
+            death_year = 2025
+        return birth_year, death_year
+    
+    return None, None
+
+async def fetch_wikipedia_info(entity_name: str) -> Optional[Dict[str, Any]]:
+    try:
+        session = await get_http_session()
+        
+        url = f"https://en.wikipedia.org/w/rest.php/v1/search/title"
+        params = {'q': entity_name, 'limit': 1}
+        
+        async with session.get(url, params=params) as response:
+            if response.status != 200:
+                return None
+                
+            data = await response.json()
+            
+            if not data.get('pages'):
+                return None
+            
+            page = data['pages'][0]
+            title = page.get('title', '')
+            description = page.get('description', '')
+            thumbnail = page.get('thumbnail', {})
+            
+            birth_year, death_year = extract_birth_death_years(description)
+            
+            image_url = thumbnail.get('url', '') if thumbnail else ''
+            if image_url:
+                image_url = fix_wikipedia_image_url(image_url)
+            
+            return {
+                'title': title,
+                'birth_year': birth_year,
+                'death_year': death_year,
+                'image_url': image_url
+            }
+            
+    except Exception as e:
+        log.error(f"Erro ao buscar Wikipedia: {str(e)}")
+        return None
+
+def generate_poster_url(name: str, birth: int, death: int, image_url: str) -> str:
+    base_url = "https://habulaj-newapi.hf.space/cover/memoriam"
+    params = f"?image_url={quote(image_url)}&name={quote(name)}&birth={birth}&death={death}"
+    return base_url + params
+
+def generate_news_poster_url(image_url: str, headline: str) -> str:
+    """Gera URL do poster para notícias normais (não morte)"""
+    base_url = "https://habulaj-newapi.hf.space/cover/news"
+    params = f"?image_url={quote(image_url)}&headline={quote(headline)}"
+    return base_url + params
+
+async def generate_poster_analysis(news_data: Dict[str, Any], rewritten_result: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """Gera análise de poster baseado nos dados da notícia"""
+    try:
+        result = {}
+        image_url = news_data.get("image", "")
+        
+        # Verifica se é morte e gera poster apropriado
+        if news_data.get("death_related") is True and news_data.get("entity_name"):
+            wikipedia_info = await fetch_wikipedia_info(news_data["entity_name"])
+            
+            if wikipedia_info:
+                result["wikipedia_info"] = wikipedia_info
+                
+                # Gera poster de morte apenas se tiver morte confirmada
+                if (wikipedia_info.get("death_year") and 
+                    wikipedia_info.get("birth_year")):
+                    
+                    poster_url = generate_poster_url(
+                        wikipedia_info["title"],
+                        wikipedia_info["birth_year"],
+                        wikipedia_info["death_year"],
+                        wikipedia_info.get("image_url", image_url)
+                    )
+                    result["poster"] = poster_url
+        
+        # Se não for morte, gera poster de notícia normal
+        if "poster" not in result and image_url:
+            # Usa headline reescrito se disponível, senão usa título original
+            headline_to_use = news_data.get("title_en", "")  # fallback para título original
+            if (rewritten_result and 
+                rewritten_result.get("success") and 
+                rewritten_result.get("data") and 
+                rewritten_result["data"].get("title")):
+                headline_to_use = rewritten_result["data"]["title"]
+            
+            news_poster_url = generate_news_poster_url(image_url, headline_to_use)
+            result["poster"] = news_poster_url
+
+        return result
+
+    except Exception as e:
+        log.error(f"Erro ao gerar poster: {str(e)}")
+        return {}
+
+app = FastAPI(title="News Analyze API")
+router = APIRouter()
+
+@router.post("/analyze")
+async def analyze_endpoint():
+    # Busca notícia com brazil_interest=true e title_pt vazio
+    news_data = await fetch_brazil_interest_news()
+    
+    title_en = news_data.get("title_en", "")
+    text_en = news_data.get("text_en", "")
+    news_id = news_data.get("id")
+    
+    if not title_en.strip() or not text_en.strip():
+        raise HTTPException(status_code=400, detail="Title_en and text_en must not be empty.")
+    
+    # Executa reescrita (tenta direta primeiro, depois HTTP)
+    rewritten_result = await rewrite_article(text_en)
+    
+    # Log do resultado completo da reescrita
+    log.info(f"Resultado completo da reescrita: {json.dumps(rewritten_result, indent=2)}")
+    
+    # Atualiza no banco de dados se reescrita foi bem-sucedida
+    if rewritten_result and rewritten_result.get("success") and rewritten_result.get("data"):
+        await update_news_rewrite(news_id, rewritten_result["data"])
+    
+    # Gera análise de poster
+    poster_analysis = await generate_poster_analysis(news_data, rewritten_result)
+    
+    # Prepara resultado final
+    result = {
+        "news_id": news_id,
+        "title_en": title_en,
+        "text_en": text_en,
+        "rewrite_result": rewritten_result,
+        "death_related": news_data.get("death_related", False),
+        "entity_name": news_data.get("entity_name", ""),
+        "entity_type": news_data.get("entity_type", ""),
+        "image": news_data.get("image", "")
+    }
+    
+    # Adiciona informações do poster se disponíveis
+    if poster_analysis:
+        result.update(poster_analysis)
+    
+    return result
+
+app.include_router(router)
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    global http_session
+    if http_session:
+        await http_session.close()

routers/curiosity.py

@@ -0,0 +1,403 @@
+from fastapi import APIRouter, Query, HTTPException
+from fastapi.responses import StreamingResponse
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import requests
+from typing import Optional
+
+router = APIRouter()
+
+def get_responsive_font_to_fit_height(text: str, font_path: str, max_width: int, max_height: int,
+                                      max_font_size: int = 48, min_font_size: int = 20) -> tuple[ImageFont.FreeTypeFont, list[str], int]:
+    temp_img = Image.new("RGB", (1, 1))
+    draw = ImageDraw.Draw(temp_img)
+
+    for font_size in range(max_font_size, min_font_size - 1, -1):
+        try:
+            font = ImageFont.truetype(font_path, font_size)
+        except:
+            font = ImageFont.load_default()
+
+        lines = wrap_text(text, font, max_width, draw)
+        line_height = int(font_size * 1.161)
+        total_height = len(lines) * line_height
+
+        if total_height <= max_height:
+            return font, lines, font_size
+
+    # Caso nenhum tamanho sirva, usar o mínimo mesmo assim
+    try:
+        font = ImageFont.truetype(font_path, min_font_size)
+    except:
+        font = ImageFont.load_default()
+    lines = wrap_text(text, font, max_width, draw)
+    return font, lines, min_font_size
+
+def download_image_from_url(url: str) -> Image.Image:
+    response = requests.get(url)
+    if response.status_code != 200:
+        raise HTTPException(status_code=400, detail="Imagem não pôde ser baixada.")
+    return Image.open(BytesIO(response.content)).convert("RGBA")
+
+def resize_and_crop_to_fill(img: Image.Image, target_width: int, target_height: int) -> Image.Image:
+    img_ratio = img.width / img.height
+    target_ratio = target_width / target_height
+
+    if img_ratio > target_ratio:
+        scale_height = target_height
+        scale_width = int(scale_height * img_ratio)
+    else:
+        scale_width = target_width
+        scale_height = int(scale_width / img_ratio)
+
+    img_resized = img.resize((scale_width, scale_height), Image.LANCZOS)
+    left = (scale_width - target_width) // 2
+    top = (scale_height - target_height) // 2
+    return img_resized.crop((left, top, left + target_width, top + target_height))
+
+def create_black_gradient_overlay(width: int, height: int) -> Image.Image:
+    gradient = Image.new("RGBA", (width, height))
+    draw = ImageDraw.Draw(gradient)
+    for y in range(height):
+        opacity = int(255 * (y / height))
+        draw.line([(0, y), (width, y)], fill=(4, 4, 4, opacity))
+    return gradient
+
+def wrap_text(text: str, font: ImageFont.FreeTypeFont, max_width: int, draw: ImageDraw.Draw) -> list[str]:
+    lines = []
+    for raw_line in text.split("\n"):
+        words = raw_line.split()
+        current_line = ""
+        for word in words:
+            test_line = f"{current_line} {word}".strip()
+            if draw.textlength(test_line, font=font) <= max_width:
+                current_line = test_line
+            else:
+                if current_line:
+                    lines.append(current_line)
+                current_line = word
+        if current_line:
+            lines.append(current_line)
+        elif not words:
+            lines.append("")  # Linha vazia preserva \n\n
+    return lines
+
+def get_responsive_font_and_lines(text: str, font_path: str, max_width: int, max_lines: int = 3,
+                                 max_font_size: int = 50, min_font_size: int = 20) -> tuple[ImageFont.FreeTypeFont, list[str], int]:
+    temp_img = Image.new("RGB", (1, 1))
+    temp_draw = ImageDraw.Draw(temp_img)
+
+    current_font_size = max_font_size
+    while current_font_size >= min_font_size:
+        try:
+            font = ImageFont.truetype(font_path, current_font_size)
+        except:
+            font = ImageFont.load_default()
+
+        lines = wrap_text(text, font, max_width, temp_draw)
+        if len(lines) <= max_lines:
+            return font, lines, current_font_size
+        current_font_size -= 1
+
+    try:
+        font = ImageFont.truetype(font_path, min_font_size)
+    except:
+        font = ImageFont.load_default()
+    lines = wrap_text(text, font, max_width, temp_draw)
+    return font, lines, min_font_size
+
+def generate_slide_1(image_url: Optional[str], headline: Optional[str]) -> Image.Image:
+    width, height = 1080, 1350
+    canvas = Image.new("RGBA", (width, height), color=(255, 255, 255, 255))
+
+    if image_url:
+        try:
+            img = download_image_from_url(image_url)
+            filled_img = resize_and_crop_to_fill(img, width, height)
+            canvas.paste(filled_img, (0, 0))
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Erro ao processar imagem de fundo: {e}")
+
+    # Gradiente
+    gradient_overlay = create_black_gradient_overlay(width, height)
+    canvas = Image.alpha_composite(canvas, gradient_overlay)
+
+    draw = ImageDraw.Draw(canvas)
+
+    # Logo no topo
+    try:
+        logo = Image.open("recurvecuriosity.png").convert("RGBA").resize((368, 29))
+        canvas.paste(logo, (66, 74), logo)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao carregar recurvecuriosity.png: {e}")
+
+    # Imagem arrastar no rodapé
+    try:
+        arrow = Image.open("arrastar.png").convert("RGBA").resize((355, 37))
+        canvas.paste(arrow, (66, 1240), arrow)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao carregar arrastar.png: {e}")
+
+    # Texto headline acima da imagem arrastar
+    if headline:
+        font_path = "fonts/Montserrat-Bold.ttf"
+        max_width = 945
+        max_lines = 3
+        try:
+            font, lines, font_size = get_responsive_font_and_lines(
+                headline, font_path, max_width, max_lines=max_lines,
+                max_font_size=50, min_font_size=20
+            )
+            line_height = int(font_size * 1.161)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Erro ao processar fonte/headline: {e}")
+
+        total_text_height = len(lines) * line_height
+        start_y = 1240 - 16 - total_text_height
+        x = (width - max_width) // 2
+        for i, line in enumerate(lines):
+            y = start_y + i * line_height
+            draw.text((x, y), line, font=font, fill=(255, 255, 255))
+
+    return canvas
+
+def generate_slide_2(image_url: Optional[str], headline: Optional[str]) -> Image.Image:
+    width, height = 1080, 1350
+    canvas = Image.new("RGBA", (width, height), color=(4, 4, 4, 255))
+    draw = ImageDraw.Draw(canvas)
+
+    # === Imagem principal ===
+    if image_url:
+        try:
+            img = download_image_from_url(image_url)
+            resized = resize_and_crop_to_fill(img, 1080, 830)
+            canvas.paste(resized, (0, 0))
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Erro ao processar imagem do slide 2: {e}")
+
+    # === Headline ===
+    if headline:
+        font_path = "fonts/Montserrat-SemiBold.ttf"
+        max_width = 945
+        top_y = 830 + 70
+        bottom_padding = 70  # Alterado de 70 para 70 (já estava correto)
+        available_height = height - top_y - bottom_padding
+
+        try:
+            font, lines, font_size = get_responsive_font_to_fit_height(
+                headline,
+                font_path=font_path,
+                max_width=max_width,
+                max_height=available_height,
+                max_font_size=48,
+                min_font_size=20
+            )
+            line_height = int(font_size * 1.161)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Erro ao processar texto do slide 2: {e}")
+
+        x = (width - max_width) // 2
+        for i, line in enumerate(lines):
+            y = top_y + i * line_height
+            draw.text((x, y), line, font=font, fill=(255, 255, 255))
+
+    return canvas
+
+def generate_slide_3(image_url: Optional[str], headline: Optional[str]) -> Image.Image:
+    width, height = 1080, 1350
+    canvas = Image.new("RGBA", (width, height), color=(4, 4, 4, 255))
+    draw = ImageDraw.Draw(canvas)
+
+    # === Imagem com cantos arredondados à esquerda ===
+    if image_url:
+        try:
+            img = download_image_from_url(image_url)
+            resized = resize_and_crop_to_fill(img, 990, 750)
+
+            # Máscara arredondando cantos esquerdos
+            mask = Image.new("L", (990, 750), 0)
+            mask_draw = ImageDraw.Draw(mask)
+            mask_draw.rectangle((25, 0, 990, 750), fill=255)
+            mask_draw.pieslice([0, 0, 50, 50], 180, 270, fill=255)
+            mask_draw.pieslice([0, 700, 50, 750], 90, 180, fill=255)
+            mask_draw.rectangle((0, 25, 25, 725), fill=255)
+
+            canvas.paste(resized, (90, 422), mask)
+
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Erro ao processar imagem do slide 3: {e}")
+
+    # === Headline acima da imagem ===
+    if headline:
+        font_path = "fonts/Montserrat-SemiBold.ttf"
+        max_width = 945
+        image_top_y = 422
+        spacing = 50
+        bottom_of_text = image_top_y - spacing
+        safe_top = 70  # Alterado de 70 para 70 (já estava correto)
+        available_height = bottom_of_text - safe_top
+
+        font_size = 48
+        while font_size >= 20:
+            try:
+                font = ImageFont.truetype(font_path, font_size)
+            except:
+                font = ImageFont.load_default()
+
+            lines = wrap_text(headline, font, max_width, draw)
+            line_height = int(font_size * 1.161)
+            total_text_height = len(lines) * line_height
+            start_y = bottom_of_text - total_text_height
+
+            if start_y >= safe_top:
+                break
+
+            font_size -= 1
+
+        try:
+            font = ImageFont.truetype(font_path, font_size)
+        except:
+            font = ImageFont.load_default()
+
+        x = 90
+        for i, line in enumerate(lines):
+            y = start_y + i * line_height
+            draw.text((x, y), line, font=font, fill=(255, 255, 255))
+
+    return canvas
+
+def generate_slide_4(image_url: Optional[str], headline: Optional[str]) -> Image.Image:
+    width, height = 1080, 1350
+    canvas = Image.new("RGBA", (width, height), color=(4, 4, 4, 255))
+    draw = ImageDraw.Draw(canvas)
+
+    # === Imagem com cantos arredondados à esquerda ===
+    if image_url:
+        try:
+            img = download_image_from_url(image_url)
+            resized = resize_and_crop_to_fill(img, 990, 750)
+
+            # Máscara com cantos arredondados à esquerda
+            mask = Image.new("L", (990, 750), 0)
+            mask_draw = ImageDraw.Draw(mask)
+            mask_draw.rectangle((25, 0, 990, 750), fill=255)
+            mask_draw.pieslice([0, 0, 50, 50], 180, 270, fill=255)
+            mask_draw.pieslice([0, 700, 50, 750], 90, 180, fill=255)
+            mask_draw.rectangle((0, 25, 25, 725), fill=255)
+
+            canvas.paste(resized, (90, 178), mask)
+
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Erro ao processar imagem do slide 4: {e}")
+
+    # === Headline abaixo da imagem ===
+    if headline:
+        font_path = "fonts/Montserrat-SemiBold.ttf"
+        max_width = 945
+        top_of_text = 178 + 750 + 50  # Y da imagem + altura + espaçamento
+        safe_bottom = 70  # Alterado de 50 para 70
+        available_height = height - top_of_text - safe_bottom
+
+        try:
+            font, lines, font_size = get_responsive_font_to_fit_height(
+                headline,
+                font_path=font_path,
+                max_width=max_width,
+                max_height=available_height,
+                max_font_size=48,
+                min_font_size=20
+            )
+            line_height = int(font_size * 1.161)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Erro ao processar texto do slide 4: {e}")
+
+        x = 90
+        for i, line in enumerate(lines):
+            y = top_of_text + i * line_height
+            draw.text((x, y), line, font=font, fill=(255, 255, 255))
+
+    return canvas
+
+def generate_slide_5(image_url: Optional[str], headline: Optional[str]) -> Image.Image:
+    width, height = 1080, 1350
+    canvas = Image.new("RGBA", (width, height), color=(4, 4, 4, 255))
+    draw = ImageDraw.Draw(canvas)
+
+    image_w, image_h = 900, 748
+    image_x = 90
+    image_y = 100
+
+    # === Imagem com cantos totalmente arredondados ===
+    if image_url:
+        try:
+            img = download_image_from_url(image_url)
+            resized = resize_and_crop_to_fill(img, image_w, image_h)
+
+            # Máscara com cantos 25px arredondados (todos os cantos)
+            radius = 25
+            mask = Image.new("L", (image_w, image_h), 0)
+            mask_draw = ImageDraw.Draw(mask)
+            mask_draw.rounded_rectangle((0, 0, image_w, image_h), radius=radius, fill=255)
+
+            canvas.paste(resized, (image_x, image_y), mask)
+
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=f"Erro ao processar imagem do slide 5: {e}")
+
+    # === Texto abaixo da imagem ===
+    if headline:
+        font_path = "fonts/Montserrat-SemiBold.ttf"
+        max_width = 945
+        top_of_text = image_y + image_h + 50
+        safe_bottom = 70  # Alterado de 50 para 70
+        available_height = height - top_of_text - safe_bottom
+
+        try:
+            font, lines, font_size = get_responsive_font_to_fit_height(
+                headline,
+                font_path=font_path,
+                max_width=max_width,
+                max_height=available_height,
+                max_font_size=48,
+                min_font_size=20
+            )
+            line_height = int(font_size * 1.161)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Erro ao processar texto do slide 5: {e}")
+
+        x = (width - max_width) // 2  # Centralizado horizontalmente
+        for i, line in enumerate(lines):
+            y = top_of_text + i * line_height
+            draw.text((x, y), line, font=font, fill=(255, 255, 255))
+
+    return canvas
+
+def generate_black_canvas() -> Image.Image:
+    return Image.new("RGB", (1080, 1350), color=(4, 4, 4))
+
+@router.get("/cover/curiosity")
+def get_curiosity_image(
+    image_url: Optional[str] = Query(None, description="URL da imagem de fundo"),
+    headline: Optional[str] = Query(None, description="Texto da curiosidade"),
+    slide: int = Query(1, ge=1, le=5, description="Número do slide (1 a 5)")
+):
+    try:
+        if slide == 1:
+            final_image = generate_slide_1(image_url, headline)
+        elif slide == 2:
+            final_image = generate_slide_2(image_url, headline)
+        elif slide == 3:
+            final_image = generate_slide_3(image_url, headline)
+        elif slide == 4:
+            final_image = generate_slide_4(image_url, headline)
+        elif slide == 5:
+            final_image = generate_slide_5(image_url, headline)
+        else:
+            final_image = generate_black_canvas()
+
+        buffer = BytesIO()
+        final_image.convert("RGB").save(buffer, format="PNG")
+        buffer.seek(0)
+        return StreamingResponse(buffer, media_type="image/png")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao gerar imagem: {str(e)}")

routers/filter.py

@@ -0,0 +1,548 @@
+import os
+import sys
+import re
+import json
+import time
+import logging
+import gc
+import asyncio
+import aiohttp
+import random
+from typing import Optional, Dict, Any
+from fastapi import FastAPI, APIRouter, HTTPException
+from pydantic import BaseModel
+from google import genai
+from google.genai import types
+from newspaper import Article
+import trafilatura
+
+# Supabase Config
+SUPABASE_URL = "https://iiwbixdrrhejkthxygak.supabase.co"
+SUPABASE_KEY = os.getenv("SUPA_KEY")
+SUPABASE_ROLE_KEY = os.getenv("SUPA_SERVICE_KEY")
+if not SUPABASE_KEY or not SUPABASE_ROLE_KEY:
+    raise ValueError("❌ SUPA_KEY or SUPA_SERVICE_KEY not set in environment!")
+SUPABASE_HEADERS = {
+    "apikey": SUPABASE_KEY,
+    "Authorization": f"Bearer {SUPABASE_KEY}",
+    "Content-Type": "application/json"
+}
+SUPABASE_ROLE_HEADERS = {
+    "apikey": SUPABASE_ROLE_KEY,
+    "Authorization": f"Bearer {SUPABASE_ROLE_KEY}",
+    "Content-Type": "application/json"
+}
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+log = logging.getLogger("news-filter-api")
+
+http_session = None
+
+# Lista de User-Agents realistas para rotacionar
+USER_AGENTS = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edge/91.0.864.59'
+]
+
+async def get_http_session():
+    global http_session
+    if http_session is None:
+        connector = aiohttp.TCPConnector(
+            limit=20,
+            limit_per_host=10,
+            ttl_dns_cache=300,
+            use_dns_cache=True,
+            keepalive_timeout=30,
+            enable_cleanup_closed=True
+        )
+        timeout = aiohttp.ClientTimeout(total=30, connect=5)
+        http_session = aiohttp.ClientSession(
+            connector=connector,
+            timeout=timeout
+        )
+    return http_session
+
+def get_realistic_headers():
+    """Retorna headers realistas para evitar bloqueios"""
+    return {
+        'User-Agent': random.choice(USER_AGENTS),
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+        'Accept-Language': 'en-US,en;q=0.5',
+        'Accept-Encoding': 'gzip, deflate, br',
+        'DNT': '1',
+        'Connection': 'keep-alive',
+        'Upgrade-Insecure-Requests': '1',
+        'Cache-Control': 'max-age=0'
+    }
+
+async def extract_article_text(url: str) -> str:
+    """Extrai o texto completo de uma notícia usando newspaper3k com fallback para trafilatura"""
+    try:
+        # Método 1: newspaper3k com headers realistas
+        try:
+            article = Article(url)
+            article.config.browser_user_agent = random.choice(USER_AGENTS)
+            article.config.request_timeout = 10
+            article.config.number_threads = 1
+            
+            article.download()
+            article.parse()
+            
+            if article.text and len(article.text.strip()) > 100:
+                return article.text.strip()
+            
+        except Exception:
+            pass
+        
+        # Método 2: trafilatura como fallback
+        session = await get_http_session()
+        headers = get_realistic_headers()
+        
+        # Adiciona um pequeno delay para parecer mais humano
+        await asyncio.sleep(random.uniform(1, 3))
+        
+        async with session.get(url, headers=headers) as response:
+            if response.status == 200:
+                html = await response.text()
+                extracted_text = trafilatura.extract(html)
+                
+                if extracted_text and len(extracted_text.strip()) > 100:
+                    return extracted_text.strip()
+        
+        return ""
+        
+    except Exception as e:
+        log.error(f"Erro ao extrair texto da URL {url}: {str(e)}")
+        return ""
+
+async def fetch_unused_news():
+    """Busca uma notícia não usada do Supabase"""
+    try:
+        session = await get_http_session()
+        url = f"{SUPABASE_URL}/rest/v1/news_extraction"
+        params = {
+            "used": "eq.false",
+            "limit": "1",
+            "order": "created_at.asc"
+        }
+        
+        async with session.get(url, headers=SUPABASE_HEADERS, params=params) as response:
+            if response.status != 200:
+                raise HTTPException(status_code=500, detail="Erro ao buscar notícia")
+            
+            data = await response.json()
+            if not data:
+                raise HTTPException(status_code=404, detail="Nenhuma notícia disponível")
+            
+            return data[0]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro Supabase: {str(e)}")
+
+async def fetch_last_50_titles():
+    """Busca os últimos 50 títulos da tabela news ordenados por created_at"""
+    try:
+        session = await get_http_session()
+        url = f"{SUPABASE_URL}/rest/v1/news"
+        params = {
+            "select": "title_pt",
+            "limit": "50",
+            "order": "created_at.desc"
+        }
+        
+        async with session.get(url, headers=SUPABASE_HEADERS, params=params) as response:
+            if response.status != 200:
+                log.warning("Erro ao buscar títulos anteriores")
+                return []
+            
+            data = await response.json()
+            titles = [item.get("title_pt", "") for item in data if item.get("title_pt")]
+            return titles
+    except Exception as e:
+        log.warning(f"Erro ao buscar últimos títulos: {str(e)}")
+        return []
+
+async def insert_news_to_db(title: str, text: str, news_id: str, url: str, image_url: str, filters: dict):
+    """Insere notícia na tabela news com dados originais e filtros"""
+    try:
+        session = await get_http_session()
+        supabase_url = f"{SUPABASE_URL}/rest/v1/news"
+        
+        payload = {
+            "title_en": title,
+            "text_en": text,
+            "news_id": news_id,
+            "url": url,
+            "image": image_url,
+            "death_related": filters.get("death_related", False),
+            "political_related": filters.get("political_related", False),
+            "woke_related": filters.get("woke_related", False),
+            "spoilers": filters.get("spoilers", False),
+            "sensitive_theme": filters.get("sensitive_theme", False),
+            "contains_video": filters.get("contains_video", False),
+            "is_news_content": filters.get("is_news_content", True),
+            "relevance": filters.get("relevance", ""),
+            "brazil_interest": filters.get("brazil_interest", False),
+            "breaking_news": filters.get("breaking_news", False),
+            "audience_age_rating": filters.get("audience_age_rating", ""),
+            "regional_focus": filters.get("regional_focus", ""),
+            "country_focus": filters.get("country_focus", ""),
+            "ideological_alignment": filters.get("ideological_alignment", ""),
+            "entity_type": filters.get("entity_type", ""),
+            "entity_name": filters.get("entity_name", ""),
+            "duplication": filters.get("duplication", False)
+        }
+        
+        async with session.post(supabase_url, headers=SUPABASE_ROLE_HEADERS, json=payload) as response:
+            if response.status not in [200, 201]:
+                response_text = await response.text()
+                raise HTTPException(status_code=500, detail=f"Erro ao inserir notícia: {response.status} - {response_text}")
+            
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao inserir: {str(e)}")
+
+async def mark_news_as_used(news_id: str):
+    """Marca notícia como usada - SEMPRE deve funcionar para evitar loops infinitos"""
+    try:
+        session = await get_http_session()
+        url = f"{SUPABASE_URL}/rest/v1/news_extraction"
+        params = {"news_id": f"eq.{news_id}"}
+        
+        payload = {"used": True}
+        
+        async with session.patch(url, headers=SUPABASE_ROLE_HEADERS, json=payload, params=params) as response:
+            if response.status not in [200, 201, 204]:
+                log.warning(f"Erro ao marcar {news_id} como usada, mas continuando...")
+            
+    except Exception as e:
+        log.warning(f"Erro ao atualizar notícia {news_id}: {str(e)}")
+
+def extract_json(text):
+    match = re.search(r'\{.*\}', text, flags=re.DOTALL)
+    return match.group(0) if match else text
+
+def ensure_filter_order(filter_dict: Dict[str, Any]) -> Dict[str, Any]:
+    ordered_keys = [
+        "death_related", "political_related", "woke_related", "spoilers", 
+        "sensitive_theme", "contains_video", "is_news_content", "relevance",
+        "brazil_interest", "breaking_news", "audience_age_rating", "regional_focus",
+        "country_focus", "ideological_alignment", "entity_type", "entity_name", "duplication"
+    ]
+    
+    return {key: filter_dict[key] for key in ordered_keys if key in filter_dict}
+
+async def filter_news(title: str, content: str, last_titles: list) -> dict:
+    try:
+        client = genai.Client(
+            api_key=os.environ.get("GEMINI_API_KEY"),
+        )
+
+        model = "gemini-2.5-flash-lite"
+
+        # Instruções do sistema
+        SYSTEM_INSTRUCTIONS = """
+        Analyze the news title and content, and return the filters in JSON format with the defined fields.
+        Please respond ONLY with the JSON filter, do NOT add any explanations, system messages, or extra text.
+
+        - death_related (true | false): Whether the news involves the real-life death of a person. Does not include fictional character deaths or deaths within stories.
+        - political_related (true | false): Related to real-world politics (governments, elections, politicians, or official decisions). Not about political storylines in fiction.
+        - woke_related (true | false): Involves social issues like inclusion, diversity, racism, gender, LGBTQIA+, etc.
+        - spoilers (true | false): Reveals important plot points (e.g., character deaths, endings, major twists).
+        - sensitive_theme (true | false): Covers sensitive or disturbing topics like suicide, abuse, violence, or tragedy.
+        - contains_video (true | false): The news includes an embedded video (e.g., trailer, teaser, interview, video report).
+        - is_news_content (true | false): Whether the content is actual news reporting. True for breaking news, announcements, factual reports. False for reviews, opinion pieces, lists, rankings, recommendations, critiques, analysis, or editorial content.
+        - relevance ("low" | "medium" | "high" | "viral"): The expected public interest or impact of the news.
+        - brazil_interest (true | false): Whether the topic is directly related to Brazil or relevant to Brazilian audiences.
+        - breaking_news (true | false): The content is urgent or part of a recent and unfolding event.
+        - audience_age_rating ("L" | 10 | 12 | 14 | 16 | 18): Content rating based on Brazilian standards.
+        - regional_focus ("global" | "americas" | "europe" | "asia" | "africa" | "middle_east" | "oceania"): The main geographic region the news relates to.
+        - country_focus (ISO 3166-1 alpha-2 code like "br", "us", "fr", "jp" or null): The specific country the news is about, if applicable.
+        - ideological_alignment ("left" | "center-left" | "center" | "center-right" | "right" | "apolitical"): The perceived political bias of the article.
+        - entity_type ("movie" | "series" | "event" | "person" | "place" | "other"): The type of main subject mentioned in the news.
+        - entity_name (string): The name of the person, title, event, or topic the article is primarily about.
+        - duplication (true | false): Whether the current news is a duplicate or highly similar to any of the previously published news titles.
+        """
+
+        # Formata os últimos títulos para incluir no prompt - aumentado para 25 títulos
+        last_titles_formatted = "\n- ".join(last_titles[:25]) if last_titles else "No previous titles available"
+
+        # Primeiro exemplo - NOTÍCIA REAL
+        EXAMPLE_INPUT_1 = f"""Title: 'The Gilded Age' Renewed for Season 4 at HBO — Everything We Know So Far
+Content: The Gilded Age will return. HBO announced on Monday, July 28, that the series has been renewed for Season 4. This comes after the release of Season 3 Episode 6 on Sunday, July 27. There are two episodes left to go in the third season. The Season 3 finale will air on Sunday, August 10, on HBO. According to HBO, total premiere-night viewing for the third season has grown for five consecutive weeks, culminating in a 20 percent growth compared to last season. Fan engagement has also climbed, with social chatter rising nearly 60 percent week over week. The show has also received its most critical acclaim to date with Season 3, its highest-stakes season so far. In the July 27 episode, the series that's known for its low stakes but high-camp drama, a character was seemingly killed off in violent (for The Gilded Age) fashion. The show is already Emmy-winning. Production designer Bob Shaw took home an Emmy for
+Last titles:
+- 'Quarteto Fantástico: Primeiros Passos' dispara para arrecadar US$ 118 milhões nas bilheterias dos EUA e US$ 218 milhões globalmente
+- Bilheteria: 'Quarteto Fantástico: Primeiros Passos' sobe para US$ 218 milhões globalmente, 'Superman' e 'F1' ultrapassam US$ 500 milhões
+- Reboot de 'Quarteto Fantástico' da Marvel ultrapassa US$ 200 milhões globalmente"""
+
+        EXAMPLE_OUTPUT_1 = """{"death_related": false,"political_related": false,"woke_related": false,"spoilers": false,"sensitive_theme": false,"contains_video": false,"is_news_content": true,"relevance": "medium","brazil_interest": true,"breaking_news": true,"audience_age_rating": 14,"regional_focus": "americas","country_focus": "us","ideological_alignment": "apolitical","entity_type": "series","entity_name": "The Gilded Age","duplication": false}"""
+
+        # Segundo exemplo - REVIEW/CRÍTICA (NÃO É NOTÍCIA)
+        EXAMPLE_INPUT_2 = f"""Title: ‘My Best Friend’s Wedding’ Sequel in the Works: ‘Materialists,’ ‘Past Lives’ Director Celine Song to Write Screenplay
+Content: A sequel to the Julia Roberts romantic comedy “My Best Friend’s Wedding” is in early development at Sony Pictures. The studio has tapped “Materialists” and “Past Lives” writer-director Celine Song to pen a screenplay for the project, though she is not in talks to helm the feature. 
+Last titles:
+- Sequência de "The Batman" ganha data de lançamento oficial da Warner Bros
+- Sequência de "The Batman" de Robert Pattinson tem data oficial de lançamento para 2026
+- Warner Bros. define data de lançamento da sequência de "The Batman" para 2026
+- Sequência de 'O Casamento do Meu Melhor Amigo' terá roteiro da diretora de 'Vidas Passadas'"""
+
+        EXAMPLE_OUTPUT_2 = """{"death_related": false,"political_related": false,"woke_related": false,"spoilers": false,"sensitive_theme": false,"contains_video": false,"is_news_content": true,"relevance": "medium","brazil_interest": true,"breaking_news": false,"audience_age_rating": 10,"regional_focus": "americas","country_focus": "us","ideological_alignment": "apolitical","entity_type": "movie","entity_name": "My Best Friend’s Wedding","duplication": true}"""
+
+        # Terceiro exemplo - LISTA/RANKING (NÃO É NOTÍCIA)
+        EXAMPLE_INPUT_3 = f"""Title: 9-1-1: Death of main character shakes series, which gets new date for the 9th season
+Content: The 9-1-1 universe was permanently redefined after one of the most shocking events in its history. The show's eighth season bid farewell to one of its pillars with the death of Captain Bobby Nash, played by Peter Krause, in episode 15. Now, with the renewal for a ninth season confirmed, ABC has announced a schedule change: the premiere has been moved up to Thursday, October 9, 2025. Bobby Nash's death, the first of a main cast member, leaves a leadership vacuum in Battalion 118 and sets the main narrative arc for the new episodes. Peter Krause's departure had already been signaled, but the impact of his absence will be the driving force behind the next season, which will have 18 episodes. Showrunner Tim Minear had previously stated that, despite the death, the character would still appear in specific moments in the eighth season finale, fulfilling his promise.
+Last titles:
+- The Batman 2 ganha data oficial de lançamento para 2026 na Warner Bros
+- Datas de estreia da ABC no outono de 2025: '9-1-1', 'Nashville' e 'Grey's Anatomy' antecipadas
+- Warner Bros. anuncia sequência de 'The Batman' para 2026"""
+
+        EXAMPLE_OUTPUT_3 = """{"death_related": false,"political_related": false,"woke_related": false,"spoilers": true,"sensitive_theme": false,"contains_video": false,"is_news_content": true,"relevance": "high","brazil_interest": true,"breaking_news": true,"audience_age_rating": 14,"regional_focus": "global","country_focus": null,"ideological_alignment": "apolitical","entity_type": "series","entity_name": "9-1-1","duplication": true}"""
+
+        # Quarto exemplo - NOTÍCIA REAL DE MORTE
+        EXAMPLE_INPUT_4 = f"""Title: Julian McMahon, 'Fantastic Four,' 'Nip/Tuck' and 'FBI: Most Wanted' Star, Dies at 56
+Content: Julian McMahon, the suave Australian actor best known for his performances on "FBI: Most Wanted," "Charmed," "Nip/Tuck" and the early aughts "Fantastic Four" films, died Wednesday in Florida. He was 56 and died after a battle with cancer. McMahon's death was confirmed through his reps, who shared a statement from his wife, Kelly McMahon, in remembrance of her husband. "With an open heart, I wish to share with the world that my beloved husband, Julian McMahon, died peacefully this week after a valiant effort to overcome cancer," she said. "Julian loved life. He loved his family. He loved his friends. He loved his work, and he loved his fans. His deepest wish was to bring joy into as many lives as possible. We ask for support during this time to allow our family to grieve in privacy. And we wish for all of those to whom Julian brought joy, to continue to find joy in life. We are grateful for the memories."
+Last titles:
+- Mortes de Celebridades em 2025: Estrelas que Perdemos Este Ano
+- Programas de TV Cancelados em 2025: Quais Séries Foram Canceladas
+- Atores Australianos que Estão Fazendo Sucesso em Hollywood"""
+
+        EXAMPLE_OUTPUT_4 = """{"death_related": true,"political_related": false,"woke_related": false,"spoilers": false,"sensitive_theme": true,"contains_video": false,"is_news_content": true,"relevance": "medium","brazil_interest": true,"breaking_news": true,"audience_age_rating": 14,"regional_focus": "americas","country_focus": "au","ideological_alignment": "apolitical","entity_type": "person","entity_name": "Julian McMahon","duplication": false}"""
+
+        # Estrutura de conversação correta com múltiplos exemplos
+        contents = [
+            # Primeiro exemplo: usuário envia uma notícia
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_1)
+                ]
+            ),
+            # Primeiro exemplo: modelo responde com o formato correto
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_1)
+                ]
+            ),
+            # Segundo exemplo: usuário envia um review (não é notícia)
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_2)
+                ]
+            ),
+            # Segundo exemplo: modelo responde marcando como não-notícia
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_2)
+                ]
+            ),
+            # Terceiro exemplo: usuário envia uma lista (não é notícia)
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_3)
+                ]
+            ),
+            # Terceiro exemplo: modelo responde marcando como não-notícia
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_3)
+                ]
+            ),
+            # Quarto exemplo: usuário envia notícia real
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_4)
+                ]
+            ),
+            # Quarto exemplo: modelo responde marcando como notícia
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_4)
+                ]
+            ),
+            # Agora o usuário envia a notícia real para ser analisada
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=f"""Title: {title}
+Content: {content}
+Last titles:
+- {last_titles_formatted}""")
+                ]
+            )
+        ]
+
+        # Ferramentas para pesquisa e pensamento
+        tools = [
+            types.Tool(googleSearch=types.GoogleSearch())
+        ]
+
+        config = types.GenerateContentConfig(
+            system_instruction=SYSTEM_INSTRUCTIONS,
+            tools=tools,
+            response_mime_type="text/plain",
+            max_output_tokens=4096,
+            temperature=0.8,
+        )
+
+        response_text = ""
+        for chunk in client.models.generate_content_stream(
+            model=model,
+            contents=contents,
+            config=config
+        ):
+            if chunk.text:
+                response_text += chunk.text
+        
+        json_result = extract_json(response_text)
+
+        try:
+            parsed = json.loads(json_result)
+        except json.JSONDecodeError as e:
+            raise ValueError("Modelo retornou JSON inválido")
+
+        ALLOWED_KEYS = {
+            "death_related", "political_related", "woke_related", "spoilers", 
+            "sensitive_theme", "contains_video", "is_news_content", "relevance",
+            "brazil_interest", "breaking_news", "audience_age_rating", "regional_focus",
+            "country_focus", "ideological_alignment", "entity_type", "entity_name", "duplication"
+        }
+
+        clean_filter = {key: parsed[key] for key in ALLOWED_KEYS if key in parsed}
+        clean_filter = ensure_filter_order(clean_filter)
+
+        return {"filter": clean_filter}
+
+    except Exception as e:
+        raise ValueError(f"Erro na filtragem: {str(e)}")
+
+def should_skip_insertion(filters: dict) -> tuple[bool, str]:
+    """
+    Verifica se a notícia deve ser pulada (não inserida na tabela news).
+    Retorna (should_skip, reason)
+    """
+
+    # Condição 1: Se duplication for true → sempre pular
+    if filters.get("duplication", False):
+        return True, "duplicação detectada"
+
+    # Condição 2: Se is_news_content for false → pular
+    if not filters.get("is_news_content", True):
+        return True, "conteúdo não é notícia (review, lista, crítica, etc.)"
+
+    # Condição 3: Se brazil_interest for false → pular
+    if not filters.get("brazil_interest", True):
+        return True, "baixo interesse para o Brasil (brazil_interest=false)"
+
+    # Condição 4: Se relevance for low ou ausente → pular
+    if filters.get("relevance", "") not in {"medium", "high", "viral"}:
+        return True, f"relevância insuficiente (relevance={filters.get('relevance')})"
+
+    # Se passou por todas, pode inserir
+    return False, ""
+    
+app = FastAPI(title="News Filter API")
+router = APIRouter()
+
+@router.post("/filter")
+async def filter_endpoint():
+    news_data = None
+    news_id = None
+    
+    try:
+        # Busca notícia não usada do Supabase
+        news_data = await fetch_unused_news()
+        
+        title = news_data.get("title", "")
+        url = news_data.get("url", "")
+        news_id = news_data.get("news_id", "")
+        image_url = news_data.get("image", "")
+        
+        if not title.strip() or not url.strip():
+            raise ValueError("Title e URL não podem estar vazios")
+        
+        log.info(f"Processando notícia {news_id}: {title}")
+        
+        # Busca os últimos 50 títulos
+        last_titles = await fetch_last_50_titles()
+        
+        # Extrai texto completo da URL
+        full_text = await extract_article_text(url)
+        
+        if not full_text.strip():
+            raise ValueError("Não foi possível extrair texto da URL")
+        
+        # Executa análise de filtros com os últimos títulos
+        filter_result = await filter_news(title, full_text, last_titles)
+        
+        # Verifica se deve pular a inserção
+        should_skip, skip_reason = should_skip_insertion(filter_result["filter"])
+        
+        if should_skip:
+            # Apenas marca como usada, não insere na tabela news
+            await mark_news_as_used(news_id)
+            log.info(f"Notícia {news_id} pulada devido a: {skip_reason}")
+            
+            return {
+                "filter": filter_result["filter"],
+                "title_en": title,
+                "text_en": full_text,
+                "news_id": news_id,
+                "url": url,
+                "image": image_url,
+                "last_titles": last_titles,
+                "skipped": True,
+                "skip_reason": skip_reason
+            }
+        else:
+            # Insere na tabela news com filtros
+            await insert_news_to_db(title, full_text, news_id, url, image_url, filter_result["filter"])
+            
+            # Marca como usada (sucesso)
+            await mark_news_as_used(news_id)
+            
+            log.info(f"Notícia {news_id} processada e inserida com sucesso")
+            
+            return {
+                "filter": filter_result["filter"],
+                "title_en": title,
+                "text_en": full_text,
+                "news_id": news_id,
+                "url": url,
+                "image": image_url,
+                "last_titles": last_titles,
+                "skipped": False
+            }
+        
+    except Exception as e:
+        error_msg = str(e)
+        log.error(f"Erro no processamento da notícia {news_id}: {error_msg}")
+        
+        # SEMPRE marca como usada em caso de erro para evitar loops infinitos
+        if news_id:
+            await mark_news_as_used(news_id)
+        
+        # Determina o tipo de erro para o HTTP response
+        if "Nenhuma notícia disponível" in error_msg:
+            raise HTTPException(status_code=404, detail=error_msg)
+        elif "Title e URL não podem estar vazios" in error_msg:
+            raise HTTPException(status_code=400, detail=error_msg)
+        elif "Não foi possível extrair texto" in error_msg:
+            raise HTTPException(status_code=400, detail=error_msg)
+        else:
+            raise HTTPException(status_code=500, detail=f"Erro interno: {error_msg}")
+
+app.include_router(router)
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    global http_session
+    if http_session:
+        await http_session.close()

routers/getnews.py

@@ -0,0 +1,134 @@
+import os
+import re
+import httpx
+from typing import List, Dict
+from bs4 import BeautifulSoup
+from fastapi import APIRouter, HTTPException
+
+router = APIRouter()
+
+# 🎯 IMDb GraphQL
+GRAPHQL_URL = "https://api.graphql.imdb.com"
+HEADERS = {"Content-Type": "application/json"}
+
+QUERY = """
+query GetNews($first: Int!) {
+  movieNews: news(first: $first, category: MOVIE) {
+    edges {
+      node {
+        id
+        articleTitle { plainText }
+        externalUrl
+        date
+        text { plaidHtml }
+        image { url }
+      }
+    }
+  }
+  tvNews: news(first: $first, category: TV) {
+    edges {
+      node {
+        id
+        articleTitle { plainText }
+        externalUrl
+        date
+        text { plaidHtml }
+        image { url }
+      }
+    }
+  }
+}
+"""
+
+# 🔧 Supabase Config
+SUPABASE_URL = "https://iiwbixdrrhejkthxygak.supabase.co"
+SUPABASE_KEY = os.getenv("SUPA_KEY")
+SUPABASE_ROLE_KEY = os.getenv("SUPA_SERVICE_KEY")
+
+if not SUPABASE_KEY or not SUPABASE_ROLE_KEY:
+    raise ValueError("❌ SUPA_KEY or SUPA_SERVICE_KEY not set in environment!")
+
+SUPABASE_HEADERS = {
+    "apikey": SUPABASE_KEY,
+    "Authorization": f"Bearer {SUPABASE_KEY}",
+    "Content-Type": "application/json"
+}
+
+SUPABASE_ROLE_HEADERS = {
+    "apikey": SUPABASE_ROLE_KEY,
+    "Authorization": f"Bearer {SUPABASE_ROLE_KEY}",
+    "Content-Type": "application/json"
+}
+
+# 🧼 HTML Cleanup
+def clean_html(raw_html: str) -> str:
+    text = BeautifulSoup(raw_html or "", "html.parser").get_text(separator=" ", strip=True)
+    text = re.sub(r"\s+", " ", text)
+    text = re.sub(r"\s+([.,;:!?])", r"\1", text)
+    text = re.sub(r"\(\s+", "(", text)
+    text = re.sub(r"\s+\)", ")", text)
+    text = re.sub(r"\[\s+", "[", text)
+    text = re.sub(r"\s+\]", "]", text)
+    text = re.sub(r"\{\s+", "{", text)
+    text = re.sub(r"\s+\}", "}", text)
+    return text.strip()
+
+# 🚀 Endpoint principal
+@router.get("/news")
+async def get_news(first: int = 20) -> List[Dict]:
+    payload = {
+        "query": QUERY,
+        "variables": {"first": first}
+    }
+
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        # Pega notícias do IMDb
+        response = await client.post(GRAPHQL_URL, headers=HEADERS, json=payload)
+
+        if response.status_code != 200:
+            raise HTTPException(status_code=502, detail="Erro ao acessar a API do IMDb")
+
+        data = response.json().get("data")
+        if not data:
+            raise HTTPException(status_code=500, detail="Resposta inválida da API")
+
+        combined = []
+
+        for category_key in ["movieNews", "tvNews"]:
+            for edge in data.get(category_key, {}).get("edges", []):
+                node = edge.get("node", {})
+                image_data = node.get("image")
+                combined.append({
+                    "news_id": node.get("id"),
+                    "title": node.get("articleTitle", {}).get("plainText"),
+                    "url": node.get("externalUrl"),
+                    "date": node.get("date"),
+                    "text": clean_html(node.get("text", {}).get("plaidHtml")),
+                    "image": image_data.get("url") if image_data else None,
+                    "category": category_key.replace("News", "").upper()
+                })
+
+        # 📌 Verifica quais IDs já existem no Supabase
+        all_ids = [item["news_id"] for item in combined]
+
+        existing_ids = []
+        ids_chunks = [all_ids[i:i + 1000] for i in range(0, len(all_ids), 1000)]  # evita URL muito grande
+
+        for chunk in ids_chunks:
+            query_ids = ",".join([f"\"{nid}\"" for nid in chunk])
+            url = f"{SUPABASE_URL}/rest/v1/news_extraction?select=news_id&news_id=in.({query_ids})"
+            r = await client.get(url, headers=SUPABASE_HEADERS)
+            if r.status_code == 200:
+                existing_ids.extend([item["news_id"] for item in r.json()])
+
+        # 🔎 Filtra apenas as novas notícias
+        new_entries = [item for item in combined if item["news_id"] not in existing_ids]
+
+        # 🧾 Insere novas notícias (em lote)
+        if new_entries:
+            insert_url = f"{SUPABASE_URL}/rest/v1/news_extraction"
+            await client.post(insert_url, headers=SUPABASE_ROLE_HEADERS, json=new_entries)
+
+        # 🔃 Ordena por data
+        combined.sort(key=lambda x: x.get("date"), reverse=True)
+        return combined

routers/image.py

@@ -0,0 +1,573 @@
+from fastapi import APIRouter, Query, HTTPException
+from fastapi.responses import StreamingResponse
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import requests
+import re
+from typing import Optional, List, Tuple
+
+router = APIRouter()
+
+def download_image_from_url(url: str) -> Image.Image:
+    headers = {
+        "User-Agent": (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/115.0.0.0 Safari/537.36"
+        )
+    }
+    try:
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+        return Image.open(BytesIO(response.content)).convert("RGBA")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Erro ao baixar imagem: {url} ({str(e)})")
+
+def resize_and_crop_to_fill(img: Image.Image, target_width: int, target_height: int) -> Image.Image:
+    img_ratio = img.width / img.height
+    target_ratio = target_width / target_height
+
+    if img_ratio > target_ratio:
+        scale_height = target_height
+        scale_width = int(scale_height * img_ratio)
+    else:
+        scale_width = target_width
+        scale_height = int(scale_width / img_ratio)
+
+    img_resized = img.resize((scale_width, scale_height), Image.LANCZOS)
+    left = (scale_width - target_width) // 2
+    top = (scale_height - target_height) // 2
+    return img_resized.crop((left, top, left + target_width, top + target_height))
+
+def create_gradient_overlay(width: int, height: int, positions: List[str], expanded: bool = False) -> Image.Image:
+    gradient = Image.new("RGBA", (width, height))
+    draw = ImageDraw.Draw(gradient)
+    
+    for position in positions:
+        if position.lower() == "bottom":
+            if expanded:
+                # Gradiente expandido para quando há texto + citação
+                gradient_start = 500  # Começar mais alto
+                gradient_height = 850  # Mais altura para cobrir ambos
+            else:
+                # Gradiente normal
+                gradient_start = 650  # Começar mais baixo para ser mais sutil
+                gradient_height = 700  # Altura menor para gradiente mais localizado
+            
+            for y in range(gradient_height):
+                if y + gradient_start < height:
+                    ratio = y / gradient_height
+                    # Gradiente muito mais suave com opacidades menores
+                    if ratio <= 0.3:
+                        opacity = int(255 * 0.15 * (ratio / 0.3))  # Começar muito sutil
+                    elif ratio <= 0.6:
+                        opacity = int(255 * (0.15 + 0.20 * ((ratio - 0.3) / 0.3)))  # Crescimento gradual
+                    else:
+                        opacity = int(255 * (0.35 + 0.15 * ((ratio - 0.6) / 0.4)))  # Max de 50% de opacidade
+                    
+                    current_pixel = gradient.getpixel((0, y + gradient_start))
+                    combined_opacity = min(255, current_pixel[3] + opacity)
+                    draw.line([(0, y + gradient_start), (width, y + gradient_start)], fill=(0, 0, 0, combined_opacity))
+        
+        elif position.lower() == "top":
+            if expanded:
+                # Gradiente expandido para quando há texto + citação
+                gradient_height = 850  # Maior altura para cobrir ambos
+            else:
+                # Gradiente normal
+                gradient_height = 650  # Menor altura para ser mais sutil
+            
+            for y in range(gradient_height):
+                if y < height:
+                    ratio = (gradient_height - y) / gradient_height
+                    # Opacidades muito menores para efeito mais sutil
+                    if ratio <= 0.2:
+                        opacity = int(255 * 0.12 * (ratio / 0.2))  # Muito sutil no início
+                    elif ratio <= 0.5:
+                        opacity = int(255 * (0.12 + 0.18 * ((ratio - 0.2) / 0.3)))  # Crescimento suave
+                    else:
+                        opacity = int(255 * (0.30 + 0.15 * ((ratio - 0.5) / 0.5)))  # Max de 45%
+                    
+                    current_pixel = gradient.getpixel((0, y))
+                    combined_opacity = min(255, current_pixel[3] + opacity)
+                    draw.line([(0, y), (width, y)], fill=(0, 0, 0, combined_opacity))
+    
+    return gradient
+
+class TextSegment:
+    def __init__(self, text: str, is_bold: bool = False, is_italic: bool = False):
+        self.text = text
+        self.is_bold = is_bold
+        self.is_italic = is_italic
+
+def parse_text_with_formatting(text: str) -> List[TextSegment]:
+    pattern = r'(<(?:strong|em)>.*?</(?:strong|em)>|<(?:strong|em)><(?:strong|em)>.*?</(?:strong|em)></(?:strong|em)>)'
+    parts = re.split(pattern, text)
+    segments = []
+    
+    for part in parts:
+        if not part:
+            continue
+            
+        if match := re.match(r'<strong><em>(.*?)</em></strong>|<em><strong>(.*?)</strong></em>', part):
+            content = match.group(1) or match.group(2)
+            segments.append(TextSegment(content, True, True))
+        elif match := re.match(r'<strong>(.*?)</strong>', part):
+            segments.append(TextSegment(match.group(1), True, False))
+        elif match := re.match(r'<em>(.*?)</em>', part):
+            segments.append(TextSegment(match.group(1), False, True))
+        else:
+            segments.append(TextSegment(part, False, False))
+    
+    return segments
+
+def get_font(segment: TextSegment, regular_font: ImageFont.FreeTypeFont, 
+            bold_font: ImageFont.FreeTypeFont, italic_font: ImageFont.FreeTypeFont,
+            bold_italic_font: ImageFont.FreeTypeFont) -> ImageFont.FreeTypeFont:
+    if segment.is_bold and segment.is_italic:
+        return bold_italic_font
+    elif segment.is_bold:
+        return bold_font
+    elif segment.is_italic:
+        return italic_font
+    return regular_font
+
+def wrap_text_with_formatting(segments: List[TextSegment], regular_font: ImageFont.FreeTypeFont, 
+                             bold_font: ImageFont.FreeTypeFont, italic_font: ImageFont.FreeTypeFont,
+                             bold_italic_font: ImageFont.FreeTypeFont, max_width: int, 
+                             draw: ImageDraw.Draw) -> List[List[TextSegment]]:
+    lines = []
+    current_line = []
+    current_width = 0
+    first_in_line = True
+    
+    for segment in segments:
+        if not segment.text:
+            continue
+            
+        font = get_font(segment, regular_font, bold_font, italic_font, bold_italic_font)
+        
+        words = re.split(r'(\s+)', segment.text)
+        
+        for word in words:
+            if not word:
+                continue
+                
+            if re.match(r'\s+', word):
+                if not first_in_line:
+                    current_line.append(TextSegment(word, segment.is_bold, segment.is_italic))
+                    current_width += draw.textlength(word, font=font)
+                continue
+            
+            word_width = draw.textlength(word, font=font)
+            
+            if current_width + word_width <= max_width or first_in_line:
+                current_line.append(TextSegment(word, segment.is_bold, segment.is_italic))
+                current_width += word_width
+                first_in_line = False
+            else:
+                if current_line:
+                    lines.append(current_line)
+                current_line = [TextSegment(word, segment.is_bold, segment.is_italic)]
+                current_width = word_width
+                first_in_line = False
+    
+    if current_line:
+        lines.append(current_line)
+    
+    return lines
+
+def wrap_simple_text(text: str, font: ImageFont.FreeTypeFont, max_width: int, 
+                    draw: ImageDraw.Draw) -> List[str]:
+    words = text.split()
+    lines = []
+    current_line = []
+    
+    for word in words:
+        test_line = ' '.join(current_line + [word])
+        if draw.textlength(test_line, font=font) <= max_width or not current_line:
+            current_line.append(word)
+        else:
+            if current_line:
+                lines.append(' '.join(current_line))
+            current_line = [word]
+    
+    if current_line:
+        lines.append(' '.join(current_line))
+    
+    return lines
+
+def get_responsive_fonts(text: str, regular_font_path: str, bold_font_path: str, 
+                        italic_font_path: str, bold_italic_font_path: str,
+                        max_width: int, max_lines: int, max_font_size: int, min_font_size: int, 
+                        draw: ImageDraw.Draw) -> Tuple[ImageFont.FreeTypeFont, ImageFont.FreeTypeFont, 
+                        ImageFont.FreeTypeFont, ImageFont.FreeTypeFont, List[List[TextSegment]], int]:
+    segments = parse_text_with_formatting(text)
+    current_font_size = max_font_size
+    
+    while current_font_size >= min_font_size:
+        try:
+            fonts = [ImageFont.truetype(path, current_font_size) 
+                    for path in [regular_font_path, bold_font_path, italic_font_path, bold_italic_font_path]]
+            regular_font, bold_font, italic_font, bold_italic_font = fonts
+        except Exception:
+            fonts = [ImageFont.load_default()] * 4
+            regular_font, bold_font, italic_font, bold_italic_font = fonts
+        
+        lines = wrap_text_with_formatting(segments, regular_font, bold_font, italic_font, bold_italic_font, max_width, draw)
+        
+        if len(lines) <= max_lines:
+            return regular_font, bold_font, italic_font, bold_italic_font, lines, current_font_size
+        
+        current_font_size -= 1
+    
+    return regular_font, bold_font, italic_font, bold_italic_font, lines, min_font_size
+
+def get_responsive_single_font(text: str, font_path: str, max_width: int, max_lines: int, 
+                              max_font_size: int, min_font_size: int, draw: ImageDraw.Draw,
+                              format_text: bool = False) -> Tuple[ImageFont.FreeTypeFont, List[str], int]:
+    formatted_text = f"{text}" if format_text else text
+    current_font_size = max_font_size
+    
+    while current_font_size >= min_font_size:
+        try:
+            font = ImageFont.truetype(font_path, current_font_size)
+        except Exception:
+            font = ImageFont.load_default()
+        
+        lines = wrap_simple_text(formatted_text, font, max_width, draw)
+        
+        if len(lines) <= max_lines:
+            return font, lines, current_font_size
+        
+        current_font_size -= 2
+    
+    return font, lines, min_font_size
+
+def draw_formatted_line(draw: ImageDraw.Draw, line_segments: List[TextSegment], 
+                       x: int, y: int, regular_font: ImageFont.FreeTypeFont, 
+                       bold_font: ImageFont.FreeTypeFont, italic_font: ImageFont.FreeTypeFont,
+                       bold_italic_font: ImageFont.FreeTypeFont, color: tuple = (255, 255, 255)):
+    current_x = x
+    
+    for segment in line_segments:
+        font = get_font(segment, regular_font, bold_font, italic_font, bold_italic_font)
+        draw.text((current_x, y), segment.text, font=font, fill=color)
+        current_x += draw.textlength(segment.text, font=font)
+
+def get_text_color_rgb(text_color: str) -> tuple[int, int, int]:
+    """
+    Converte o parâmetro text_color para RGB.
+    """
+    if text_color.lower() == "black":
+        return (0, 0, 0)
+    else:  # white por padrão
+        return (255, 255, 255)
+
+def get_device_dimensions() -> tuple[int, int]:
+    return (1080, 1350)
+
+def add_logo(canvas: Image.Image):
+    try:
+        logo = Image.open("recurve.png").convert("RGBA")
+        logo_resized = logo.resize((121, 23))
+        
+        logo_with_opacity = Image.new("RGBA", logo_resized.size)
+        for x in range(logo_resized.width):
+            for y in range(logo_resized.height):
+                r, g, b, a = logo_resized.getpixel((x, y))
+                logo_with_opacity.putpixel((x, y), (r, g, b, int(a * 0.42)))
+        
+        canvas.paste(logo_with_opacity, (891, 1274), logo_with_opacity)
+    except Exception as e:
+        print(f"Aviso: Erro ao carregar a logo: {e}")
+
+def create_canvas(image_url: Optional[str], text: Optional[str], text_position: str = "bottom",
+                 citation: Optional[str] = None, citation_direction: str = "bottom", 
+                 text_color: str = "white") -> BytesIO:
+    width, height = get_device_dimensions()
+    padding_x, top_padding, citation_text_gap = 60, 60, 15
+    max_width = width - 2 * padding_x
+    text_rgb = get_text_color_rgb(text_color)
+
+    # Validação das combinações de posições
+    if text:
+        valid_combinations = {
+            "top": ["text-bottom", "text-top", "bottom"],
+            "bottom": ["text-top", "text-bottom", "top"]
+        }
+        
+        if citation and citation_direction not in valid_combinations.get(text_position, []):
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Combinação inválida: text_position='{text_position}' com citation_direction='{citation_direction}'. "
+                      f"Para text_position='{text_position}', use citation_direction em: {valid_combinations.get(text_position, [])}"
+            )
+
+    canvas = Image.new("RGBA", (width, height), color=(255, 255, 255, 255))
+
+    if image_url:
+        img = download_image_from_url(image_url)
+        filled_img = resize_and_crop_to_fill(img, width, height)
+        canvas.paste(filled_img, (0, 0))
+
+    # Determinar posições do gradiente e se precisa expandir
+    # Só aplicar gradiente se o texto não for preto
+    gradient_positions = []
+    needs_expanded_gradient = False
+    
+    if text_color.lower() != "black":
+        if text and text_position.lower() == "bottom":
+            gradient_positions.append("bottom")
+            # Se há citação com text-top, expande o gradiente bottom
+            if citation and citation_direction.lower() == "text-top":
+                needs_expanded_gradient = True
+        elif text and text_position.lower() == "top":
+            gradient_positions.append("top")
+            # Se há citação com text-bottom, expande o gradiente top
+            if citation and citation_direction.lower() == "text-bottom":
+                needs_expanded_gradient = True
+        
+        # Adicionar gradientes para citações em posições fixas
+        if citation and citation_direction.lower() == "top" and "top" not in gradient_positions:
+            gradient_positions.append("top")
+        elif citation and citation_direction.lower() == "bottom" and "bottom" not in gradient_positions:
+            gradient_positions.append("bottom")
+    
+    if gradient_positions:
+        gradient_overlay = create_gradient_overlay(width, height, gradient_positions, needs_expanded_gradient)
+        canvas = Image.alpha_composite(canvas, gradient_overlay)
+
+    add_logo(canvas)
+
+    if text or citation:
+        canvas_rgb = canvas.convert("RGB")
+        draw = ImageDraw.Draw(canvas_rgb)
+        
+        font_paths = {
+            'regular': "fonts/WorkSans-Regular.ttf",
+            'bold': "fonts/WorkSans-SemiBold.ttf",
+            'italic': "fonts/WorkSans-Italic.ttf",
+            'bold_italic': "fonts/WorkSans-SemiBoldItalic.ttf",
+            'citation': "fonts/AGaramondPro-Semibold.ttf"
+        }
+
+        text_lines, text_height, citation_lines, citation_height = [], 0, [], 0
+        
+        if text:
+            try:
+                regular_font, bold_font, italic_font, bold_italic_font, text_lines, font_size = get_responsive_fonts(
+                    text, font_paths['regular'], font_paths['bold'], font_paths['italic'], 
+                    font_paths['bold_italic'], max_width, 5, 35, 15, draw
+                )
+                text_height = len(text_lines) * int(font_size * 1.2)
+            except Exception:
+                text_lines = [[TextSegment(word, False, False) for word in text.split()]]
+                text_height = 40
+
+        if citation:
+            try:
+                citation_font, citation_lines, citation_font_size = get_responsive_single_font(
+                    citation, font_paths['citation'], max_width, 3, 60, 30, draw, True
+                )
+                citation_height = len(citation_lines) * int(citation_font_size * 1.05)
+            except Exception:
+                citation_lines = [citation]
+                citation_height = 40
+
+        # Calcular posições respeitando os limites da imagem
+        text_y = citation_y = 0
+        bottom_limit = 1274 - 50  # Limite inferior (antes da logo)
+        
+        if text and citation:
+            # Calcular espaço total necessário quando há texto e citação
+            total_gap = citation_text_gap if citation_direction in ["text-top", "text-bottom"] else 0
+            total_content_height = text_height + citation_height + total_gap
+            
+            if citation_direction.lower() == "text-top":
+                # Citação acima do texto
+                if text_position.lower() == "bottom":
+                    # Posicionar do bottom para cima
+                    text_y = min(bottom_limit - text_height, bottom_limit - text_height)
+                    citation_y = text_y - citation_text_gap - citation_height
+                    # Verificar se vaza pelo topo
+                    if citation_y < top_padding:
+                        # Reajustar para caber tudo
+                        available_height = bottom_limit - top_padding
+                        if total_content_height <= available_height:
+                            citation_y = top_padding
+                            text_y = citation_y + citation_height + citation_text_gap
+                else:  # text top
+                    # Posicionar do top para baixo
+                    citation_y = top_padding
+                    text_y = citation_y + citation_height + citation_text_gap
+                    # Verificar se vaza pelo bottom
+                    if text_y + text_height > bottom_limit:
+                        # Reajustar para caber tudo
+                        available_height = bottom_limit - top_padding
+                        if total_content_height <= available_height:
+                            text_y = bottom_limit - text_height
+                            citation_y = text_y - citation_text_gap - citation_height
+            
+            elif citation_direction.lower() == "text-bottom":
+                # Citação abaixo do texto
+                if text_position.lower() == "bottom":
+                    # Posicionar do bottom para cima
+                    citation_y = bottom_limit - citation_height
+                    text_y = citation_y - citation_text_gap - text_height
+                    # Verificar se vaza pelo topo
+                    if text_y < top_padding:
+                        # Reajustar para caber tudo
+                        available_height = bottom_limit - top_padding
+                        if total_content_height <= available_height:
+                            text_y = top_padding
+                            citation_y = text_y + text_height + citation_text_gap
+                else:  # text top
+                    # Posicionar do top para baixo
+                    text_y = top_padding
+                    citation_y = text_y + text_height + citation_text_gap
+                    # Verificar se vaza pelo bottom
+                    if citation_y + citation_height > bottom_limit:
+                        # Reajustar para caber tudo
+                        available_height = bottom_limit - top_padding
+                        if total_content_height <= available_height:
+                            citation_y = bottom_limit - citation_height
+                            text_y = citation_y - citation_text_gap - text_height
+            
+            elif citation_direction.lower() == "top":
+                # Citação no topo, texto na posição original
+                citation_y = top_padding
+                if text_position.lower() == "bottom":
+                    text_y = bottom_limit - text_height
+                else:
+                    # Evitar sobreposição
+                    text_y = max(top_padding + citation_height + citation_text_gap, top_padding)
+            
+            elif citation_direction.lower() == "bottom":
+                # Citação no bottom, texto na posição original
+                citation_y = bottom_limit - citation_height
+                if text_position.lower() == "top":
+                    text_y = top_padding
+                else:
+                    # Evitar sobreposição
+                    text_y = min(bottom_limit - text_height, citation_y - citation_text_gap - text_height)
+        
+        elif text:
+            # Apenas texto, posições fixas originais
+            if text_position.lower() == "bottom":
+                text_y = bottom_limit - text_height
+            else:
+                text_y = top_padding
+        
+        elif citation:
+            # Apenas citação
+            if citation_direction.lower() == "top":
+                citation_y = top_padding
+            elif citation_direction.lower() == "bottom":
+                citation_y = bottom_limit - citation_height
+
+        # Desenhar citação
+        if citation_lines:
+            line_height = int(citation_font_size * 1.05) if 'citation_font_size' in locals() else 40
+            for i, line in enumerate(citation_lines):
+                draw.text((padding_x, citation_y + i * line_height), line, 
+                         font=citation_font if 'citation_font' in locals() else ImageFont.load_default(), 
+                         fill=text_rgb)
+
+        # Desenhar texto
+        if text_lines:
+            line_height = int(font_size * 1.2) if 'font_size' in locals() else 40
+            for i, line in enumerate(text_lines):
+                if 'regular_font' in locals():
+                    draw_formatted_line(draw, line, padding_x, text_y + i * line_height, 
+                                      regular_font, bold_font, italic_font, bold_italic_font, text_rgb)
+                else:
+                    draw.text((padding_x, text_y + i * line_height), ' '.join([s.text for s in line]), 
+                             font=ImageFont.load_default(), fill=text_rgb)
+        
+        canvas = canvas_rgb.convert("RGBA")
+
+    buffer = BytesIO()
+    canvas.convert("RGB").save(buffer, format="PNG")
+    buffer.seek(0)
+    return buffer
+
+def create_cover_canvas(image_url: Optional[str], title: Optional[str], title_position: str = "bottom",
+                       text_color: str = "white") -> BytesIO:
+    width, height = get_device_dimensions()
+    padding_x, top_padding = 60, 60
+    max_width = width - 2 * padding_x
+    text_rgb = get_text_color_rgb(text_color)
+
+    canvas = Image.new("RGBA", (width, height), color=(255, 255, 255, 255))
+
+    if image_url:
+        img = download_image_from_url(image_url)
+        filled_img = resize_and_crop_to_fill(img, width, height)
+        canvas.paste(filled_img, (0, 0))
+
+    gradient_positions = []
+    # Só aplicar gradiente se o texto não for preto
+    if title and text_color.lower() != "black":
+        gradient_positions.append(title_position.lower())
+    
+    if gradient_positions:
+        gradient_overlay = create_gradient_overlay(width, height, gradient_positions)
+        canvas = Image.alpha_composite(canvas, gradient_overlay)
+
+    add_logo(canvas)
+
+    if title:
+        canvas_rgb = canvas.convert("RGB")
+        draw = ImageDraw.Draw(canvas_rgb)
+        
+        try:
+            title_font, title_lines, title_font_size = get_responsive_single_font(
+                title, "fonts/AGaramondPro-Regular.ttf", max_width, 3, 85, 40, draw
+            )
+            title_line_height = int(title_font_size * 1.2)
+            title_height = len(title_lines) * title_line_height
+        except Exception:
+            title_font = ImageFont.load_default()
+            title_lines = [title]
+            title_line_height = title_height = 50
+
+        title_y = (1274 - 50 - title_height) if title_position.lower() == "bottom" else top_padding
+
+        for i, line in enumerate(title_lines):
+            draw.text((padding_x, title_y + i * title_line_height), line, font=title_font, fill=text_rgb)
+        
+        canvas = canvas_rgb.convert("RGBA")
+
+    buffer = BytesIO()
+    canvas.convert("RGB").save(buffer, format="PNG")
+    buffer.seek(0)
+    return buffer
+
+@router.get("/create/image")
+def get_news_image(
+    image_url: Optional[str] = Query(None, description="URL da imagem de fundo"),
+    text: Optional[str] = Query(None, description="Texto com suporte a tags <strong>"),
+    text_position: str = Query("bottom", description="Posição do texto: 'top' para topo ou 'bottom' para parte inferior"),
+    citation: Optional[str] = Query(None, description="Texto da citação"),
+    citation_direction: str = Query("bottom", description="Posição da citação: 'top', 'bottom' ou 'text-top'"),
+    text_color: str = Query("white", description="Cor do texto: 'white' (padrão) ou 'black'. Se 'black', remove o gradiente de fundo")
+):
+    try:
+        buffer = create_canvas(image_url, text, text_position, citation, citation_direction, text_color)
+        return StreamingResponse(buffer, media_type="image/png")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao gerar imagem: {str(e)}")
+
+@router.get("/create/cover/image")
+def get_cover_image(
+    image_url: Optional[str] = Query(None, description="URL da imagem de fundo"),
+    title: Optional[str] = Query(None, description="Título da capa"),
+    title_position: str = Query("bottom", description="Posição do título: 'top' para topo ou 'bottom' para parte inferior"),
+    text_color: str = Query("white", description="Cor do texto: 'white' (padrão) ou 'black'. Se 'black', remove o gradiente de fundo")
+):
+    try:
+        buffer = create_cover_canvas(image_url, title, title_position, text_color)
+        return StreamingResponse(buffer, media_type="image/png")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao gerar imagem: {str(e)}")

routers/inference.py

@@ -0,0 +1,566 @@
+import os
+import logging
+import json
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from google import genai
+from google.genai import types
+from datetime import datetime
+from zoneinfo import ZoneInfo
+import locale
+import re
+
+# Configurar logging
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class NewsRequest(BaseModel):
+    content: str
+
+class NewsResponse(BaseModel):
+    title: str
+    subhead: str
+    content: str
+    sources: list[str]  # Lista de URLs/links utilizados
+
+def get_brazilian_date_string():
+    """
+    Retorna a data atual formatada em português brasileiro.
+    Implementa fallbacks robustos para diferentes sistemas operacionais.
+    """
+    try:
+        # Tenta configurar o locale brasileiro
+        locale_variants = [
+            'pt_BR.UTF-8',      # Linux/macOS padrão
+            'pt_BR.utf8',       # Algumas distribuições Linux
+            'pt_BR',            # Fallback sem encoding
+            'Portuguese_Brazil.1252',  # Windows
+            'Portuguese_Brazil',       # Windows alternativo
+            'pt_BR.ISO8859-1',        # Encoding alternativo
+        ]
+        
+        locale_set = False
+        for loc in locale_variants:
+            try:
+                locale.setlocale(locale.LC_TIME, loc)
+                locale_set = True
+                logger.info(f"Locale configurado com sucesso: {loc}")
+                break
+            except locale.Error:
+                logger.debug(f"Locale {loc} não disponível")
+                continue
+        
+        if not locale_set:
+            logger.warning("Nenhum locale brasileiro encontrado, usando locale padrão")
+            locale.setlocale(locale.LC_TIME, '')  # Usa locale padrão do sistema
+        
+        # Obtém a data atual no fuso horário de São Paulo
+        now = datetime.now(ZoneInfo("America/Sao_Paulo"))
+        
+        # Dicionários para tradução manual (fallback caso locale não funcione)
+        meses = {
+            1: 'janeiro', 2: 'fevereiro', 3: 'março', 4: 'abril',
+            5: 'maio', 6: 'junho', 7: 'julho', 8: 'agosto',
+            9: 'setembro', 10: 'outubro', 11: 'novembro', 12: 'dezembro'
+        }
+        
+        dias_semana = {
+            0: 'segunda-feira', 1: 'terça-feira', 2: 'quarta-feira', 
+            3: 'quinta-feira', 4: 'sexta-feira', 5: 'sábado', 6: 'domingo'
+        }
+        
+        try:
+            # Tenta usar strftime com locale configurado
+            if locale_set:
+                # Para sistemas Unix/Linux usa %-d (sem zero à esquerda)
+                try:
+                    date_string = now.strftime("%-d de %B de %Y (%A)")
+                except ValueError:
+                    # Para Windows usa %#d
+                    try:
+                        date_string = now.strftime("%#d de %B de %Y (%A)")
+                    except ValueError:
+                        # Fallback: usa %d e remove zero manualmente se necessário
+                        date_string = now.strftime("%d de %B de %Y (%A)")
+                        if date_string.startswith('0'):
+                            date_string = date_string[1:]
+                
+                # Força dia da semana em minúscula
+                date_string = date_string.replace(date_string.split('(')[1].split(')')[0], 
+                                                date_string.split('(')[1].split(')')[0].lower())
+            else:
+                # Fallback manual completo
+                dia = now.day
+                mes = meses[now.month]
+                ano = now.year
+                dia_semana = dias_semana[now.weekday()]
+                date_string = f"{dia} de {mes} de {ano} ({dia_semana})"
+                
+        except Exception as e:
+            logger.warning(f"Erro ao formatar data com locale: {e}")
+            # Fallback manual completo em caso de erro
+            dia = now.day
+            mes = meses[now.month]
+            ano = now.year
+            dia_semana = dias_semana[now.weekday()]
+            date_string = f"{dia} de {mes} de {ano} ({dia_semana})"
+        
+        logger.info(f"Data detectada e formatada: {date_string}")
+        return date_string
+        
+    except Exception as e:
+        logger.error(f"Erro crítico na formatação de data: {e}")
+        # Último fallback: data em inglês
+        now = datetime.now(ZoneInfo("America/Sao_Paulo"))
+        date_string = now.strftime("%d de %B de %Y")
+        logger.warning(f"Usando fallback de data: {date_string}")
+        return date_string
+
+def safe_json_serialize(obj):
+    """Converte objeto em JSON de forma segura para logging"""
+    try:
+        return json.dumps(obj, indent=2, ensure_ascii=False, default=str)
+    except Exception as e:
+        logger.warning(f"Erro ao serializar objeto para JSON: {e}")
+        return str(obj)
+
+def extract_text_from_response(response):
+    """
+    Extrai o texto da resposta de forma robusta, lidando com diferentes estruturas possíveis.
+    """
+    response_text = ""
+    
+    # Método 1: Tentar response.text diretamente
+    if hasattr(response, 'text') and response.text:
+        response_text = response.text
+        logger.info(f"Texto extraído via response.text: {len(response_text)} caracteres")
+        return response_text
+    
+    # Método 2: Tentar extrair dos candidates
+    if hasattr(response, 'candidates') and response.candidates:
+        for i, candidate in enumerate(response.candidates):
+            logger.debug(f"Processando candidate {i}")
+            
+            if not hasattr(candidate, 'content') or not candidate.content:
+                logger.debug(f"Candidate {i} não tem content válido")
+                continue
+                
+            content = candidate.content
+            
+            # Verificar se content tem parts e se não é None
+            if not hasattr(content, 'parts') or content.parts is None:
+                logger.debug(f"Candidate {i} content.parts é None ou não existe")
+                continue
+                
+            # Iterar pelas parts de forma segura
+            try:
+                parts_list = list(content.parts) if content.parts else []
+                logger.debug(f"Candidate {i} tem {len(parts_list)} parts")
+                
+                for j, part in enumerate(parts_list):
+                    if hasattr(part, 'text') and part.text:
+                        response_text += part.text
+                        logger.debug(f"Texto adicionado do candidate {i}, part {j}: {len(part.text)} chars")
+                        
+            except Exception as e:
+                logger.warning(f"Erro ao processar parts do candidate {i}: {e}")
+                continue
+    
+    # Método 3: Tentar atributos alternativos
+    if not response_text and hasattr(response, 'candidates'):
+        for i, candidate in enumerate(response.candidates):
+            for attr_name in ['output', 'generated_text', 'text_content']:
+                if hasattr(candidate, attr_name):
+                    attr_value = getattr(candidate, attr_name)
+                    if attr_value and str(attr_value).strip():
+                        response_text += str(attr_value)
+                        logger.info(f"Texto encontrado em candidate.{attr_name}")
+                        break
+    
+    logger.info(f"Texto total extraído: {len(response_text)} caracteres")
+    return response_text
+
+def extract_sources_from_response(response):
+    """
+    Extrai as fontes (URLs) do grounding metadata de forma robusta.
+    """
+    sources = []
+    
+    if not (hasattr(response, 'candidates') and response.candidates):
+        logger.debug("Response não tem candidates")
+        return sources
+    
+    for i, candidate in enumerate(response.candidates):
+        if not (hasattr(candidate, 'grounding_metadata') and candidate.grounding_metadata):
+            logger.debug(f"Candidate {i} não tem grounding_metadata")
+            continue
+        
+        grounding_metadata = candidate.grounding_metadata
+        logger.debug(f"Processando grounding_metadata do candidate {i}")
+        
+        # Verificar grounding_chunks
+        if hasattr(grounding_metadata, 'grounding_chunks') and grounding_metadata.grounding_chunks:
+            logger.debug(f"Encontrados {len(grounding_metadata.grounding_chunks)} grounding_chunks")
+            
+            for j, chunk in enumerate(grounding_metadata.grounding_chunks):
+                try:
+                    if (hasattr(chunk, 'web') and chunk.web and 
+                        hasattr(chunk.web, 'uri') and chunk.web.uri):
+                        
+                        uri = chunk.web.uri
+                        if uri and uri not in sources:
+                            sources.append(uri)
+                            logger.debug(f"Fonte adicionada do chunk {j}: {uri}")
+                            
+                except Exception as e:
+                    logger.warning(f"Erro ao processar chunk {j}: {e}")
+                    continue
+        
+        # Verificar search_entry_point (método alternativo)
+        if hasattr(grounding_metadata, 'search_entry_point') and grounding_metadata.search_entry_point:
+            logger.debug("Search entry point encontrado")
+            # Aqui você pode adicionar lógica adicional se necessário
+    
+    logger.info(f"Total de fontes únicas encontradas: {len(sources)}")
+    return sources
+
+@router.post("/rewrite-news", response_model=NewsResponse)
+async def rewrite_news(news: NewsRequest):
+    """
+    Endpoint para reescrever notícias usando o modelo Gemini.
+    """
+    try:
+        logger.info(f"Iniciando reescrita de notícia com {len(news.content)} caracteres")
+        
+        # Verificar se a API key está configurada
+        api_key = os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            logger.error("GEMINI_API_KEY não encontrada nas variáveis de ambiente")
+            raise HTTPException(status_code=500, detail="API key não configurada")
+        
+        client = genai.Client(api_key=api_key)
+        model = "gemini-2.5-pro"
+        
+        # Obter data formatada
+        date_string = get_brazilian_date_string()
+        logger.info(f"Usando data: {date_string}")
+        
+        # Instruções do sistema
+        SYSTEM_INSTRUCTIONS = f"""
+Você é um jornalista de entretenimento brasileiro, escrevendo para portais digitais modernos. Sua missão é transformar notícias internacionais em matérias originais, atualizadas e envolventes para o público brasileiro.
+
+ESTILO DE ESCRITA:
+
+- Tom natural, direto e conversacional, sem frases feitas ou jargões jornalísticos
+- Varie estruturas e conectivos para evitar robotização. Ou seja, sem frases redundantes, exemplo: "destacando como a experiência pode ser um divisor de águas profissional", "reafirma a força criativa do país no cenário global", "A revelação contextualizou não apenas sua performance na dança, mas também". É para noticiar a notícia de fato, sempre buscando mais informações que se conectam, e não opiniões pessoais.
+- Sem linguagem militante ou juízos morais: mantenha tom informativo e predominantemente conservador
+- Evite opiniões genéricas; foque em fatos e contexto
+
+CONTEÚDO E ABORDAGEM:
+
+- Use a notícia-base como ponto de partida, não como roteiro
+- PESQUISE SEMPRE usando a ferramenta de busca, Variety, THR, Deadline e fontes confiáveis em inglês
+- Traga dados extras, contexto histórico e informações relevantes
+- Sempre que possível, inclua títulos de obras em Português do Brasil
+
+ESTRUTURA E FORMATAÇÃO:
+
+- Comece com um lead que já entrega o essencial
+- Desenvolva com profundidade, conectando com outros fatos e entregando contexto completo, principalmente no cenário brasileiro
+- Termine com uma informação concreta (data, lançamento, próximos passos), nunca com opinião genérica. Ou seja, a conclusão da noticia deve ser com mais noticia, sem redundância genérica e robótica
+- Otimize para leitura digital e SEO (parágrafos bem segmentados, palavras chaves, etc)
+
+FORMATO:
+
+<headline>título aqui</headline>
+<subhead>subtítulo aqui</subhead>  
+<body>conteúdo aqui</body>
+
+Use <strong> para destaques e <em> para títulos de obras ou citações. Apenas. Mais tags estão estritamente proibidas.
+
+TÍTULOS:
+
+- Padrão brasileiro: só a primeira palavra em maiúscula (exceto nomes próprios e títulos de filmes/séries)
+- Seja claro, direto e específico... Se houver, não inclua spoilers no título, apenas no body
+
+OBRIGAÇÕES:
+
+1. É obrigatório usar a ferramenta de busca para complementar a notícia se no prompt, contiver /google.
+2. Traga sempre informações novas e contextualizadas.
+
+O resultado deve soar como uma matéria escrita por um profissional experiente, não por IA. Seja preciso, atual e interessante. Sempre pesquise informações adicionais se no prompt contiver /google, isso é obrigatório. Sempre complete a notícia com acontecimentos que se ligam, sempre contextualize tudo para o leitor. A data de hoje é {date_string}
+"""
+
+        # Primeiro exemplo
+        EXAMPLE_INPUT_1 = """
+/google News base: Ed Helms revealed in an interview that he was nervous about his parents' reaction to the film The Hangover, but in the end everything worked out and her mother loved the movie. The article is out of date, more information is needed.
+"""
+
+        EXAMPLE_OUTPUT_1 = """<headline>"Se Beber, Não Case!": Ed Helms, o Dr. Stuart, revela medo do que os pais iriam pensar, mas tudo deu certo</headline>
+<subhead>Em uma carreira repleta de surpresas e sucesso internacional, o ator relembra o nervosismo que antecedeu a estreia da comédia que o tornou famoso.</subhead>
+<body>
+<p><strong>Ed Helms</strong> nunca escondeu o fato de que sua participação em <strong>Se Beber, Não Case!</strong> foi um choque cultural, especialmente para seus pais. Em uma entrevista recente ao podcast de <strong>Ted Danson</strong>, <em>Where Everybody Knows Your Name</em>, o ator falou sobre a ansiedade que sentiu ao imaginar a reação da família à comédia para maiores que o transformou em astro de cinema.</p>
+<p>Helms, que foi criado em um lar sulista com valores socialmente conservadores, revelou que, embora o ambiente fosse politicamente progressista, algumas situações, como dentes arrancados, casamentos embriagados e até tigres no banheiro, eram muito diferentes do que seus pais consideravam apropriado. O ator brincou: <em>"Não foi pra isso que me criaram"</em>, fazendo alusão ao enredo caótico do filme de 2009. Ele acrescentou que, embora seus pais já tivessem assistido a algumas de suas performances em programas como <em>The Daily Show</em> e <em>The Office</em>, o que ajudou a criar certa tolerância, o filme ainda o deixava nervoso.</p>
+<p>Estrelando sua primeira grande produção, Helms levou os pais para a estreia quando tinha 35 anos. No entanto, foi surpreendido ao ver sua mãe chorando quando as luzes se acenderam. <em>"Pensei: 'Pronto. Acabei de partir o coração da minha mãe'"</em>, recordou. O momento de tensão, porém, durou pouco: ela o tranquilizou dizendo que o filme havia sido hilário.</p>
+<p><strong>Se Beber, Não Case!</strong>, dirigido por <strong>Todd Phillips</strong>, foi um sucesso comercial, arrecadando aproximadamente <strong>469 milhões de dólares</strong> em todo o mundo e se tornando a comédia para maiores de classificação indicativa de maior bilheteria até então. A popularidade do filme resultou em duas sequências, lançadas em 2011 e 2013, e consolidou o "bando de lobos" formado por <strong>Helms</strong>, <strong>Bradley Cooper</strong> e <strong>Zach Galifianakis</strong> como um dos times cômicos mais icônicos do cinema moderno.</p>
+<p>Sobre a possibilidade de um quarto filme, <strong>Bradley Cooper</strong> afirmou em 2023 que toparia participar sem hesitar, principalmente pela chance de reencontrar colegas e diretor. Ainda assim, reconheceu que o projeto é improvável, já que <strong>Phillips</strong> está atualmente focado em empreendimentos de maior escala, como a série de filmes <em>Coringa</em>.</p>
+</body>"""
+
+        # Segundo exemplo
+        EXAMPLE_INPUT_2 = """
+/google News base: The Office spinoff series 'The Paper' has set a September premiere date at Peacock.
+
+The new mockumentary series from Greg Daniels and Michael Koman will debut Sept. 4 on Peacock, the streamer announced Thursday. The first four episodes of 'The Paper' will premiere on Sept. 4, with two new episodes dropping every Thursday through Sept. 25.
+
+'The Paper' follows the documentary crew that immortalized Dunder Mifflin's Scranton branch in 'The Office' as they find a new subject when they discover a historic Midwestern newspaper and the publisher trying to revive it, according to the official logline.
+
+'The Office' fan-favorite Oscar Nuñez returns to the franchise in 'The Paper,' joining series regulars Domhnall Gleeson, Sabrina Impacciatore, Chelsea Frei, Melvin Gregg, Gbemisola Ikumelo, Alex Edelman, Ramona Young and Tim Key.
+
+Guest stars for the show include Eric Rahill, Tracy Letts, Molly Ephraim, Mo Welch, Allan Havey, Duane Shepard Sr., Nate Jackson and Nancy Lenehan.
+
+'The Paper' was created by Daniels, who created 'The Office,' under his banner Deedle-Dee Productions, and Koman, who has written on 'Nathan for You' and 'SNL.' Produced by Universal Television, a division of Universal Studio Group, 'The Paper' is executive produced by Ricky Gervais, Stephen Merchant, Howard Klein, Ben Silverman and Banijay Americas (formerly Reveille).
+
+Daniels serves as a director on the show alongside Ken Kwapis, Yana Gorskaya, Paul Lieberstein, Tazbah Chavez, Jason Woliner, Jennifer Celotta, Matt Sohn, Dave Rogers and Jeff Blitz.
+
+'The Office' launched in 2005 on NBC and ran for nine seasons leading up to the series finale in 2013. The cast of the beloved sitcom included Steve Carell, Rainn Wilson, John Krasinski, Jenna Fischer, Mindy Kaling and B.J. Novak, among others. The article is out of date, more information is needed.
+"""
+
+        EXAMPLE_OUTPUT_2 = """<headline>Nova série do universo 'The Office' ganha título, data de estreia e um rosto familiar</headline>
+<subhead>Intitulada 'The Paper', produção de Greg Daniels e Michael Koman chega em setembro com Domhnall Gleeson, Sabrina Impacciatore e o retorno de Oscar Nuñez</subhead>
+<body>
+<p>A equipe original de documentaristas de <em>"Insane Daily Life at Dunder Mifflin"</em> voltou ao trabalho, desta vez mudando para uma nova história, três anos após o fim de <em>"The Office"</em>. Após uma década de espera, o derivado da amada série de comédia finalmente saiu do papel e será lançado em <strong>4 de setembro de 2025</strong>. O nome do derivado é <em>"The Paper"</em> e estará disponível na plataforma de streaming <strong>Peacock</strong>.</p>
+<p>A trama agora se desloca da fictícia <strong>Scranton, Pensilvânia</strong>, para o escritório de um jornal histórico, porém problemático, localizado no meio-oeste dos Estados Unidos, focando em um jornal em dificuldades na região. A equipe busca uma nova história após cobrir a vida de <strong>Michael Scott</strong> e <strong>Dwight Schrute</strong>. Agora, a equipe acompanha o <strong>Toledo Truth Teller</strong>, um jornal em <strong>Toledo, Ohio</strong>, e o editor que tenta reviver o jornal com a ajuda de repórteres voluntários.</p>
+<p>O novo elenco conta com <strong>Domhnall Gleeson</strong>, ator irlandês famoso por <em>"Ex Machina"</em> e <em>"Questão de Tempo"</em>, ao lado da atriz italiana <strong>Sabrina Impacciatore</strong>, que ganhou amplo reconhecimento por seu papel na segunda temporada de <em>"The White Lotus"</em>. Gleeson interpreta o novo editor otimista do jornal, enquanto Impacciatore atua como gerente de redação.</p>
+<p>Nas entrevistas mais recentes, Gleeson tenta se distanciar das comparações com o gerente da <strong>Dunder Mifflin</strong>. <em>"Acho que se você tentar competir com o que Steve [Carell] ou Ricky Gervais fizeram, seria um enorme erro,"</em> enfatizou o ator, visando construir uma persona totalmente nova. Ele também revelou ter recebido um tipo de conselho de <strong>John Krasinski</strong> e até de <strong>Steve Carell</strong> para aceitar o papel, especialmente porque se tratava de um projeto de <strong>Greg Daniels</strong>.</p>
+<p>Como <em>"The Paper"</em> está reintroduzindo os personagens originais, os fãs de longa data da série parecem estar encantados, já que também traz <strong>Oscar Nuñez</strong> reprisando seu papel como o contador <strong>Oscar Martinez</strong>. Oscar, que estava iniciando uma carreira política em <em>"The Office"</em>, agora parece ter se mudado para <strong>Toledo</strong>. <em>"Eu disse ao Sr. Greg Daniels que, se Oscar voltasse, ele provavelmente estaria morando em uma cidade mais agitada e cosmopolita. Greg me ouviu e mudou Oscar para Toledo, Ohio, que tem três vezes a população de Scranton. Então, foi bom ser ouvido"</em>, brincou Nuñez durante um evento da <strong>NBCUniversal</strong>.</p>
+<p><strong>Greg Daniels</strong>, que anteriormente adaptou <em>"The Office"</em> para o público americano, está em parceria com <strong>Michael Koman</strong>, cocriador de <em>"Nathan for You"</em>, para este novo projeto. Koman e Daniels, junto com <strong>Ricky Gervais</strong> e <strong>Stephen Merchant</strong>, criadores da série britânica original, formam a equipe de produção executiva.</p>
+<p>A primeira temporada de <em>"The Paper"</em> será dividida em <strong>dez episódios</strong>. Nos Estados Unidos, os <strong>quatro primeiros episódios</strong> estarão disponíveis para streaming em <strong>4 de setembro</strong>. Depois disso, os episódios restantes serão lançados no formato de <strong>dois episódios por semana</strong>, com um total de seis episódios liberados até o final em <strong>25 de setembro</strong>.</p>
+<p>A série ainda não tem data de estreia confirmada no Brasil, mas a expectativa é de que seja lançada no <strong>Universal+</strong>, serviço de streaming que costuma exibir produções do catálogo da <strong>Peacock</strong>.</p>
+</body>"""
+
+        # Terceiro exemplo
+        EXAMPLE_INPUT_3 = """
+/google News base: The first trailer for "Eyes of Wakanda," a four-episode limited animated series executive produced by "Black Panther" director Ryan Coogler, has been released. It will release on Disney+ on Aug. 1.
+
+The upcoming show will be set in Wakanda, the home of the Black Panther that was extensively explored in Coogler's two Marvel movies. The show will follow "the adventures of brave Wakandan warriors throughout history. In this globe-trotting adventure, the heroes must carry-out dangerous missions to retrieve Vibranium artifacts from the enemies of Wakanda. They are the Hatut Zaraze and this is their story."
+
+The voice cast includes Winnie Harlow, Cress Williams, Patricia Belcher, Larry Herron, Adam Gold, Lynn Whitfield, Jacques Colimon, Jona Xiao, Isaac Robinson-Smith, Gary Anthony Williams, Zeke Alton, Steve Toussaint and Anika Noni Rose.
+
+Popular on Variety
+
+The last time fans saw Wakanda was in 2022's "Black Panther: Wakanda Forever," the sequel to Marvel's 2018 best picture nominee. That movie introduced the underwater world of Atlantis and featured the returns of Letitia Wright, Lupita Nyong'o, Angela Bassett, Winston Duke, Danai Gurira and Martin Freeman. Wakandans have popped up in other places in the MCU, including an appearance by Ayo, played by Florence Kasumba, in the Disney+ series "The Falcon and The Winter Soldier." The second-in-command of the Dora Milaje, Ayo first appeared in "Captain America: Civil War."
+
+The "Wakanda" series is the first in a multi-year overall TV deal with Coogler's Proximity production company and The Walt Disney Company, with other TV projects in currently in development for the MCU.
+
+"Eyes of Wakanda" is helmed by director/executive producer Todd Harris, who was first a storyboard artist on "Black Panther" and "Black Panther: Wakanda Forever" then as an illustrator on "Sinners" before directing "Eyes of Wakanda." The show is executive produced by Coogler, Brad Winderbaum, Kevin Feige, Louis D'Esposito and Dana Vasquez-Eberhardt.
+
+The article is out of date, more information is needed.
+"""
+
+        EXAMPLE_OUTPUT_3 = """<headline>Olhos de Wakanda: nova animação da Marvel ganha trailer e data de estreia</headline>
+<subhead>A série de Ryan Coogler vai mergulhar na história do reino de T'Challa e nas missões secretas de seus guerreiros para proteger o vibranium.</subhead>
+<body>
+<p>A <strong>Marvel Studios</strong> acaba de publicar o primeiro trailer da sua próxima série animada, <em>Olhos de Wakanda</em>, que explora a história do avançado reino africano. Foi anunciado que a série terá produção executiva de <strong>Ryan Coogler</strong>, diretor dos filmes do <strong>Pantera Negra</strong>, e será lançada como uma minissérie em quatro partes no dia <strong>1º de agosto</strong> no <strong>Disney Plus</strong>. A data é um pouco surpreendente, pois o lançamento estava inicialmente marcado para <strong>27 de agosto</strong>.</p>
+<p>A narrativa acompanhará as façanhas dos <strong>Hatut Zaraze</strong>, os guerreiros de elite de <strong>Wakanda</strong>, enquanto embarcam em missões globais para recuperar artefatos de <strong>vibranium</strong> roubados. Conhecida nos quadrinhos como os <em>"Cães de Guerra"</em>, essa força secreta atua como uma agência clandestina, protegendo os recursos e inovações ocultas da nação. Os ancestrais de <strong>T'Challa</strong> serão ainda mais explorados na série, mostrando como eles, junto de seus descendentes, forjaram o legado do <strong>Pantera Negra</strong>, que ele um dia herdará, ao longo de séculos de defesa, em arcos cronológicos marcantes.</p>
+<p><strong>Todd Harris</strong>, que trabalhou como artista de storyboard nos filmes da franquia, criou e dirigiu a obra, que terá um visual distinto, separado das adaptações. Segundo Harris, a trama integra espionagem com eventos históricos, começando no final da <strong>Idade do Bronze</strong> e se estendendo por séculos. O diretor acrescentou: <em>"Você tem um James Bond com a qualidade de Wakanda e às vezes uma Jane Bond com toda a grandiosidade visual e cultural que a nação representa."</em></p>
+<p><strong>Winnie Harlow</strong>, <strong>Cress Williams</strong>, <strong>Patricia Belcher</strong>, <strong>Lynn Whitfield</strong> e <strong>Anika Noni Rose</strong> fazem parte do elenco de vozes. Além de expandir a mitologia de <strong>Wakanda</strong> dentro do <strong>MCU</strong>, a série também apresentará uma versão ancestral do herói <strong>Punho de Ferro</strong>. <strong>Brad Winderbaum</strong>, chefe de TV e streaming da <strong>Marvel Studios</strong>, confirmou que <em>Olhos de Wakanda</em> estará profundamente integrada com a linha do tempo principal do <strong>MCU</strong>.</p>
+<p>A produtora de <strong>Coogler</strong>, <strong>Proximity Media</strong>, e a <strong>Disney</strong> têm um acordo televisivo de vários anos que inclui a produção de outros projetos do <strong>MCU</strong>. No dia da estreia, todos os quatro episódios de <em>Olhos de Wakanda</em> estarão disponíveis ao mesmo tempo.</p>
+</body>"""
+
+        # Configuração correta da ferramenta de pesquisa
+        grounding_tool = types.Tool(
+            google_search=types.GoogleSearch()
+        )
+
+        config = types.GenerateContentConfig(
+            system_instruction=SYSTEM_INSTRUCTIONS,
+            thinking_config=types.ThinkingConfig(
+                thinking_budget=-1,
+            ),
+            tools=[grounding_tool],  # Use a ferramenta corretamente
+            response_mime_type="text/plain",
+            max_output_tokens=4096,
+            temperature=0.8,
+        )
+
+        # Conteúdo da conversa
+        contents = [
+            # Primeiro exemplo: usuário envia uma notícia
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_1)
+                ]
+            ),
+            # Primeiro exemplo: modelo responde com o formato correto
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_1)
+                ]
+            ),
+            # Segundo exemplo: usuário envia outra notícia
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_2)
+                ]
+            ),
+            # Segundo exemplo: modelo responde com o formato correto
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_2)
+                ]
+            ),
+            # Terceiro exemplo: usuário envia outra notícia
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_3)
+                ]
+            ),
+            # Terceiro exemplo: modelo responde com o formato correto
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_3)
+                ]
+            ),
+            # Agora o usuário envia a notícia real para ser reescrita
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=f"/google News base: {news.content}. The article is out of date, more information is needed.")
+                ]
+            )
+        ]
+
+        logger.info("Iniciando geração de conteúdo com o modelo Gemini")
+        
+        # Usar generate_content em vez de generate_content_stream para melhor controle do grounding
+        response = client.models.generate_content(
+            model=model,
+            contents=contents,
+            config=config
+        )
+
+        # =================================
+        # LOGS DETALHADOS DA RESPOSTA BRUTA
+        # =================================
+        logger.info("=== RESPOSTA BRUTA COMPLETA DO GEMINI ===")
+        logger.info(f"Tipo da resposta: {type(response)}")
+        logger.info(f"Resposta completa: {safe_json_serialize(response)}")
+        
+        # Log dos atributos principais
+        logger.info(f"response.text: '{response.text if hasattr(response, 'text') else 'ATRIBUTO text NÃO EXISTE'}'")
+        logger.info(f"response.candidates: {safe_json_serialize(response.candidates) if hasattr(response, 'candidates') else 'ATRIBUTO candidates NÃO EXISTE'}")
+        
+        # Log detalhado dos candidates - COM PROTEÇÃO CONTRA PARTS = None
+        if hasattr(response, 'candidates') and response.candidates:
+            for i, candidate in enumerate(response.candidates):
+                logger.info(f"=== CANDIDATE {i} ===")
+                logger.info(f"Candidate completo: {safe_json_serialize(candidate)}")
+                
+                if hasattr(candidate, 'content'):
+                    logger.info(f"Candidate.content: {safe_json_serialize(candidate.content)}")
+                    
+                    if hasattr(candidate.content, 'parts'):
+                        if candidate.content.parts is None:
+                            logger.warning(f"ATENÇÃO: Candidate {i} content.parts é None!")
+                        else:
+                            try:
+                                parts_list = list(candidate.content.parts)
+                                logger.info(f"Candidate {i} tem {len(parts_list)} parts")
+                                
+                                for j, part in enumerate(parts_list):
+                                    logger.info(f"Part {j}: {safe_json_serialize(part)}")
+                                    if hasattr(part, 'text'):
+                                        logger.info(f"Part {j} text: '{part.text}'")
+                                        
+                            except Exception as e:
+                                logger.error(f"Erro ao processar parts do candidate {i}: {e}")
+                    else:
+                        logger.warning(f"Candidate {i} content não tem atributo 'parts'")
+                
+                if hasattr(candidate, 'finish_reason'):
+                    logger.info(f"Finish reason: {candidate.finish_reason}")
+                
+                if hasattr(candidate, 'safety_ratings'):
+                    logger.info(f"Safety ratings: {safe_json_serialize(candidate.safety_ratings)}")
+                
+                if hasattr(candidate, 'grounding_metadata'):
+                    logger.info(f"Grounding metadata: {safe_json_serialize(candidate.grounding_metadata)}")
+        
+        # Log de outros atributos possíveis
+        for attr in ['usage_metadata', 'prompt_feedback', 'model_version']:
+            if hasattr(response, attr):
+                logger.info(f"response.{attr}: {safe_json_serialize(getattr(response, attr))}")
+        
+        logger.info("=== FIM DA RESPOSTA BRUTA ===")
+
+        # Usar as funções seguras para extração
+        response_text = extract_text_from_response(response)
+        sources = extract_sources_from_response(response)
+        
+        logger.info(f"Resposta do modelo recebida com {len(response_text)} caracteres")
+        logger.info(f"Encontradas {len(sources)} fontes únicas: {sources}")
+
+        # Verificar se o texto está vazio
+        if not response_text or response_text.strip() == "":
+            logger.error("ERRO CRÍTICO: Texto da resposta está vazio!")
+            raise HTTPException(
+                status_code=500, 
+                detail="Modelo não retornou conteúdo válido. Verifique os logs do servidor."
+            )
+
+        # Extração do título, subtítulo e conteúdo usando as tags
+        title_match = re.search(r"<headline>(.*?)</headline>", response_text, re.DOTALL)
+        title = title_match.group(1).strip() if title_match else "Título não encontrado"
+        logger.info(f"Título extraído: '{title}'")
+
+        subhead_match = re.search(r"<subhead>(.*?)</subhead>", response_text, re.DOTALL)
+        subhead = subhead_match.group(1).strip() if subhead_match else "Subtítulo não encontrado"
+        logger.info(f"Subtítulo extraído: '{subhead}'")
+
+        # Extração do conteúdo com lógica mais flexível para <body>
+        body_match = re.search(r"<body>(.*?)</body>", response_text, re.DOTALL)
+        if body_match:
+            content = body_match.group(1).strip()
+        else:
+            body_start_match = re.search(r"<body>(.*)", response_text, re.DOTALL)
+            if body_start_match:
+                content = body_start_match.group(1).strip()
+            else:
+                content = "Conteúdo não encontrado"
+        
+        logger.info(f"Conteúdo extraído: {len(content)} caracteres - '{content[:200]}...' (primeiros 200 chars)")
+
+        # Verificações adicionais
+        if title == "Título não encontrado" or subhead == "Subtítulo não encontrado" or content == "Conteúdo não encontrado":
+            logger.warning("Algumas partes do conteúdo não foram encontradas!")
+            logger.warning(f"Texto completo da resposta: '{response_text}'")
+        
+        logger.info("Artigo reescrito com sucesso")
+        logger.debug(f"Título extraído: {title[:50]}...")
+        logger.debug(f"Subtítulo extraído: {subhead[:50]}...")
+        logger.debug(f"Conteúdo extraído: {len(content)} caracteres")
+        logger.debug(f"Sources encontradas: {sources}")
+
+        # Log adicional para debug
+        logger.info("=== RESULTADO FINAL ===")
+        logger.info(f"Title: '{title}'")
+        logger.info(f"Subhead: '{subhead}'")
+        logger.info(f"Content length: {len(content)}")
+        logger.info(f"Sources count: {len(sources)}")
+
+        return NewsResponse(title=title, subhead=subhead, content=content, sources=sources)
+
+    except HTTPException:
+        # Re-lança HTTPExceptions para manter o status code correto
+        raise
+    except Exception as e:
+        error_msg = f"Erro na reescrita: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        raise HTTPException(status_code=500, detail=error_msg)

routers/instagram.py

@@ -0,0 +1,368 @@
+import os
+import httpx
+from typing import Dict, Optional, Tuple
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter()
+
+# 📱 Instagram API Config
+INSTAGRAM_API_BASE = "https://graph.instagram.com/v23.0"
+INSTAGRAM_PAGE_ID = "17841464166934843"  # Seu Page ID
+INSTAGRAM_TOKEN = os.getenv("INSTAGRAM_ACCESS_TOKEN")
+
+if not INSTAGRAM_TOKEN:
+    raise ValueError("❌ INSTAGRAM_ACCESS_TOKEN não foi definido nas variáveis de ambiente!")
+
+# 📝 Modelos de dados
+class InstagramPost(BaseModel):
+    image_url: str
+    caption: Optional[str] = None
+
+class PublishResponse(BaseModel):
+    success: bool
+    media_id: Optional[str] = None
+    post_id: Optional[str] = None
+    post_url: Optional[str] = None
+    message: str
+    comment_posted: bool = False
+    comment_id: Optional[str] = None
+
+def convert_to_bold_unicode(text: str) -> str:
+    """
+    Converte texto normal para caracteres Unicode sans-serif bold.
+    Usa uma fonte mais próxima da padrão do Instagram.
+    Funciona para letras A-Z, a-z e números 0-9.
+    """
+    # Mapeamento usando Mathematical Sans-Serif Bold (mais próximo da fonte do Instagram)
+    bold_map = {
+        'A': '𝗔', 'B': '𝗕', 'C': '𝗖', 'D': '𝗗', 'E': '𝗘', 'F': '𝗙', 'G': '𝗚', 'H': '𝗛',
+        'I': '𝗜', 'J': '𝗝', 'K': '𝗞', 'L': '𝗟', 'M': '𝗠', 'N': '𝗡', 'O': '𝗢', 'P': '𝗣',
+        'Q': '𝗤', 'R': '𝗥', 'S': '𝗦', 'T': '𝗧', 'U': '𝗨', 'V': '𝗩', 'W': '𝗪', 'X': '𝗫',
+        'Y': '𝗬', 'Z': '𝗭',
+        
+        'a': '𝗮', 'b': '𝗯', 'c': '𝗰', 'd': '𝗱', 'e': '𝗲', 'f': '𝗳', 'g': '𝗴', 'h': '𝗵',
+        'i': '𝗶', 'j': '𝗷', 'k': '𝗸', 'l': '𝗹', 'm': '𝗺', 'n': '𝗻', 'o': '𝗼', 'p': '𝗽',
+        'q': '𝗾', 'r': '𝗿', 's': '𝘀', 't': '𝘁', 'u': '𝘂', 'v': '𝘃', 'w': '𝘄', 'x': '𝘅',
+        'y': '𝘆', 'z': '𝘇',
+        
+        '0': '𝟬', '1': '𝟭', '2': '𝟮', '3': '𝟯', '4': '𝟰', '5': '𝟱', '6': '𝟲', '7': '𝟳',
+        '8': '𝟴', '9': '𝟵'
+    }
+    
+    return ''.join(bold_map.get(char, char) for char in text)
+
+def convert_to_italic_unicode(text: str) -> str:
+    """
+    Converte texto normal para caracteres Unicode sans-serif itálico.
+    Usa uma fonte mais próxima da padrão do Instagram.
+    Funciona para letras A-Z, a-z e números 0-9.
+    """
+    # Mapeamento usando Mathematical Sans-Serif Italic (mais próximo da fonte do Instagram)
+    italic_map = {
+        'A': '𝘈', 'B': '𝘉', 'C': '𝘊', 'D': '𝘋', 'E': '𝘌', 'F': '𝘍', 'G': '𝘎', 'H': '𝘏',
+        'I': '𝘐', 'J': '𝘑', 'K': '𝘒', 'L': '𝘓', 'M': '𝘔', 'N': '𝘕', 'O': '𝘖', 'P': '𝘗',
+        'Q': '𝘘', 'R': '𝘙', 'S': '𝘚', 'T': '𝘛', 'U': '𝘜', 'V': '𝘝', 'W': '𝘞', 'X': '𝘟',
+        'Y': '𝘠', 'Z': '𝘡',
+        
+        'a': '𝘢', 'b': '𝘣', 'c': '𝘤', 'd': '𝘥', 'e': '𝘦', 'f': '𝘧', 'g': '𝘨', 'h': '𝘩',
+        'i': '𝘪', 'j': '𝘫', 'k': '𝘬', 'l': '𝘭', 'm': '𝘮', 'n': '𝘯', 'o': '𝘰', 'p': '𝘱',
+        'q': '𝘲', 'r': '𝘳', 's': '𝘴', 't': '𝘵', 'u': '𝘶', 'v': '𝘷', 'w': '𝘸', 'x': '𝘹',
+        'y': '𝘺', 'z': '𝘻',
+        
+        # Números itálicos (mesmo conjunto do negrito, pois não há itálico específico)
+        '0': '𝟬', '1': '𝟭', '2': '𝟮', '3': '𝟯', '4': '𝟰', '5': '𝟱', '6': '𝟲', '7': '𝟳',
+        '8': '𝟴', '9': '𝟵'
+    }
+    
+    return ''.join(italic_map.get(char, char) for char in text)
+
+def clean_html_tags(text: str) -> str:
+    """
+    Remove todas as tags HTML exceto <strong> e <em>.
+    Converte <h2> para <strong> (negrito).
+    Converte <p> para quebras de linha.
+    Remove completamente outras tags como <li>, <h3>, etc.
+    
+    Returns:
+        str: Texto limpo com apenas <strong> e <em>
+    """
+    if not text:
+        return ""
+    
+    import re
+    
+    # Converte <h2> para <strong> (mantendo o conteúdo)
+    text = re.sub(r'<h2[^>]*>(.*?)</h2>', r'<strong>\1</strong>', text, flags=re.DOTALL | re.IGNORECASE)
+    
+    # Converte <p> para quebras de linha
+    text = re.sub(r'<p[^>]*>(.*?)</p>', r'\1\n\n', text, flags=re.DOTALL | re.IGNORECASE)
+    
+    # Converte <br> e <br/> para quebra de linha simples
+    text = re.sub(r'<br\s*/?>', '\n', text, flags=re.IGNORECASE)
+    
+    # Remove todas as outras tags HTML, mantendo apenas o conteúdo
+    # Exclui <strong>, </strong>, <em>, </em> da remoção
+    text = re.sub(r'<(?!/?(?:strong|em)\b)[^>]*>', '', text, flags=re.IGNORECASE)
+    
+    # Remove quebras de linha excessivas e espaços extras
+    text = re.sub(r'\n\s*\n\s*\n+', '\n\n', text)  # Máximo de 2 quebras consecutivas
+    text = re.sub(r'[ \t]+', ' ', text)  # Remove espaços/tabs extras
+    text = text.strip()
+    
+    return text
+
+def format_text_for_instagram(text: str) -> Tuple[str, Optional[str]]:
+    """
+    Formata o texto para o Instagram:
+    1. Limpa tags HTML indesejadas
+    2. Converte <strong> para negrito Unicode
+    3. Converte <em> para itálico Unicode
+    4. Corta se necessário e retorna o texto principal e o resto para comentário
+    
+    Returns:
+        Tuple[str, Optional[str]]: (texto_principal, resto_para_comentario)
+    """
+    if not text:
+        return "", None
+    
+    # 🧹 Primeiro, limpa as tags HTML indesejadas
+    text = clean_html_tags(text)
+    
+    # 🔤 Converte tags <strong> para negrito Unicode do Instagram
+    import re
+    
+    def replace_strong_tags(match):
+        content = match.group(1)  # Conteúdo entre as tags <strong>
+        return convert_to_bold_unicode(content)
+    
+    def replace_em_tags(match):
+        content = match.group(1)  # Conteúdo entre as tags <em>
+        return convert_to_italic_unicode(content)
+    
+    # Substitui todas as ocorrências de <strong>conteudo</strong>
+    text = re.sub(r'<strong>(.*?)</strong>', replace_strong_tags, text, flags=re.DOTALL)
+    
+    # Substitui todas as ocorrências de <em>conteudo</em>
+    text = re.sub(r'<em>(.*?)</em>', replace_em_tags, text, flags=re.DOTALL)
+    
+    max_length = 2200
+    suffix = '\n\n💬 Continua nos comentários!'
+    
+    if len(text) <= max_length:
+        return text, None
+    
+    cutoff_length = max_length - len(suffix)
+    if cutoff_length <= 0:
+        return suffix.strip(), text
+    
+    trimmed = text[:cutoff_length]
+    
+    def is_inside_quotes(s: str, index: int) -> bool:
+        """Verifica se há aspas abertas não fechadas até o índice"""
+        up_to_index = s[:index + 1]
+        quote_count = up_to_index.count('"')
+        return quote_count % 2 != 0
+    
+    # Encontra o último ponto final fora de aspas
+    last_valid_dot = -1
+    for i in range(len(trimmed) - 1, -1, -1):
+        if trimmed[i] == '.' and not is_inside_quotes(trimmed, i):
+            last_valid_dot = i
+            break
+    
+    if last_valid_dot > 100:
+        main_text = trimmed[:last_valid_dot + 1]
+        remaining_text = text[last_valid_dot + 1:].strip()
+    else:
+        main_text = trimmed
+        remaining_text = text[cutoff_length:].strip()
+    
+    final_main_text = f"{main_text}{suffix}"
+    
+    return final_main_text, remaining_text if remaining_text else None
+
+async def post_comment(client: httpx.AsyncClient, post_id: str, comment_text: str) -> Optional[str]:
+    """
+    Posta um comentário no post do Instagram
+    
+    Returns:
+        Optional[str]: ID do comentário se postado com sucesso
+    """
+    try:
+        comment_url = f"{INSTAGRAM_API_BASE}/{post_id}/comments"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {INSTAGRAM_TOKEN}"
+        }
+        
+        comment_payload = {
+            "message": comment_text
+        }
+        
+        print(f"💬 Postando comentário no post {post_id}")
+        comment_response = await client.post(
+            comment_url,
+            headers=headers,
+            json=comment_payload
+        )
+        
+        if comment_response.status_code == 200:
+            comment_data = comment_response.json()
+            comment_id = comment_data.get("id")
+            print(f"✅ Comentário postado com ID: {comment_id}")
+            return comment_id
+        else:
+            error_detail = comment_response.text
+            print(f"⚠️ Erro ao postar comentário: {error_detail}")
+            return None
+            
+    except Exception as e:
+        print(f"⚠️ Erro inesperado ao postar comentário: {str(e)}")
+        return None
+
+# 🚀 Endpoint principal para publicar no Instagram
+@router.post("/publish", response_model=PublishResponse)
+async def publish_instagram_post(post: InstagramPost) -> PublishResponse:
+    """
+    Publica uma imagem no Instagram em duas etapas:
+    1. Cria o media container
+    2. Publica o post
+    3. Se necessário, posta o resto do texto como comentário
+    """
+    
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        try:
+            # 📝 Processa o texto da caption
+            main_caption, remaining_text = format_text_for_instagram(post.caption) if post.caption else ("", None)
+            
+            # 🎯 ETAPA 1: Criar o media container
+            media_payload = {
+                "image_url": post.image_url
+            }
+            
+            # Adiciona caption processada se fornecida
+            if main_caption:
+                media_payload["caption"] = main_caption
+            
+            media_url = f"{INSTAGRAM_API_BASE}/{INSTAGRAM_PAGE_ID}/media"
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {INSTAGRAM_TOKEN}"
+            }
+            
+            print(f"📤 Criando media container para: {post.image_url}")
+            if remaining_text:
+                print(f"✂️ Texto cortado - será postado comentário com {len(remaining_text)} caracteres")
+            
+            media_response = await client.post(
+                media_url, 
+                headers=headers, 
+                json=media_payload
+            )
+            
+            if media_response.status_code != 200:
+                error_detail = media_response.text
+                print(f"❌ Erro ao criar media container: {error_detail}")
+                raise HTTPException(
+                    status_code=media_response.status_code, 
+                    detail=f"Erro ao criar media container: {error_detail}"
+                )
+            
+            media_data = media_response.json()
+            media_id = media_data.get("id")
+            
+            if not media_id:
+                raise HTTPException(
+                    status_code=500, 
+                    detail="ID do media container não retornado"
+                )
+            
+            print(f"✅ Media container criado com ID: {media_id}")
+            
+            # 🎯 ETAPA 2: Publicar o post
+            publish_payload = {
+                "creation_id": media_id
+            }
+            
+            publish_url = f"{INSTAGRAM_API_BASE}/{INSTAGRAM_PAGE_ID}/media_publish"
+            
+            print(f"📤 Publicando post com creation_id: {media_id}")
+            publish_response = await client.post(
+                publish_url, 
+                headers=headers, 
+                json=publish_payload
+            )
+            
+            if publish_response.status_code != 200:
+                error_detail = publish_response.text
+                print(f"❌ Erro ao publicar post: {error_detail}")
+                raise HTTPException(
+                    status_code=publish_response.status_code, 
+                    detail=f"Erro ao publicar post: {error_detail}"
+                )
+            
+            publish_data = publish_response.json()
+            post_id = publish_data.get("id")
+            
+            # 🔗 ETAPA 3: Obter detalhes do post para construir URL
+            post_url = None
+            if post_id:
+                try:
+                    # Query para obter o permalink do post
+                    post_details_url = f"{INSTAGRAM_API_BASE}/{post_id}?fields=permalink"
+                    details_response = await client.get(post_details_url, headers=headers)
+                    
+                    if details_response.status_code == 200:
+                        details_data = details_response.json()
+                        post_url = details_data.get("permalink")
+                        print(f"🔗 Link do post: {post_url}")
+                    else:
+                        print(f"⚠️ Não foi possível obter o link do post: {details_response.text}")
+                except Exception as e:
+                    print(f"⚠️ Erro ao obter link do post: {str(e)}")
+            
+            # 💬 ETAPA 4: Postar comentário com o resto do texto (se necessário)
+            comment_posted = False
+            comment_id = None
+            
+            if remaining_text and post_id:
+                comment_id = await post_comment(client, post_id, remaining_text)
+                comment_posted = comment_id is not None
+            
+            success_message = "Post publicado com sucesso no Instagram!"
+            if comment_posted:
+                success_message += " Texto adicional postado como comentário."
+            elif remaining_text and not comment_posted:
+                success_message += " ATENÇÃO: Não foi possível postar o comentário com o resto do texto."
+            
+            print(f"🎉 {success_message} Post ID: {post_id}")
+            
+            return PublishResponse(
+                success=True,
+                media_id=media_id,
+                post_id=post_id,
+                post_url=post_url,
+                message=success_message,
+                comment_posted=comment_posted,
+                comment_id=comment_id
+            )
+            
+        except httpx.TimeoutException:
+            print("⏰ Timeout na requisição para Instagram API")
+            raise HTTPException(
+                status_code=408, 
+                detail="Timeout na comunicação com a API do Instagram"
+            )
+        except httpx.RequestError as e:
+            print(f"🌐 Erro de conexão: {str(e)}")
+            raise HTTPException(
+                status_code=502, 
+                detail=f"Erro de conexão: {str(e)}"
+            )
+        except Exception as e:
+            print(f"💥 Erro inesperado: {str(e)}")
+            raise HTTPException(
+                status_code=500, 
+                detail=f"Erro interno do servidor: {str(e)}"
+            )

routers/memoriam.py

@@ -0,0 +1,203 @@
+from fastapi import APIRouter, Query, HTTPException
+from fastapi.responses import StreamingResponse
+from PIL import Image, ImageDraw, ImageEnhance, ImageFont
+from io import BytesIO
+import requests
+from typing import Optional
+import logging
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger("memoriam-api")
+
+router = APIRouter()
+
+def download_image_from_url(url: str) -> Image.Image:
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36"
+    }
+    response = requests.get(url, headers=headers)
+    if response.status_code != 200:
+        raise HTTPException(status_code=400, detail=f"Imagem não pôde ser baixada. Código {response.status_code}")
+    try:
+        return Image.open(BytesIO(response.content)).convert("RGB")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Erro ao abrir imagem: {str(e)}")
+
+def resize_and_crop_to_fill(img: Image.Image, target_width: int, target_height: int) -> Image.Image:
+    img_ratio = img.width / img.height
+    target_ratio = target_width / target_height
+
+    if img_ratio > target_ratio:
+        scale_height = target_height
+        scale_width = int(scale_height * img_ratio)
+    else:
+        scale_width = target_width
+        scale_height = int(scale_width / img_ratio)
+
+    img_resized = img.resize((scale_width, scale_height), Image.LANCZOS)
+
+    left = (scale_width - target_width) // 2
+    top = (scale_height - target_height) // 2
+    right = left + target_width
+    bottom = top + target_height
+
+    return img_resized.crop((left, top, right, bottom))
+
+def create_bottom_black_gradient(width: int, height: int) -> Image.Image:
+    """Cria um gradiente preto suave que vai do topo transparente até a metade da imagem preto"""
+    gradient = Image.new("RGBA", (width, height), color=(0, 0, 0, 0))
+    draw = ImageDraw.Draw(gradient)
+    
+    for y in range(height):
+        # Gradiente mais suave que começa transparente e vai até metade da imagem
+        ratio = y / height
+        if ratio <= 0.6:
+            # Primeira parte: totalmente transparente
+            alpha = 0
+        elif ratio <= 0.75:
+            # Transição muito suave (60% a 75% da altura)
+            alpha = int(80 * (ratio - 0.6) / 0.15)
+        else:
+            # Final suave (75% a 100% da altura)
+            alpha = int(80 + 50 * (ratio - 0.75) / 0.25)
+        
+        # Usar preto puro (0, 0, 0) com alpha mais baixo
+        draw.line([(0, y), (width, y)], fill=(0, 0, 0, alpha))
+    
+    return gradient
+
+def create_top_black_gradient(width: int, height: int) -> Image.Image:
+    """Cria um gradiente preto suave que vai do fundo transparente até a metade da imagem preto"""
+    gradient = Image.new("RGBA", (width, height), color=(0, 0, 0, 0))
+    draw = ImageDraw.Draw(gradient)
+    
+    for y in range(height):
+        # Gradiente mais suave que começa preto e vai até metade da imagem
+        ratio = y / height
+        if ratio <= 0.25:
+            # Primeira parte suave (0% a 25% da altura)
+            alpha = int(80 + 50 * (0.25 - ratio) / 0.25)
+        elif ratio <= 0.4:
+            # Transição muito suave (25% a 40% da altura)
+            alpha = int(80 * (0.4 - ratio) / 0.15)
+        else:
+            # Segunda parte: totalmente transparente
+            alpha = 0
+        
+        # Usar preto puro (0, 0, 0) com alpha mais baixo
+        draw.line([(0, y), (width, y)], fill=(0, 0, 0, alpha))
+    
+    return gradient
+
+def draw_text_left_aligned(draw: ImageDraw.Draw, text: str, x: int, y: int, font_path: str, font_size: int):
+    """Desenha texto alinhado à esquerda com especificações exatas"""
+    try:
+        font = ImageFont.truetype(font_path, font_size)
+    except Exception:
+        font = ImageFont.load_default()
+    
+    # Espaçamento entre letras 0% e cor branca
+    draw.text((x, y), text, font=font, fill=(255, 255, 255), spacing=0)
+
+
+
+def create_canvas(image_url: Optional[str], name: Optional[str], birth: Optional[str], death: Optional[str], text_position: str = "bottom") -> BytesIO:
+    # Dimensões fixas para Instagram
+    width = 1080
+    height = 1350
+    
+    canvas = Image.new("RGBA", (width, height), (0, 0, 0, 0))  # Fundo transparente
+
+    # Carregar e processar imagem de fundo se fornecida
+    if image_url:
+        try:
+            img = download_image_from_url(image_url)
+            img_bw = ImageEnhance.Color(img).enhance(0.0).convert("RGBA")
+            filled_img = resize_and_crop_to_fill(img_bw, width, height)
+            canvas.paste(filled_img, (0, 0))
+        except Exception as e:
+            log.warning(f"Erro ao carregar imagem: {e}")
+
+    # Aplicar gradiente baseado na posição do texto
+    if text_position.lower() == "top":
+        gradient_overlay = create_top_black_gradient(width, height)
+    else:  # bottom
+        gradient_overlay = create_bottom_black_gradient(width, height)
+    
+    canvas = Image.alpha_composite(canvas, gradient_overlay)
+
+    # Adicionar logo no canto inferior direito com opacidade
+    try:
+        logo = Image.open("recurve.png").convert("RGBA")
+        logo_resized = logo.resize((120, 22))
+        # Aplicar opacidade à logo
+        logo_with_opacity = Image.new("RGBA", logo_resized.size)
+        logo_with_opacity.paste(logo_resized, (0, 0))
+        # Reduzir opacidade
+        logo_alpha = logo_with_opacity.split()[-1].point(lambda x: int(x * 0.42))  # 42% de opacidade
+        logo_with_opacity.putalpha(logo_alpha)
+        
+        logo_padding = 40
+        logo_x = width - 120 - logo_padding
+        logo_y = height - 22 - logo_padding
+        canvas.paste(logo_with_opacity, (logo_x, logo_y), logo_with_opacity)
+    except Exception as e:
+        log.warning(f"Erro ao carregar a logo: {e}")
+
+    draw = ImageDraw.Draw(canvas)
+
+    # Configurar posições baseadas no text_position
+    text_x = 80  # Alinhamento à esquerda com margem
+    
+    if text_position.lower() == "top":
+        dates_y = 100
+        name_y = dates_y + 36 + 6  # Ano + espaçamento de 6px + nome
+    else:  # bottom
+        dates_y = height - 250
+        name_y = dates_y + 36 + 6  # Ano + espaçamento de 6px + nome
+
+    # Desenhar datas primeiro (se fornecidas)
+    if birth or death:
+        font_path_regular = "fonts/AGaramondPro-Regular.ttf"
+        
+        # Construir texto das datas
+        dates_text = ""
+        if birth and death:
+            dates_text = f"{birth} - {death}"
+        elif birth:
+            dates_text = f"{birth}"
+        elif death:
+            dates_text = f"- {death}"
+        
+        if dates_text:
+            draw_text_left_aligned(draw, dates_text, text_x, dates_y, font_path_regular, 36)
+
+    # Desenhar nome abaixo das datas
+    if name:
+        font_path = "fonts/AGaramondPro-BoldItalic.ttf"
+        draw_text_left_aligned(draw, name, text_x, name_y, font_path, 87)
+
+    buffer = BytesIO()
+    canvas.save(buffer, format="PNG")
+    buffer.seek(0)
+    return buffer
+
+@router.get("/cover/memoriam")
+def get_memoriam_image(
+    image_url: Optional[str] = Query(None, description="URL da imagem de fundo"),
+    name: Optional[str] = Query(None, description="Nome (será exibido em maiúsculas)"),
+    birth: Optional[str] = Query(None, description="Ano de nascimento (ex: 1943)"),
+    death: Optional[str] = Query(None, description="Ano de falecimento (ex: 2023)"),
+    text_position: str = Query("bottom", description="Posição do texto: 'top' ou 'bottom'")
+):
+    """
+    Gera imagem de memoriam no formato 1080x1350 (Instagram).
+    Todos os parâmetros são opcionais, mas recomenda-se fornecer pelo menos o nome.
+    O gradiente será aplicado baseado na posição do texto (top ou bottom).
+    """
+    try:
+        buffer = create_canvas(image_url, name, birth, death, text_position)
+        return StreamingResponse(buffer, media_type="image/png")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao gerar imagem: {str(e)}")

routers/news.py

@@ -0,0 +1,291 @@
+from fastapi import APIRouter, Query, HTTPException
+from fastapi.responses import StreamingResponse
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import requests
+from typing import Optional
+
+router = APIRouter()
+
+def download_image_from_url(url: str) -> Image.Image:
+    headers = {
+        "User-Agent": (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/115.0.0.0 Safari/537.36"
+        )
+    }
+    try:
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+        return Image.open(BytesIO(response.content)).convert("RGBA")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Erro ao baixar imagem: {url} ({str(e)})")
+
+def resize_and_crop_to_fill(img: Image.Image, target_width: int, target_height: int) -> Image.Image:
+    img_ratio = img.width / img.height
+    target_ratio = target_width / target_height
+
+    if img_ratio > target_ratio:
+        scale_height = target_height
+        scale_width = int(scale_height * img_ratio)
+    else:
+        scale_width = target_width
+        scale_height = int(scale_width / img_ratio)
+
+    img_resized = img.resize((scale_width, scale_height), Image.LANCZOS)
+
+    left = (scale_width - target_width) // 2
+    top = (scale_height - target_height) // 2
+    right = left + target_width
+    bottom = top + target_height
+
+    return img_resized.crop((left, top, right, bottom))
+
+def create_gradient_overlay(width: int, height: int, text_position: str = "bottom") -> Image.Image:
+    """
+    Cria gradiente overlay baseado na posição do texto
+    """
+    gradient = Image.new("RGBA", (width, height))
+    draw = ImageDraw.Draw(gradient)
+    
+    if text_position.lower() == "bottom":
+        # Gradiente para texto embaixo: posição Y:531, altura 835px
+        gradient_start = 531
+        gradient_height = 835
+        
+        for y in range(gradient_height):
+            if y + gradient_start < height:
+                # Gradient: 0% transparent -> 46.63% rgba(0,0,0,0.55) -> 100% rgba(0,0,0,0.7)
+                ratio = y / gradient_height
+                if ratio <= 0.4663:
+                    # 0% a 46.63%: de transparente para 0.55
+                    opacity_ratio = ratio / 0.4663
+                    opacity = int(255 * 0.55 * opacity_ratio)
+                else:
+                    # 46.63% a 100%: de 0.55 para 0.7
+                    opacity_ratio = (ratio - 0.4663) / (1 - 0.4663)
+                    opacity = int(255 * (0.55 + (0.7 - 0.55) * opacity_ratio))
+                
+                draw.line([(0, y + gradient_start), (width, y + gradient_start)], fill=(0, 0, 0, opacity))
+    
+    else:  # text_position == "top"
+        # Gradiente para texto no topo: posição Y:0, altura 835px
+        # linear-gradient(0deg, rgba(0,0,0,0) 0%, rgba(0,0,0,0.307045) 16.93%, rgba(0,0,0,0.55) 45.57%, rgba(0,0,0,0.7) 100%)
+        # 0deg significa: 0% = bottom, 100% = top
+        gradient_height = 835
+        
+        for y in range(gradient_height):
+            if y < height:
+                # Inverter a ratio: y=0 (topo) deve ser 100% do gradient, y=835 (bottom) deve ser 0%
+                ratio = (gradient_height - y) / gradient_height
+                if ratio <= 0.1693:
+                    # 0% a 16.93%: de 0 (transparente) para 0.307
+                    opacity_ratio = ratio / 0.1693
+                    opacity = int(255 * (0.307 * opacity_ratio))
+                elif ratio <= 0.4557:
+                    # 16.93% a 45.57%: de 0.307 para 0.55
+                    opacity_ratio = (ratio - 0.1693) / (0.4557 - 0.1693)
+                    opacity = int(255 * (0.307 + (0.55 - 0.307) * opacity_ratio))
+                else:
+                    # 45.57% a 100%: de 0.55 para 0.7
+                    opacity_ratio = (ratio - 0.4557) / (1 - 0.4557)
+                    opacity = int(255 * (0.55 + (0.7 - 0.55) * opacity_ratio))
+                
+                draw.line([(0, y), (width, y)], fill=(0, 0, 0, opacity))
+    
+    return gradient
+
+def wrap_text(text: str, font: ImageFont.FreeTypeFont, max_width: int, draw: ImageDraw.Draw) -> list[str]:
+    words = text.split()
+    lines = []
+    current_line = ""
+
+    for word in words:
+        test_line = f"{current_line} {word}".strip()
+        if draw.textlength(test_line, font=font) <= max_width:
+            current_line = test_line
+        else:
+            if current_line:
+                lines.append(current_line)
+            current_line = word
+    if current_line:
+        lines.append(current_line)
+    return lines
+
+def get_responsive_font_and_lines(text: str, font_path: str, max_width: int, max_lines: int = 3, 
+                                 max_font_size: int = 80, min_font_size: int = 20) -> tuple[ImageFont.FreeTypeFont, list[str], int]:
+    """
+    Retorna a fonte e linhas ajustadas para caber no número máximo de linhas.
+    """
+    temp_img = Image.new("RGB", (1, 1))
+    temp_draw = ImageDraw.Draw(temp_img)
+    
+    current_font_size = max_font_size
+    
+    while current_font_size >= min_font_size:
+        try:
+            font = ImageFont.truetype(font_path, current_font_size)
+        except Exception:
+            font = ImageFont.load_default()
+        
+        lines = wrap_text(text, font, max_width, temp_draw)
+        
+        if len(lines) <= max_lines:
+            return font, lines, current_font_size
+        
+        current_font_size -= 1
+    
+    try:
+        font = ImageFont.truetype(font_path, min_font_size)
+    except Exception:
+        font = ImageFont.load_default()
+    
+    lines = wrap_text(text, font, max_width, temp_draw)
+    return font, lines, min_font_size
+
+def get_font_and_lines(text: str, font_path: str, font_size: int, max_width: int) -> tuple[ImageFont.FreeTypeFont, list[str]]:
+    """
+    Retorna a fonte e linhas com tamanho fixo de fonte.
+    """
+    try:
+        font = ImageFont.truetype(font_path, font_size)
+    except Exception:
+        font = ImageFont.load_default()
+    
+    temp_img = Image.new("RGB", (1, 1))
+    temp_draw = ImageDraw.Draw(temp_img)
+    lines = wrap_text(text, font, max_width, temp_draw)
+    
+    return font, lines
+
+def get_text_color_rgb(text_color: str) -> tuple[int, int, int]:
+    """
+    Converte o parâmetro text_color para RGB.
+    """
+    if text_color.lower() == "black":
+        return (0, 0, 0)
+    else:  # white por padrão
+        return (255, 255, 255)
+
+def get_device_dimensions(device: str) -> tuple[int, int]:
+    """Retorna as dimensões baseadas no dispositivo"""
+    if device.lower() == "web":
+        return (1280, 720)
+    else:  # Instagram por padrão
+        return (1080, 1350)
+
+def create_canvas(image_url: Optional[str], headline: Optional[str], device: str = "ig", 
+                 text_position: str = "bottom", text_color: str = "white") -> BytesIO:
+    width, height = get_device_dimensions(device)
+    is_web = device.lower() == "web"
+    text_rgb = get_text_color_rgb(text_color)
+    
+    # Configurações específicas por dispositivo
+    if is_web:
+        padding_x = 40
+        logo_width, logo_height = 120, 22
+        logo_padding = 40
+    else:
+        padding_x = 60
+        bottom_padding = 80
+        top_padding = 60
+        logo_width, logo_height = 121, 23  # Novas dimensões: L:121, A:22.75 (arredondado para 23)
+    
+    max_width = width - 2 * padding_x
+
+    canvas = Image.new("RGBA", (width, height), color=(255, 255, 255, 255))
+
+    # Adicionar imagem de fundo se fornecida
+    if image_url:
+        img = download_image_from_url(image_url)
+        filled_img = resize_and_crop_to_fill(img, width, height)
+        canvas.paste(filled_img, (0, 0))
+
+    # Para Instagram: adicionar gradiente e texto
+    if not is_web:
+        # Só aplicar gradiente se o texto for branco
+        if text_color.lower() != "black":
+            gradient_overlay = create_gradient_overlay(width, height, text_position)
+            canvas = Image.alpha_composite(canvas, gradient_overlay)
+
+        if headline:
+            draw = ImageDraw.Draw(canvas)
+            font_path = "fonts/AGaramondPro-Semibold.ttf"
+            line_height_factor = 1.05  # 105% da altura da linha
+
+            try:
+                font, lines, font_size = get_responsive_font_and_lines(
+                    headline, font_path, max_width, max_lines=3, 
+                    max_font_size=80, min_font_size=20
+                )
+                line_height = int(font_size * line_height_factor)
+                
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=f"Erro ao processar a fonte: {e}")
+
+            total_text_height = len(lines) * line_height
+            
+            # Posicionar texto baseado no parâmetro text_position
+            if text_position.lower() == "bottom":
+                # Posicionar texto 50px acima da logo (que está em Y:1274)
+                text_end_y = 1274 - 50
+                start_y = text_end_y - total_text_height
+            else:  # text_position == "top"
+                # Posicionar texto no topo com padding
+                start_y = top_padding
+
+            # Adicionar logo no canto inferior direito (posição fixa)
+            try:
+                logo_path = "recurve.png"
+                logo = Image.open(logo_path).convert("RGBA")
+                logo_resized = logo.resize((logo_width, logo_height))
+                
+                # Aplicar opacidade de 42%
+                logo_with_opacity = Image.new("RGBA", logo_resized.size)
+                for x in range(logo_resized.width):
+                    for y in range(logo_resized.height):
+                        r, g, b, a = logo_resized.getpixel((x, y))
+                        new_alpha = int(a * 0.42)  # 42% de opacidade
+                        logo_with_opacity.putpixel((x, y), (r, g, b, new_alpha))
+                
+                # Posição fixa: X:891, Y:1274
+                canvas.paste(logo_with_opacity, (891, 1274), logo_with_opacity)
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=f"Erro ao carregar a logo: {e}")
+
+            # Adiciona texto com a cor especificada
+            for i, line in enumerate(lines):
+                y = start_y + i * line_height
+                draw.text((padding_x, y), line, font=font, fill=text_rgb)
+
+    # Para web: apenas logo no canto inferior direito
+    else:
+        try:
+            logo_path = "recurve.png"
+            logo = Image.open(logo_path).convert("RGBA")
+            logo_resized = logo.resize((logo_width, logo_height))
+            logo_x = width - logo_width - logo_padding
+            logo_y = height - logo_height - logo_padding
+            canvas.paste(logo_resized, (logo_x, logo_y), logo_resized)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Erro ao carregar a logo: {e}")
+
+    buffer = BytesIO()
+    canvas.convert("RGB").save(buffer, format="PNG")
+    buffer.seek(0)
+    return buffer
+
+@router.get("/cover/news")
+def get_news_image(
+    image_url: Optional[str] = Query(None, description="URL da imagem de fundo"),
+    headline: Optional[str] = Query(None, description="Texto do título (opcional para IG, ignorado para web)"),
+    device: str = Query("ig", description="Dispositivo: 'ig' para Instagram (1080x1350) ou 'web' para Web (1280x720)"),
+    text_position: str = Query("bottom", description="Posição do texto: 'top' para topo ou 'bottom' para parte inferior"),
+    text_color: str = Query("white", description="Cor do texto: 'white' (padrão) ou 'black'. Se 'black', remove o gradiente de fundo")
+):
+    try:
+        buffer = create_canvas(image_url, headline, device, text_position, text_color)
+        return StreamingResponse(buffer, media_type="image/png")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao gerar imagem: {str(e)}")

routers/search.py

@@ -0,0 +1,382 @@
+from fastapi import APIRouter, HTTPException, Query
+from fastapi.responses import JSONResponse
+import httpx
+import json
+import re
+from urllib.parse import unquote
+from PIL import Image
+import io
+import asyncio
+import struct
+from typing import Optional, Tuple
+
+router = APIRouter()
+
+@router.get("/search")
+async def search(
+    q: str = Query(..., description="Termo de pesquisa para imagens"),
+    min_width: int = Query(1200, description="Largura mínima das imagens (padrão: 1200px)")
+):
+    """
+    Busca imagens no Google Imagens e retorna uma lista estruturada
+    Agora com filtro de largura mínima
+    """
+    
+    # URL do Google Imagens com parâmetros para imagens grandes
+    google_images_url = "http://www.google.com/search"
+    
+    params = {
+        "tbm": "isch",  # Google Images
+        "q": q,
+        "start": 0,
+        "sa": "N",
+        "asearch": "arc",
+        "cs": "1",
+        "tbs": "isz:l",  # Adiciona filtro para imagens grandes (Large)
+        # Outras opções disponíveis:
+        # "isz:m" = Medium
+        # "isz:i" = Icon  
+        # "isz:lt,islt:2mp" = Larger than 2MP
+        # "isz:ex,iszw:1920,iszh:1080" = Exact size
+        "async": f"arc_id:srp_GgSMaOPQOtL_5OUPvbSTOQ_110,ffilt:all,ve_name:MoreResultsContainer,inf:1,_id:arc-srp_GgSMaOPQOtL_5OUPvbSTOQ_110,_pms:s,_fmt:pc"
+    }
+    
+    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": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "pt-BR,pt;q=0.8,en-US;q=0.5,en;q=0.3",
+        "Accept-Encoding": "gzip, deflate",
+        "Connection": "keep-alive",
+        "Referer": "https://www.google.com/"
+    }
+    
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(google_images_url, params=params, headers=headers)
+        
+        if response.status_code != 200:
+            raise HTTPException(status_code=response.status_code, detail="Erro ao buscar no Google Imagens")
+        
+        # Extrair dados das imagens do conteúdo retornado
+        images = extract_images_from_response(response.text)
+        
+        # Enriquecer com dimensões reais das imagens (otimizado)
+        enriched_images = await enrich_images_with_dimensions_optimized(images)
+        
+        # Filtrar apenas imagens que têm dimensões válidas E largura >= min_width
+        valid_images = [
+            img for img in enriched_images 
+            if img.get('width') is not None 
+            and img.get('height') is not None 
+            and img.get('width') >= min_width
+        ]
+        
+        # Se não temos resultados suficientes, tenta buscar mais com filtros mais agressivos
+        if len(valid_images) < 20:
+            print(f"Poucos resultados com largura >= {min_width}px, buscando mais imagens...")
+            
+            # Tenta uma segunda busca com filtro de imagens extra grandes
+            params["tbs"] = "isz:lt,islt:4mp"  # Larger than 4MP
+            
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response2 = await client.get(google_images_url, params=params, headers=headers)
+            
+            if response2.status_code == 200:
+                additional_images = extract_images_from_response(response2.text)
+                additional_enriched = await enrich_images_with_dimensions_optimized(additional_images)
+                
+                # Combina os resultados e remove duplicatas
+                all_images = enriched_images + additional_enriched
+                seen_urls = set()
+                unique_images = []
+                
+                for img in all_images:
+                    if (img.get('url') not in seen_urls 
+                        and img.get('width') is not None 
+                        and img.get('height') is not None 
+                        and img.get('width') >= min_width):
+                        seen_urls.add(img.get('url'))
+                        unique_images.append(img)
+                
+                valid_images = unique_images
+        
+        # Ordena por largura (maiores primeiro) e limita a 50 resultados
+        valid_images.sort(key=lambda x: x.get('width', 0), reverse=True)
+        final_images = valid_images[:50]
+        
+        return JSONResponse(content={
+            "query": q,
+            "min_width_filter": min_width,
+            "total_found": len(final_images),
+            "images": final_images
+        })
+        
+    except httpx.TimeoutException:
+        raise HTTPException(status_code=408, detail="Timeout na requisição ao Google")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao executar a busca: {str(e)}")
+
+
+def clean_wikimedia_url(url: str) -> str:
+    """
+    Remove 'thumb/' das URLs do Wikimedia para obter imagem em resolução original
+    Funciona com URLs que terminam direto no arquivo ou com redimensionamento
+    """
+    if 'wikimedia.org' in url and '/thumb/' in url:
+        try:
+            # Casos possíveis:
+            # 1. https://upload.wikimedia.org/wikipedia/commons/thumb/7/79/James_Gunn_%2828557194032%29_%28cropped%29.jpg
+            # 2. https://upload.wikimedia.org/wikipedia/commons/thumb/7/79/James_Gunn_%2828557194032%29_%28cropped%29.jpg/220px-James_Gunn_%2828557194032%29_%28cropped%29.jpg
+            # Ambos devem virar: https://upload.wikimedia.org/wikipedia/commons/7/79/James_Gunn_%2828557194032%29_%28cropped%29.jpg
+            
+            # Divide a URL na parte /thumb/
+            parts = url.split('/thumb/')
+            if len(parts) == 2:
+                before_thumb = parts[0]  # https://upload.wikimedia.org/wikipedia/commons
+                after_thumb = parts[1]   # 7/79/James_Gunn_%2828557194032%29_%28cropped%29.jpg ou 7/79/James_Gunn_%2828557194032%29_%28cropped%29.jpg/220px-...
+                
+                # Divide o after_thumb por barras
+                path_parts = after_thumb.split('/')
+                
+                if len(path_parts) >= 3:
+                    # Estrutura: ['7', '79', 'filename.jpg'] ou ['7', '79', 'filename.jpg', 'resized-filename.jpg']
+                    # Queremos sempre pegar os 3 primeiros elementos (diretório + nome original)
+                    original_path = '/'.join(path_parts[:3])  # '7/79/James_Gunn_%2828557194032%29_%28cropped%29.jpg'
+                    cleaned_url = f"{before_thumb}/{original_path}"
+                    print(f"URL limpa: {url} -> {cleaned_url}")
+                    return cleaned_url
+                elif len(path_parts) == 2:
+                    # Caso onde só tem diretório/arquivo: 7/79 (sem o nome do arquivo)
+                    # Neste caso, a URL original pode estar malformada, retorna como está
+                    print(f"URL do Wikimedia malformada (sem nome do arquivo): {url}")
+                    
+        except Exception as e:
+            print(f"Erro ao limpar URL do Wikimedia: {e}")
+    
+    return url
+
+
+def extract_images_from_response(response_text: str) -> list:
+    """
+    Extrai informações das imagens do HTML/JavaScript retornado pelo Google
+    Agora busca mais URLs para garantir resultados com alta resolução
+    """
+    images = []
+    
+    try:
+        # Usar o regex antigo que funcionava para pegar todas as URLs
+        pattern = r'https?:\/\/[^\s"\'<>]+?\.(?:jpg|png|webp|jpeg)\b'
+        image_urls = re.findall(pattern, response_text, re.IGNORECASE)
+        
+        # Remove duplicatas mantendo a ordem
+        seen_urls = set()
+        unique_urls = []
+        for url in image_urls:
+            # Limpa a URL imediatamente ao extrair
+            cleaned_url = clean_wikimedia_url(url)
+            if cleaned_url not in seen_urls:
+                seen_urls.add(cleaned_url)
+                unique_urls.append(cleaned_url)
+        
+        # Extrai mais URLs inicialmente (150) porque muitas serão filtradas por largura
+        # Isso garante que tenhamos pelo menos 50 resultados válidos com largura >= 1200px
+        for url in unique_urls[:150]:
+            images.append({
+                "url": url,
+                "width": None,
+                "height": None
+            })
+            
+    except Exception as e:
+        print(f"Erro na extração: {e}")
+    
+    return images
+
+
+def get_image_size_from_bytes(data: bytes) -> Optional[Tuple[int, int]]:
+    """
+    Extrai dimensões da imagem usando apenas os primeiros bytes (muito rápido)
+    Suporta JPEG, PNG, GIF, WebP sem usar PIL - versão melhorada
+    """
+    if len(data) < 24:
+        return None
+    
+    try:
+        # JPEG
+        if data[:2] == b'\xff\xd8':
+            i = 2
+            while i < len(data) - 8:
+                if data[i:i+2] == b'\xff\xc0' or data[i:i+2] == b'\xff\xc2':
+                    if i + 9 <= len(data):
+                        height = struct.unpack('>H', data[i+5:i+7])[0]
+                        width = struct.unpack('>H', data[i+7:i+9])[0]
+                        if width > 0 and height > 0:
+                            return width, height
+                i += 1
+        
+        # PNG
+        elif data[:8] == b'\x89PNG\r\n\x1a\n':
+            if len(data) >= 24:
+                width = struct.unpack('>I', data[16:20])[0]
+                height = struct.unpack('>I', data[20:24])[0]
+                if width > 0 and height > 0:
+                    return width, height
+        
+        # GIF
+        elif data[:6] in (b'GIF87a', b'GIF89a'):
+            if len(data) >= 10:
+                width = struct.unpack('<H', data[6:8])[0]
+                height = struct.unpack('<H', data[8:10])[0]
+                if width > 0 and height > 0:
+                    return width, height
+        
+        # WebP
+        elif data[:4] == b'RIFF' and len(data) > 12 and data[8:12] == b'WEBP':
+            if len(data) >= 30:
+                if data[12:16] == b'VP8 ':
+                    # VP8 format
+                    if len(data) >= 30:
+                        width = struct.unpack('<H', data[26:28])[0] & 0x3fff
+                        height = struct.unpack('<H', data[28:30])[0] & 0x3fff
+                        if width > 0 and height > 0:
+                            return width, height
+                elif data[12:16] == b'VP8L':
+                    # VP8L format  
+                    if len(data) >= 25:
+                        bits = struct.unpack('<I', data[21:25])[0]
+                        width = (bits & 0x3fff) + 1
+                        height = ((bits >> 14) & 0x3fff) + 1
+                        if width > 0 and height > 0:
+                            return width, height
+                elif data[12:16] == b'VP8X':
+                    # VP8X format (extended)
+                    if len(data) >= 30:
+                        width = struct.unpack('<I', data[24:27] + b'\x00')[0] + 1
+                        height = struct.unpack('<I', data[27:30] + b'\x00')[0] + 1
+                        if width > 0 and height > 0:
+                            return width, height
+    
+    except (struct.error, IndexError) as e:
+        # Se houver erro no parsing, retorna None silenciosamente
+        pass
+    
+    return None
+
+
+async def get_image_dimensions_fast(client: httpx.AsyncClient, url: str) -> Tuple[str, Optional[int], Optional[int]]:
+    """
+    Obtém dimensões da imagem de forma otimizada
+    A URL já foi limpa na função extract_images_from_response
+    """
+    try:
+        # Limpa a URL de caracteres escapados e problemáticos
+        clean_url = url.replace('\\u003d', '=').replace('\\u0026', '&').replace('\\\\', '').replace('\\/', '/')
+        
+        # Headers otimizados - primeiro tenta com range pequeno
+        headers = {
+            'Range': 'bytes=0-2048',  # Aumentado para 2KB para ser mais confiável
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+            'Accept': 'image/*',
+            'Accept-Encoding': 'gzip, deflate',
+            'Connection': 'close'
+        }
+        
+        # Timeout bem baixo para ser rápido
+        response = await client.get(clean_url, headers=headers, timeout=5.0)
+        
+        if response.status_code in [200, 206]:  # 206 = Partial Content (normal com Range)
+            # Tenta primeiro com parsing manual (mais rápido)
+            dimensions = get_image_size_from_bytes(response.content)
+            if dimensions:
+                print(f"Dimensões obtidas via parsing manual para {clean_url}: {dimensions[0]}x{dimensions[1]}")
+                return clean_url, dimensions[0], dimensions[1]
+            
+            # Se não conseguiu com parsing manual, tenta baixar mais dados
+            print(f"Parsing manual falhou para {clean_url}, tentando baixar mais dados...")
+            
+            # Remove o Range header para baixar mais dados
+            headers_full = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                'Accept': 'image/*',
+                'Accept-Encoding': 'gzip, deflate',
+                'Connection': 'close'
+            }
+            
+            # Tenta baixar os primeiros 10KB
+            headers_full['Range'] = 'bytes=0-10240'
+            response_full = await client.get(clean_url, headers=headers_full, timeout=5.0)
+            
+            if response_full.status_code in [200, 206]:
+                # Tenta novamente com parsing manual
+                dimensions = get_image_size_from_bytes(response_full.content)
+                if dimensions:
+                    print(f"Dimensões obtidas via parsing manual (10KB) para {clean_url}: {dimensions[0]}x{dimensions[1]}")
+                    return clean_url, dimensions[0], dimensions[1]
+                
+                # Fallback para PIL se necessário
+                try:
+                    image = Image.open(io.BytesIO(response_full.content))
+                    width, height = image.size
+                    print(f"Dimensões obtidas via PIL para {clean_url}: {width}x{height}")
+                    return clean_url, width, height
+                except Exception as pil_error:
+                    print(f"PIL também falhou para {clean_url}: {pil_error}")
+        
+        else:
+            print(f"Erro HTTP {response.status_code} para {clean_url}")
+                
+    except Exception as e:
+        print(f"Erro ao obter dimensões para {url}: {e}")
+    
+    print(f"Não foi possível obter dimensões para {url}")
+    return url, None, None
+
+
+async def enrich_images_with_dimensions_optimized(images: list) -> list:
+    """
+    Versão otimizada para obter dimensões das imagens
+    """
+    if not images:
+        return []
+    
+    # Configurações otimizadas para velocidade
+    connector = httpx.AsyncClient(
+        timeout=httpx.Timeout(3.0),  # Timeout bem baixo
+        limits=httpx.Limits(
+            max_keepalive_connections=20,
+            max_connections=30,
+            keepalive_expiry=5.0
+        )
+        # http2=True removido para evitar dependência extra
+    )
+    
+    # Semáforo para controlar concorrência (aumentado para 15 para processar mais rápido)
+    semaphore = asyncio.Semaphore(15)
+    
+    async def process_image_with_semaphore(image_data):
+        async with semaphore:
+            url, width, height = await get_image_dimensions_fast(connector, image_data["url"])
+            return {
+                "url": url,
+                "width": width,
+                "height": height
+            }
+    
+    try:
+        # Processa todas as imagens em paralelo
+        tasks = [process_image_with_semaphore(img) for img in images]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Filtra apenas resultados válidos
+        valid_images = []
+        for result in results:
+            if not isinstance(result, Exception):
+                # Adiciona informação se a URL foi limpa (para debug)
+                if 'wikimedia.org' in result['url'] and '/thumb/' not in result['url']:
+                    result['cleaned_wikimedia_url'] = True
+                valid_images.append(result)
+        
+        return valid_images
+        
+    finally:
+        await connector.aclose()

routers/subtitle.py

@@ -0,0 +1,497 @@
+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}")

routers/twitter.py

@@ -0,0 +1,502 @@
+from fastapi import APIRouter, Query, HTTPException
+from fastapi.responses import StreamingResponse
+from PIL import Image, ImageDraw, ImageFont
+from io import BytesIO
+import requests
+import re
+from html import unescape
+
+router = APIRouter()
+
+def fetch_tweet_data(tweet_id: str) -> dict:
+    url = f"https://tweethunter.io/api/thread?tweetId={tweet_id}"
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:141.0) Gecko/20100101 Firefox/141.0",
+        "Accept": "application/json",
+        "Referer": "https://tweethunter.io/tweetpik"
+    }
+    try:
+        resp = requests.get(url, headers=headers, timeout=10)
+        resp.raise_for_status()
+        data = resp.json()
+        if not data:
+            raise HTTPException(status_code=404, detail="Tweet não encontrado")
+        return data[0]
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Erro ao buscar tweet: {e}")
+
+def download_emoji(emoji_url: str) -> Image.Image:
+    try:
+        response = requests.get(emoji_url, timeout=10)
+        response.raise_for_status()
+        emoji_img = Image.open(BytesIO(response.content)).convert("RGBA")
+        return emoji_img.resize((32, 32), Image.Resampling.LANCZOS)
+    except Exception as e:
+        print(f"Erro ao baixar emoji {emoji_url}: {e}")
+        return None
+
+def clean_tweet_text(text: str) -> str:
+    if not text:
+        return ""
+    
+    text = re.sub(r'<a[^>]*>pic\.x\.com/[^<]*</a>', '', text)
+    
+    text = re.sub(r'<img[^>]*alt="([^"]*)"[^>]*/?>', r'\1', text)
+    
+    text = re.sub(r'<[^>]+>', '', text)
+    
+    text = unescape(text)
+    
+    text = text.replace('\\n', '\n')
+    
+    text = re.sub(r'\n\s*\n', '\n\n', text)
+    text = text.strip()
+    
+    return text
+
+def extract_emojis_from_html(text: str) -> list:
+    emoji_pattern = r'<img[^>]*class="emoji"[^>]*alt="([^"]*)"[^>]*src="([^"]*)"[^>]*/?>'
+    emojis = []
+    
+    for match in re.finditer(emoji_pattern, text):
+        emoji_char = match.group(1)
+        emoji_url = match.group(2)
+        start_pos = match.start()
+        end_pos = match.end()
+        emojis.append({
+            'char': emoji_char,
+            'url': emoji_url,
+            'start': start_pos,
+            'end': end_pos
+        })
+    
+    return emojis
+
+def wrap_text_with_emojis(text: str, font: ImageFont.FreeTypeFont, max_width: int, draw: ImageDraw.Draw) -> list:
+    emojis = extract_emojis_from_html(text)
+    clean_text = clean_tweet_text(text)
+    
+    paragraphs = clean_text.split('\n')
+    all_lines = []
+    emoji_positions = []
+    current_char_index = 0
+    
+    for paragraph in paragraphs:
+        if not paragraph.strip():
+            all_lines.append({
+                'text': "",
+                'emojis': []
+            })
+            current_char_index += 1
+            continue
+            
+        words = paragraph.split()
+        current_line = ""
+        line_emojis = []
+        
+        for word in words:
+            test_line = f"{current_line} {word}".strip()
+            
+            emoji_count_in_word = 0
+            for emoji in emojis:
+                if emoji['char'] in word:
+                    emoji_count_in_word += len(emoji['char'])
+            
+            text_width = draw.textlength(test_line, font=font)
+            emoji_width = emoji_count_in_word * 32
+            total_width = text_width + emoji_width
+            
+            if total_width <= max_width:
+                current_line = test_line
+                for emoji in emojis:
+                    if emoji['char'] in word:
+                        emoji_pos_in_line = len(current_line) - len(word) + word.find(emoji['char'])
+                        line_emojis.append({
+                            'emoji': emoji,
+                            'position': emoji_pos_in_line
+                        })
+            else:
+                if current_line:
+                    all_lines.append({
+                        'text': current_line,
+                        'emojis': line_emojis.copy()
+                    })
+                current_line = word
+                line_emojis = []
+                for emoji in emojis:
+                    if emoji['char'] in word:
+                        emoji_pos_in_line = word.find(emoji['char'])
+                        line_emojis.append({
+                            'emoji': emoji,
+                            'position': emoji_pos_in_line
+                        })
+        
+        if current_line:
+            all_lines.append({
+                'text': current_line,
+                'emojis': line_emojis.copy()
+            })
+        
+        current_char_index += len(paragraph) + 1
+    
+    return all_lines
+
+def wrap_text_with_newlines(text: str, font: ImageFont.FreeTypeFont, max_width: int, draw: ImageDraw.Draw) -> list[str]:
+    paragraphs = text.split('\n')
+    all_lines = []
+    
+    for paragraph in paragraphs:
+        if not paragraph.strip():
+            all_lines.append("")
+            continue
+            
+        words = paragraph.split()
+        current_line = ""
+        
+        for word in words:
+            test_line = f"{current_line} {word}".strip()
+            if draw.textlength(test_line, font=font) <= max_width:
+                current_line = test_line
+            else:
+                if current_line:
+                    all_lines.append(current_line)
+                current_line = word
+        
+        if current_line:
+            all_lines.append(current_line)
+    
+    return all_lines
+
+def download_and_resize_image(url: str, max_width: int, max_height: int) -> Image.Image:
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        
+        img = Image.open(BytesIO(response.content)).convert("RGB")
+        
+        original_width, original_height = img.size
+        ratio = min(max_width / original_width, max_height / original_height)
+        
+        new_width = int(original_width * ratio)
+        new_height = int(original_height * ratio)
+        
+        return img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    except Exception as e:
+        print(f"Erro ao baixar imagem {url}: {e}")
+        return None
+
+def create_verification_badge(draw: ImageDraw.Draw, x: int, y: int, size: int = 24):
+    blue_color = (27, 149, 224)
+    
+    draw.ellipse((x, y, x + size, y + size), fill=blue_color)
+    
+    check_points = [
+        (x + size * 0.25, y + size * 0.5),
+        (x + size * 0.45, y + size * 0.7),
+        (x + size * 0.75, y + size * 0.3)
+    ]
+    
+    line_width = max(2, size // 12)
+    for i in range(len(check_points) - 1):
+        draw.line([check_points[i], check_points[i + 1]], fill=(255, 255, 255), width=line_width)
+
+def format_number(num: int) -> str:
+    if num >= 1000000:
+        return f"{num / 1000000:.1f}M"
+    elif num >= 1000:
+        return f"{num / 1000:.1f}K"
+    else:
+        return str(num)
+
+def draw_rounded_rectangle(draw: ImageDraw.Draw, bbox: tuple, radius: int, fill: tuple):
+    x1, y1, x2, y2 = bbox
+    
+    draw.rectangle((x1 + radius, y1, x2 - radius, y2), fill=fill)
+    draw.rectangle((x1, y1 + radius, x2, y2 - radius), fill=fill)
+    
+    draw.pieslice((x1, y1, x1 + 2*radius, y1 + 2*radius), 180, 270, fill=fill)
+    draw.pieslice((x2 - 2*radius, y1, x2, y1 + 2*radius), 270, 360, fill=fill)
+    draw.pieslice((x1, y2 - 2*radius, x1 + 2*radius, y2), 90, 180, fill=fill)
+    draw.pieslice((x2 - 2*radius, y2 - 2*radius, x2, y2), 0, 90, fill=fill)
+
+def draw_rounded_image(img: Image.Image, photo_img: Image.Image, x: int, y: int, radius: int = 16):
+    mask = Image.new("L", photo_img.size, 0)
+    mask_draw = ImageDraw.Draw(mask)
+    mask_draw.rounded_rectangle((0, 0, photo_img.width, photo_img.height), radius, fill=255)
+    
+    rounded_img = Image.new("RGBA", photo_img.size, (0, 0, 0, 0))
+    rounded_img.paste(photo_img, (0, 0))
+    rounded_img.putalpha(mask)
+    
+    img.paste(rounded_img, (x, y), rounded_img)
+
+def create_tweet_image(tweet: dict) -> BytesIO:
+    WIDTH, HEIGHT = 1080, 1350
+    
+    OUTER_BG_COLOR = (0, 0, 0)
+    INNER_BG_COLOR = (255, 255, 255)
+    TEXT_COLOR = (2, 6, 23)
+    SECONDARY_COLOR = (100, 116, 139)
+    STATS_COLOR = (110, 118, 125)
+    
+    OUTER_PADDING = 64
+    INNER_PADDING = 48
+    BORDER_RADIUS = 32
+    AVATAR_SIZE = 96
+    
+    raw_text = tweet.get("textHtml", "")
+    cleaned_text = clean_tweet_text(raw_text)
+    photos = tweet.get("photos", [])
+    videos = tweet.get("videos", [])
+    
+    media_url = None
+    if videos and videos[0].get("poster"):
+        media_url = videos[0]["poster"]
+    elif photos:
+        media_url = photos[0]
+    
+    has_media = media_url is not None
+    
+    base_font_size = 40
+    max_iterations = 10
+    current_iteration = 0
+    
+    while current_iteration < max_iterations:
+        try:
+            font_name = ImageFont.truetype("fonts/Chirp Bold.woff", int(base_font_size * 0.9))
+            font_handle = ImageFont.truetype("fonts/Chirp Regular.woff", int(base_font_size * 0.9))
+            font_text = ImageFont.truetype("fonts/Chirp Regular.woff", base_font_size)
+            font_stats_number = ImageFont.truetype("fonts/Chirp Bold.woff", int(base_font_size * 0.9))
+            font_stats_label = ImageFont.truetype("fonts/Chirp Regular.woff", int(base_font_size * 0.9))
+        except:
+            font_name = ImageFont.load_default()
+            font_handle = ImageFont.load_default()
+            font_text = ImageFont.load_default()
+            font_stats_number = ImageFont.load_default()
+            font_stats_label = ImageFont.load_default()
+        
+        text_max_width = WIDTH - (2 * OUTER_PADDING) - (2 * INNER_PADDING)
+        
+        temp_img = Image.new("RGB", (100, 100))
+        temp_draw = ImageDraw.Draw(temp_img)
+        
+        has_emojis = '<img' in raw_text and 'emoji' in raw_text
+        
+        if has_emojis:
+            lines = wrap_text_with_emojis(raw_text, font_text, text_max_width - 100, temp_draw)
+        else:
+            text_lines = wrap_text_with_newlines(cleaned_text, font_text, text_max_width, temp_draw)
+            lines = [{'text': line, 'emojis': []} for line in text_lines]
+        
+        line_height = int(font_text.size * 1.2)
+        text_height = len(lines) * line_height
+        
+        media_height = 0
+        media_margin = 0
+        if has_media:
+            if len(cleaned_text) > 200:
+                media_height = 250
+            elif len(cleaned_text) > 100:
+                media_height = 350
+            else:
+                media_height = 450
+            media_margin = 24
+        
+        header_height = AVATAR_SIZE + 16
+        text_margin = 20
+        stats_height = 40
+        stats_margin = 32
+        
+        total_content_height = (
+            INNER_PADDING +
+            header_height +
+            text_margin +
+            text_height +
+            (media_margin if has_media else 0) +
+            media_height +
+            (media_margin if has_media else 0) +
+            stats_margin +
+            stats_height +
+            INNER_PADDING
+        )
+        
+        max_card_height = HEIGHT - (2 * OUTER_PADDING)
+        
+        if total_content_height <= max_card_height or base_font_size <= 24:
+            break
+        
+        base_font_size -= 2
+        current_iteration += 1
+    
+    card_height = min(total_content_height, HEIGHT - (2 * OUTER_PADDING))
+    card_width = WIDTH - (2 * OUTER_PADDING)
+    
+    card_x = OUTER_PADDING
+    card_y = (HEIGHT - card_height) // 2 - 30
+    
+    img = Image.new("RGB", (WIDTH, HEIGHT), OUTER_BG_COLOR)
+    draw = ImageDraw.Draw(img)
+    
+    draw_rounded_rectangle(
+        draw, 
+        (card_x, card_y, card_x + card_width, card_y + card_height),
+        BORDER_RADIUS,
+        INNER_BG_COLOR
+    )
+    
+    content_x = card_x + INNER_PADDING
+    current_y = card_y + INNER_PADDING
+    
+    avatar_y = current_y
+    try:
+        avatar_resp = requests.get(tweet["avatarUrl"], timeout=10)
+        avatar_img = Image.open(BytesIO(avatar_resp.content)).convert("RGBA")
+        avatar_img = avatar_img.resize((AVATAR_SIZE, AVATAR_SIZE), Image.Resampling.LANCZOS)
+        
+        mask = Image.new("L", (AVATAR_SIZE, AVATAR_SIZE), 0)
+        mask_draw = ImageDraw.Draw(mask)
+        mask_draw.ellipse((0, 0, AVATAR_SIZE, AVATAR_SIZE), fill=255)
+        
+        img.paste(avatar_img, (content_x, avatar_y), mask)
+    except:
+        draw.ellipse(
+            (content_x, avatar_y, content_x + AVATAR_SIZE, avatar_y + AVATAR_SIZE),
+            fill=(200, 200, 200)
+        )
+    
+    user_info_x = content_x + AVATAR_SIZE + 20
+    user_info_y = avatar_y
+    
+    name = tweet.get("nameHtml", "Nome Desconhecido")
+    name = clean_tweet_text(name)
+    draw.text((user_info_x, user_info_y), name, font=font_name, fill=TEXT_COLOR)
+    
+    verified = tweet.get("verified", False)
+    if verified:
+        name_width = draw.textlength(name, font=font_name)
+        badge_x = user_info_x + name_width + 14
+        badge_y = user_info_y + 6
+        create_verification_badge(draw, badge_x, badge_y, 28)
+    
+    handle = tweet.get("handler", "@unknown")
+    if not handle.startswith('@'):
+        handle = f"@{handle}"
+    
+    handle_y = user_info_y + 44
+    draw.text((user_info_x, handle_y), handle, font=font_handle, fill=SECONDARY_COLOR)
+    
+    current_y = avatar_y + header_height + text_margin
+    
+    for line_data in lines:
+        line_text = line_data['text']
+        line_emojis = line_data.get('emojis', [])
+        
+        if line_text.strip() or line_emojis:
+            text_x = content_x
+            
+            if has_emojis and line_emojis:
+                current_x = text_x
+                text_parts = []
+                last_pos = 0
+                
+                sorted_emojis = sorted(line_emojis, key=lambda e: e['position'])
+                
+                for emoji_data in sorted_emojis:
+                    emoji_pos = emoji_data['position']
+                    emoji_info = emoji_data['emoji']
+                    
+                    if emoji_pos > last_pos:
+                        text_before = line_text[last_pos:emoji_pos]
+                        if text_before:
+                            draw.text((current_x, current_y), text_before, font=font_text, fill=TEXT_COLOR)
+                            current_x += draw.textlength(text_before, font=font_text)
+                    
+                    emoji_img = download_emoji(emoji_info['url'])
+                    if emoji_img:
+                        emoji_y = current_y + (line_height - 32) // 2
+                        img.paste(emoji_img, (int(current_x), int(emoji_y)), emoji_img)
+                        current_x += 32
+                    else:
+                        draw.text((current_x, current_y), emoji_info['char'], font=font_text, fill=TEXT_COLOR)
+                        current_x += draw.textlength(emoji_info['char'], font=font_text)
+                    
+                    last_pos = emoji_pos + len(emoji_info['char'])
+                
+                if last_pos < len(line_text):
+                    remaining_text = line_text[last_pos:]
+                    draw.text((current_x, current_y), remaining_text, font=font_text, fill=TEXT_COLOR)
+            else:
+                draw.text((text_x, current_y), line_text, font=font_text, fill=TEXT_COLOR)
+        
+        current_y += line_height
+    
+    if has_media:
+        current_y += media_margin
+        media_img = download_and_resize_image(media_url, text_max_width, media_height)
+        
+        if media_img:
+            media_x = content_x
+            media_y = current_y
+            
+            draw_rounded_image(img, media_img, media_x, media_y, 16)
+            current_y = media_y + media_img.height + media_margin
+    
+    current_y += stats_margin
+    stats_y = current_y
+    stats_x = content_x
+    
+    retweets = tweet.get("retweets", 0)
+    retweets_text = format_number(retweets)
+    draw.text((stats_x, stats_y), retweets_text, font=font_stats_number, fill=TEXT_COLOR)
+    
+    retweets_num_width = draw.textlength(retweets_text, font=font_stats_number)
+    retweets_label_x = stats_x + retweets_num_width + 12
+    draw.text((retweets_label_x, stats_y), "Retweets", font=font_stats_label, fill=STATS_COLOR)
+    
+    retweets_label_width = draw.textlength("Retweets", font=font_stats_label)
+    likes_x = retweets_label_x + retweets_label_width + 44
+    
+    likes = tweet.get("likes", 0)
+    likes_text = format_number(likes)
+    draw.text((likes_x, stats_y), likes_text, font=font_stats_number, fill=TEXT_COLOR)
+    
+    likes_num_width = draw.textlength(likes_text, font=font_stats_number)
+    likes_label_x = likes_x + likes_num_width + 12
+    draw.text((likes_label_x, stats_y), "Likes", font=font_stats_label, fill=STATS_COLOR)
+    
+    try:
+        logo_path = "recurve.png"
+        logo = Image.open(logo_path).convert("RGBA")
+        logo_width, logo_height = 121, 23
+        logo_resized = logo.resize((logo_width, logo_height))
+        
+        logo_with_opacity = Image.new("RGBA", logo_resized.size)
+        for x in range(logo_resized.width):
+            for y in range(logo_resized.height):
+                r, g, b, a = logo_resized.getpixel((x, y))
+                new_alpha = int(a * 0.42)
+                logo_with_opacity.putpixel((x, y), (r, g, b, new_alpha))
+        
+        logo_x = WIDTH - logo_width - 64
+        logo_y = HEIGHT - logo_height - 64
+        img.paste(logo_with_opacity, (logo_x, logo_y), logo_with_opacity)
+    except Exception as e:
+        print(f"Erro ao carregar a logo: {e}")
+    
+    buffer = BytesIO()
+    img.save(buffer, format="PNG", quality=95)
+    buffer.seek(0)
+    return buffer
+
+def extract_tweet_id(tweet_url: str) -> str:
+    match = re.search(r"/status/(\d+)", tweet_url)
+    if not match:
+        raise HTTPException(status_code=400, detail="URL de tweet inválida")
+    return match.group(1)
+
+@router.get("/tweet/image")
+def get_tweet_image(tweet_url: str = Query(..., description="URL do tweet")):
+    tweet_id = extract_tweet_id(tweet_url)
+    tweet_data = fetch_tweet_data(tweet_id)
+    img_buffer = create_tweet_image(tweet_data)
+    return StreamingResponse(img_buffer, media_type="image/png")

routers/video.py

@@ -0,0 +1,396 @@
+from fastapi import APIRouter, Query, HTTPException
+from fastapi.responses import StreamingResponse
+from moviepy.editor import VideoFileClip, CompositeVideoClip, ColorClip, ImageClip, TextClip
+from moviepy.video.VideoClip import VideoClip
+from moviepy.video.fx.all import resize
+from io import BytesIO
+import tempfile
+import requests
+import os
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import gc
+import re
+from typing import List, Tuple, Optional
+
+router = APIRouter()
+
+def download_file(url: str, suffix: str = ".mp4") -> str:
+    """Download genérico para vídeos e arquivos SRT"""
+    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 download_video(video_url: str) -> str:
+    return download_file(video_url, ".mp4")
+
+def download_srt(srt_url: str) -> str:
+    return download_file(srt_url, ".srt")
+
+def parse_srt(srt_path: str) -> List[Tuple[float, float, str]]:
+    """Parse arquivo SRT e retorna lista de tuplas (start_time, end_time, text)"""
+    subtitles = []
+    
+    with open(srt_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+    
+    # Regex para extrair informações do SRT
+    pattern = r'(\d+)\s*\n(\d{2}:\d{2}:\d{2},\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2},\d{3})\s*\n(.*?)(?=\n\d+\s*\n|\n*$)'
+    matches = re.findall(pattern, content, re.DOTALL)
+    
+    for match in matches:
+        start_time_str = match[1]
+        end_time_str = match[2]
+        text = match[3].strip()
+        
+        # Converter timestamp para segundos
+        start_time = time_to_seconds(start_time_str)
+        end_time = time_to_seconds(end_time_str)
+        
+        subtitles.append((start_time, end_time, text))
+    
+    print(f"Parsed {len(subtitles)} subtítulos do arquivo SRT")
+    return subtitles
+
+def time_to_seconds(time_str: str) -> float:
+    """Converte timestamp SRT (HH:MM:SS,mmm) para segundos"""
+    time_str = time_str.replace(',', '.')
+    parts = time_str.split(':')
+    hours = int(parts[0])
+    minutes = int(parts[1])
+    seconds = float(parts[2])
+    return hours * 3600 + minutes * 60 + seconds
+
+def create_rounded_mask(w: int, h: int, radius: int) -> np.ndarray:
+    """Cria uma máscara numpy com cantos arredondados otimizada"""
+    img = Image.new("L", (w, h), 0)
+    draw = ImageDraw.Draw(img)
+    draw.rounded_rectangle((0, 0, w, h), radius=radius, fill=255)
+    mask = np.array(img, dtype=np.float32) / 255.0
+    return mask
+
+def create_text_image(text: str, font_path: str, font_size: int, color: str = "white", width: int = 900, background_color: str = None) -> np.ndarray:
+    """Cria uma imagem com texto usando PIL e retorna array numpy diretamente com quebra de linha"""
+    try:
+        font = ImageFont.truetype(font_path, font_size)
+    except:
+        font = ImageFont.load_default()
+    
+    # Função para quebrar texto em múltiplas linhas
+    def wrap_text(text, font, max_width):
+        # Primeiro, dividir por quebras de linha existentes (importantes para SRT)
+        existing_lines = text.split('\n')
+        final_lines = []
+        
+        for line in existing_lines:
+            if not line.strip():  # Pular linhas vazias
+                continue
+                
+            words = line.split(' ')
+            current_line = []
+            
+            for word in words:
+                test_line = ' '.join(current_line + [word])
+                bbox = font.getbbox(test_line)
+                test_width = bbox[2] - bbox[0]
+                
+                if test_width <= max_width - 40:  # 40px de margem total
+                    current_line.append(word)
+                else:
+                    if current_line:
+                        final_lines.append(' '.join(current_line))
+                        current_line = [word]
+                    else:
+                        final_lines.append(word)
+            
+            if current_line:
+                final_lines.append(' '.join(current_line))
+        
+        return final_lines
+    
+    # Quebrar o texto em linhas
+    lines = wrap_text(text, font, width)
+    
+    # Calcular dimensões totais baseadas na altura real da fonte
+    font_metrics = font.getmetrics()
+    ascent, descent = font_metrics
+    line_height = ascent + descent
+    line_spacing = int(line_height * 0.2)
+    total_height = len(lines) * line_height + (len(lines) - 1) * line_spacing
+    
+    # Definir padding para o fundo
+    padding_vertical = 16 if background_color else 10
+    padding_horizontal = 24 if background_color else 10
+    
+    # Criar imagem com altura ajustada para múltiplas linhas
+    img = Image.new("RGBA", (width, total_height + padding_vertical * 2), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(img)
+    
+    # Desenhar fundo se especificado
+    if background_color:
+        # Calcular largura máxima do texto para um fundo mais ajustado
+        max_text_width = 0
+        for line in lines:
+            bbox = font.getbbox(line)
+            line_width = bbox[2] - bbox[0]
+            max_text_width = max(max_text_width, line_width)
+        
+        # Calcular dimensões do fundo
+        bg_width = max_text_width + padding_horizontal * 2
+        bg_height = total_height + padding_vertical * 2
+        bg_x = (width - bg_width) // 2
+        bg_y = 0
+        
+        # Desenhar fundo com cantos arredondados
+        draw.rounded_rectangle(
+            (bg_x, bg_y, bg_x + bg_width, bg_y + bg_height),
+            radius=6,
+            fill=background_color
+        )
+    
+    # Desenhar cada linha centralizada usando baseline correto
+    current_y = padding_vertical
+    for line in lines:
+        bbox = font.getbbox(line)
+        line_width = bbox[2] - bbox[0]
+        line_x = (width - line_width) // 2  # Centralizar cada linha
+        draw.text((line_x, current_y), line, font=font, fill=color)
+        current_y += line_height + line_spacing
+    
+    return np.array(img, dtype=np.uint8)
+
+def create_subtitle_clips(subtitles: List[Tuple[float, float, str]], video_duration: float) -> List[ImageClip]:
+    """Cria clips de legenda otimizados usando ImageClip"""
+    subtitle_clips = []
+    
+    for start_time, end_time, text in subtitles:
+        # Ignorar legendas que ultrapassam a duração do vídeo
+        if start_time >= video_duration:
+            continue
+        
+        # Ajustar end_time se necessário
+        if end_time > video_duration:
+            end_time = video_duration
+        
+        # Criar imagem da legenda com fonte Medium e fundo escuro
+        subtitle_array = create_text_image(
+            text, 
+            "fonts/Montserrat-Medium.ttf",  # Fonte Medium para legendas
+            32,  # Tamanho para legendas
+            "white", 
+            900,
+            "#1A1A1A"  # Fundo escuro para legendas
+        )
+        
+        # Criar clip de imagem
+        subtitle_clip = ImageClip(subtitle_array, duration=end_time - start_time)
+        subtitle_clip = subtitle_clip.set_start(start_time)
+        
+        subtitle_clips.append(subtitle_clip)
+    
+    print(f"Criados {len(subtitle_clips)} clips de legenda")
+    return subtitle_clips
+
+def create_centered_video_on_black_background(
+    video_path: str, 
+    text: str = "Season 1, episode 1", 
+    srt_path: Optional[str] = None,
+    output_resolution=(1080, 1920), 
+    max_height=500, 
+    max_width=900
+) -> BytesIO:
+    print(f"Iniciando processamento do vídeo: {video_path}")
+    
+    clip = None
+    background = None
+    text_clip = None
+    centered_clip = None
+    final = None
+    subtitle_clips = []
+    
+    try:
+        # Carregar vídeo
+        clip = VideoFileClip(video_path, audio=True, verbose=False)
+        print(f"Vídeo carregado - Dimensões: {clip.w}x{clip.h}, Duração: {clip.duration}s, FPS: {clip.fps}")
+        
+        # Redimensionar vídeo para 500px de altura máxima
+        if clip.w != max_width or clip.h > max_height:
+            scale_w = max_width / clip.w
+            scale_h = max_height / clip.h
+            scale = min(scale_w, scale_h)
+            new_width = int(clip.w * scale)
+            new_height = int(clip.h * scale)
+            print(f"Redimensionando para: {new_width}x{new_height} (max_height={max_height})")
+            clip = clip.resize(newsize=(new_width, new_height))
+        
+        # Criar fundo preto
+        background = ColorClip(size=output_resolution, color=(0, 0, 0), duration=clip.duration)
+        
+        # Criar máscara arredondada baseada no tamanho atual do vídeo
+        print(f"Criando máscara para vídeo: {clip.w}x{clip.h}")
+        mask_array = create_rounded_mask(clip.w, clip.h, radius=80)
+        
+        def make_mask_frame(t):
+            return mask_array
+        
+        mask_clip = VideoClip(make_mask_frame, ismask=True, duration=clip.duration)
+        clip = clip.set_mask(mask_clip)
+        
+        # Criar texto principal
+        text_array = create_text_image(text, "fonts/Montserrat-SemiBold.ttf", 38, "white", 900)
+        text_clip = ImageClip(text_array, duration=clip.duration)
+        
+        # Centralizar o vídeo
+        centered_clip = clip.set_position(("center", "center"))
+        
+        # Posicionar texto principal (45px de distância do vídeo)
+        video_top = (output_resolution[1] - clip.h) // 2
+        text_y = video_top - 45 - text_clip.h
+        text_clip = text_clip.set_position(("center", text_y))
+        
+        # Processar legendas se fornecidas
+        if srt_path:
+            print("Processando legendas SRT...")
+            subtitles = parse_srt(srt_path)
+            subtitle_clips = create_subtitle_clips(subtitles, clip.duration)
+            
+            # Posicionar legendas abaixo do vídeo (45px de distância)
+            video_bottom = (output_resolution[1] + clip.h) // 2
+            subtitle_y = video_bottom + 45  # 45px de espaçamento
+            
+            # Aplicar posicionamento a cada clip individual
+            for i, subtitle_clip in enumerate(subtitle_clips):
+                subtitle_clips[i] = subtitle_clip.set_position(("center", subtitle_y))
+        
+        # Compor todos os elementos
+        all_clips = [background, text_clip, centered_clip] + subtitle_clips
+        final = CompositeVideoClip(all_clips)
+        
+        print("Composição finalizada, iniciando renderização...")
+        
+        buffer = BytesIO()
+        tmp_output_path = None
+        
+        try:
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_output:
+                tmp_output_path = tmp_output.name
+            
+            print(f"Renderizando para arquivo temporário: {tmp_output_path}")
+            
+            final.write_videofile(
+                tmp_output_path,
+                codec="libx264",
+                audio_codec="aac",
+                fps=clip.fps,
+                preset="ultrafast",
+                threads=os.cpu_count(),
+                temp_audiofile="temp-audio.m4a",
+                remove_temp=True,
+                audio=True,
+                logger=None,
+                verbose=False,
+                ffmpeg_params=[
+                    "-crf", "23",
+                    "-movflags", "+faststart",
+                    "-tune", "fastdecode",
+                    "-x264opts", "no-scenecut"
+                ]
+            )
+            
+            print("Renderização concluída, lendo arquivo...")
+            with open(tmp_output_path, "rb") as f:
+                buffer.write(f.read())
+            buffer.seek(0)
+            
+            print(f"Vídeo processado com sucesso. Tamanho final: {buffer.getbuffer().nbytes} bytes")
+            
+        finally:
+            if tmp_output_path and os.path.exists(tmp_output_path):
+                os.unlink(tmp_output_path)
+    
+    except Exception as e:
+        print(f"Erro durante processamento: {e}")
+        raise
+    
+    finally:
+        # Limpeza de memória
+        clips_to_close = [clip, background, text_clip, centered_clip, final] + subtitle_clips
+        for c in clips_to_close:
+            if c is not None:
+                try:
+                    c.close()
+                except:
+                    pass
+        
+        gc.collect()
+    
+    return buffer
+
+@router.get("/cover/video")
+def get_video_with_black_background(
+    video_url: str = Query(..., description="URL do vídeo em .mp4 para centralizar em fundo preto com cantos arredondados"),
+    text: str = Query("Season 1, episode 1", description="Texto a ser exibido acima do vídeo"),
+    srt_url: Optional[str] = Query(None, description="URL do arquivo SRT de legendas (opcional)")
+):
+    local_video = None
+    local_srt = None
+    
+    try:
+        # Baixar vídeo
+        local_video = download_video(video_url)
+        
+        # Baixar SRT se fornecido
+        if srt_url:
+            local_srt = download_srt(srt_url)
+        
+        # Processar vídeo com altura máxima de 500px
+        video_buffer = create_centered_video_on_black_background(
+            local_video, 
+            text, 
+            local_srt
+        )
+        
+        return StreamingResponse(video_buffer, media_type="video/mp4")
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao processar vídeo: {e}")
+    
+    finally:
+        # Limpeza de arquivos temporários
+        for temp_file in [local_video, local_srt]:
+            if temp_file and os.path.exists(temp_file):
+                os.unlink(temp_file)