Initial commit from cloned Space

.gitattributes

@@ -33,3 +33,26 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Inter-Bold.otf filter=lfs diff=lfs merge=lfs -text
+fonts/Inter-Bold.otf filter=lfs diff=lfs merge=lfs -text
+fonts/Montserrat-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/Montserrat-SemiBold.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/Montserrat-Medium.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/AGaramondPro-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/AGaramondPro-BoldItalic.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/AGaramondPro-Italic.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/AGaramondPro-Regular.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/AGaramondPro-Semibold.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/AGaramondPro-SemiboldItalic.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/WorkSans-Italic.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/WorkSans-Regular.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/WorkSans-SemiBold.ttf filter=lfs diff=lfs merge=lfs -text
+fonts/WorkSans-SemiBoldItalic.ttf filter=lfs diff=lfs merge=lfs -text
+arrastar.png filter=lfs diff=lfs merge=lfs -text
+cross.png filter=lfs diff=lfs merge=lfs -text
+fonts/Chirp filter=lfs diff=lfs merge=lfs -text
+Bold.woff filter=lfs diff=lfs merge=lfs -text
+Regular.woff filter=lfs diff=lfs merge=lfs -text
+recurve.png filter=lfs diff=lfs merge=lfs -text
+recurvecuriosity.png filter=lfs diff=lfs merge=lfs -text
+star.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.9
+
+RUN apt-get update && apt-get install -y libgl1
+#
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,8 +1,8 @@
 ---
-title: Newapi Clone3
-emoji: 🌖
-colorFrom: green
-colorTo: green
+title: Newapi
+emoji: 👁
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
 ---

app.py

@@ -0,0 +1,50 @@
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, Request
+from routers import news
+from routers import curiosity
+from routers import memoriam
+from routers import getnews
+from routers import filter
+from routers import inference
+from routers import video
+from routers import subtitle
+from routers import image
+from routers import analyze
+from routers import search
+from routers import twitter
+from routers import searchterm
+from routers import inference_createposter
+from routers import db
+from routers.db import connect_db, disconnect_db
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    await connect_db()
+    yield
+    # Shutdown
+    await disconnect_db()
+
+# Instancia a aplicação FastAPI
+app = FastAPI(lifespan=lifespan)
+    
+@app.get("/")
+def greet_json():
+    return {"Hello": "World!"}
+
+# Inclui as rotas
+app.include_router(news.router)
+app.include_router(curiosity.router)
+app.include_router(memoriam.router)
+app.include_router(getnews.router)
+app.include_router(filter.router)
+app.include_router(inference.router)
+app.include_router(video.router)
+app.include_router(subtitle.router)
+app.include_router(image.router)
+app.include_router(analyze.router)
+app.include_router(search.router)
+app.include_router(twitter.router)
+app.include_router(searchterm.router)
+app.include_router(inference_createposter.router)
+app.include_router(db.router)

fonts/AGaramondPro-Bold.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9966b8104a59c5af0d1ca9f01a5643c40cbb7cc77d8774904612badfb7bf98f1
+size 105764

fonts/AGaramondPro-BoldItalic.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1db2dbb1b664b6be8a65a81cf61c7d2dd6102c21949509a3049c0892f99be789
+size 107332

fonts/AGaramondPro-Italic.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cdd92bc0fb487d46d98b8db2f17f9530fb1769d0536aab810aedf80158a570f4
+size 137248

fonts/AGaramondPro-Regular.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c4f462ed1a8dc1f188c527eaf4217657ca85525bbec16689a6183b55857ca54
+size 178372

fonts/AGaramondPro-Semibold.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49566aaa32789492a3e34a0043bc245e9ddd767486bc38744dfe0ee83e0c558d
+size 140732

fonts/AGaramondPro-SemiboldItalic.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5e22572f19cb5f6857d093754af06c4136748e31288f915eb416d3e876b6dd3
+size 107912

fonts/Inter-Bold.otf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1e8d028b7007a080d3b081a636712b98d48eeca67cf24724febd9447521e288
+size 232056

fonts/Montserrat-Bold.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:846d5823e5c909a5aad49efbd71dd5f3320a8640fff86840bf7d529c8d8660a5
+size 335788

fonts/Montserrat-Medium.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d557ed5f56b95c2be4a712e09c9636c864a5ec49bd124fe4f2973bee128ecfb
+size 330872

fonts/Montserrat-SemiBold.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef7b80ad18d3afab1c769972452d1e2e44c20ba12a7b1cb1c6d662525c8558ae
+size 333988

fonts/WorkSans-Italic.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b7f7002e0b0c8b261fe878658ef5551e3e59d9f6b609b04efb90dde1e2c1ada
+size 174280

fonts/WorkSans-Regular.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e67985a843df0d3cdee51a3d0f329eb1774a344ad9ff0c9ab923751f1577e2a4
+size 188916

fonts/WorkSans-SemiBold.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9220892ffd913cdb1b4cd874009557b2b1330f14366d363ec99393f5c50e08e1
+size 191016

fonts/WorkSans-SemiBoldItalic.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d272da2946c6ced1569e68c000ad89d0d36bdd75f9815adc9665116cf50a0ef0
+size 175504

requirements.txt

@@ -0,0 +1,35 @@
+fastapi
+uvicorn
+better-profanity
+pillow
+numpy
+requests
+dnspython
+opencv-python
+lxml_html_clean
+beautifulsoup4
+google-genai
+httpx[http2]
+aiohttp
+transformers
+peft
+torch
+accelerate
+newspaper3k
+trafilatura
+groq
+moviepy==1.0.3
+pygame
+librosa
+scipy
+soundfile
+noisereduce
+audio_separator
+onnxruntime
+aiofiles
+ujson
+datetime
+pydantic
+sqlalchemy
+databases[mysql]
+asyncmy

routers/__init__.py

@@ -0,0 +1 @@
+##

routers/analyze.py

@@ -0,0 +1,501 @@
+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-clone2.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
+        }
+        
+        # Validação básica da resposta
+        required_keys = ["title", "subhead", "content"]
+        if all(key in rewritten_data and rewritten_data[key].strip() for key in required_keys):
+            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 required_keys 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
+                    required_keys = ["title", "subhead", "content"]
+                    if all(key in rewritten_data for key in required_keys):
+                        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 required_keys 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 incluindo campos do Instagram"""
+    try:
+        session = await get_http_session()
+        url = f"{SUPABASE_URL}/rest/v1/news"
+        params = {"id": f"eq.{news_id}"}
+        
+        payload = {
+            "title_pt": rewritten_data.get("title", ""),
+            "text_pt": rewritten_data.get("content", ""),
+            "subhead_pt": rewritten_data.get("subhead", "")
+        }
+        
+        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}")
+            
+    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-clone2.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-clone2.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/db.py

@@ -0,0 +1,60 @@
+# db.py
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Optional
+import databases
+import sqlalchemy
+import os
+
+# Opção 1: Apenas variável de ambiente (mais seguro)
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+# Verificação se a variável existe
+if not DATABASE_URL:
+    raise ValueError("DATABASE_URL environment variable is not set")
+
+database = databases.Database(DATABASE_URL, min_size=5, max_size=20)
+metadata = sqlalchemy.MetaData()
+
+igbio = sqlalchemy.Table(
+    "igbio",
+    metadata,
+    sqlalchemy.Column("url_instagram", sqlalchemy.Text),
+    sqlalchemy.Column("url_web", sqlalchemy.Text),
+    sqlalchemy.Column("image", sqlalchemy.Text),
+)
+
+router = APIRouter()
+
+class IGPost(BaseModel):
+    url_instagram: Optional[str] = None
+    url_web: Optional[str] = None
+    image: Optional[str] = None
+
+async def connect_db():
+    await database.connect()
+
+async def disconnect_db():
+    await database.disconnect()
+
+@router.post("/igbio")
+async def add_igbio(item: IGPost):
+    def clean_value(value: Optional[str]) -> Optional[str]:
+        if value is None:
+            return None
+        val = value.strip()
+        if val == "" or val.lower() == "null":
+            return None
+        return val
+
+    query = igbio.insert().values(
+        url_instagram=clean_value(item.url_instagram),
+        url_web=clean_value(item.url_web),
+        image=clean_value(item.image),
+    )
+
+    try:
+        record_id = await database.execute(query)
+        return {"success": True, "id": record_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao inserir no banco: {e}")

routers/filter.py

@@ -0,0 +1,1011 @@
+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): True only if the news topic has a clear and direct impact, relevance, or interest for the Brazilian audience. This includes:
+
+Events, releases, or announcements happening in Brazil or significant international announcements.
+Content (movies, series, sports, games, music) officially available in Brazil.
+People, teams, companies, brands, or productions that are relevant and recognized by the Brazilian audience.
+International celebrities, athletes, or artists with significant fan bases in Brazil.
+
+Do not mark as true if the content is unknown to most of the Brazilian population or if the actors, artists, or productions do not have notable recognition in the country.
+
+Examples:
+
+"Couple on 'House Hunters' with a 30-year age difference shocks viewers" — TRUE (In Brazil, House Hunters is Em Busca da Casa Perfeita, so it is available)
+"Wild Bill Wichrowski from 'Deadliest Catch' will miss the 21st season after battling prostate cancer" — TRUE (Because Deadliest Catch is known in Brazil as Pesca Mortal)
+"Loni Anderson, star of 'WKRP in Cincinnati,' dies at 79" — FALSE (Few people know her in Brazil, and WKRP in Cincinnati is not available there)
+"The 'forgotten' film in the 'Conjuring' universe: why 'The Curse of La Llorona' is considered the worst of the franchise" — TRUE
+"Rose Byrne collapses: new A24 film described as a 'test of endurance'" — TRUE (Rose Byrne is well-known in Brazil)
+"Star Trek: how to understand the timeline of one of the greatest sci-fi sagas" — TRUE
+"Crisis at Mubi: top filmmakers, including Israelis, demand boycott over ties to military investor" — TRUE (Mubi operates in Brazil)
+"Liam Neeson and Joe Keery face biological terror in the trailer for Cold Storage" — TRUE (Joe Keery is well-known in Brazil for Stranger Things)
+"TIFF 2025: from John Candy to Lucrecia Martel, meet the documentaries of the year" — TRUE (Toronto International Film Festival is one of the most famous independent festivals, so it is considered relevant to Brazil)
+"TIFF 2025: festival announces documentaries with Lucrecia Martel and a production by Barack and Michelle Obama" — TRUE (Toronto International Film Festival is well-known, relevant to Brazil)
+"'Stranger Things' universe expands: animated series and stage play confirmed" — TRUE (Stranger Things is well-known in Brazil)
+"New Park Chan-wook film with stars from 'Squid Game' and 'Landing on Love' will open a film festival" — TRUE (No Other Choice features a famous actor from Squid Game)
+"Francis Ford Coppola hospitalized in Rome, but reassures fans: 'I'm fine'" — TRUE (Francis Coppola is internationally known)
+"Ken Jennings used 'Who Wants to Be a Millionaire?' to provoke a rival, but the scene was cut" — FALSE (This program is not Brazilian; Brazil has its own more popular version)
+"Canelo vs. Crawford: Netflix confirms fight of the century without pay-per-view cost" — TRUE (Even though they are not Brazilian, fights usually attract worldwide interest)
+
+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 (Last 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 - SÉRIE HBO RENOVADA
+        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":"low",
+   "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 - SEQUÊNCIA DE FILME
+        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 - SÉRIE COM SPOILERS E MORTE DE PERSONAGEM
+        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 - MORTE DE CELEBRIDADE
+        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":"high",
+   "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
+}"""
+
+        # Quinto exemplo - SEQUÊNCIA DE FILME COM ELEMENTOS POLÍTICOS
+        EXAMPLE_INPUT_5 = f"""Title: Mikey Madison and Jeremy Allen White Circling Lead Roles in Aaron Sorkin's 'Social Network' Sequel
+Content: Mikey Madison and Jeremy Allen White are circling the lead roles for Aaron Sorkin's sequel to the 2010 Oscar winner "The Social Network," according to sources with knowledge of the project. While no offers have been made, Sorkin has met with both Madison and White about the project. The film is still very much in the development stage and has yet to receive the green light from Sony.
+Last titles:
+- Wild Bill Wichrowski do 'Deadliest Catch' ficará de fora da 21ª temporada após batalha contra o câncer de próstata
+- Loni Anderson, estrela de 'WKRP in Cincinnati', morre aos 79 anos
+- O filme "esquecido" do universo "Invocação do Mal": entenda por que "A Maldição da Chorona" é considerado o pior da franquia
+- Rose Byrne em colapso: novo filme da A24 é descrito como 'teste de resistência'
+- Jornada nas Estrelas: como entender a linha do tempo de uma das maiores sagas da ficção
+- Crise na Mubi: cineastas de peso, incluindo israelenses, exigem boicote por laços com investidor militar"""
+
+        EXAMPLE_OUTPUT_5 = """{
+   "death_related":false,
+   "political_related":true,
+   "woke_related":false,
+   "spoilers":false,
+   "sensitive_theme":false,
+   "contains_video":false,
+   "is_news_content":true,
+   "relevance":"high",
+   "brazil_interest":true,
+   "breaking_news":true,
+   "audience_age_rating":14,
+   "regional_focus":"americas",
+   "country_focus":"au",
+   "ideological_alignment":"apolitical",
+   "entity_type":"movie",
+   "entity_name":"The Social Network",
+   "duplication":false
+}"""
+
+        # Sexto exemplo - EPISÓDIO COM SPOILERS
+        EXAMPLE_INPUT_6 = f"""Title: Star Trek: Strange New Worlds' Holodeck Episode Began As A Tribute To A DS9 Masterpiece [Exclusive]
+Content: Spoilers for episode 4 of "Star Trek: Strange New Worlds" season 4, titled "A Space Adventure Hour," episode follow. The newest episode of "Star Trek: Strange New Worlds" — "A Space Adventure Hour," written by Dana Horgan & Kathryn Lyn — features the show going back to the past. Except, it's not a time travel episode. To test a prototype holodeck, La'an (Christina Chong) crafts a murder mystery story set in mid-20th century Hollywood where she's the detective, Amelia Moon. And the suspects are the cast and crew of a space adventure series, "The Last Frontier," that's about to be canceled. The episode has enough metatext to fill the whole Enterprise, because "The Last Frontier" is a clear stand-in for "Star Trek: The Original Series." However, the writers weren't just thinking about "TOS" when it came to "A Space Adventure Hour."
+Last titles:
+- Wild Bill Wichrowski do 'Deadliest Catch' ficará de fora da 21ª temporada após batalha contra o câncer de próstata
+- Loni Anderson, estrela de 'WKRP in Cincinnati', morre aos 79 anos
+- O filme "esquecido" do universo "Invocação do Mal": entenda por que "A Maldição da Chorona" é considerado o pior da franquia
+- Rose Byrne em colapso: novo filme da A24 é descrito como 'teste de resistência'
+- Jornada nas Estrelas: como entender a linha do tempo de uma das maiores sagas da ficção
+- Crise na Mubi: cineastas de peso, incluindo israelenses, exigem boicote por laços com investidor militar"""
+
+        EXAMPLE_OUTPUT_6 = """{
+   "death_related": false,
+   "political_related": false,
+   "woke_related": false,
+   "spoilers": true,
+   "sensitive_theme": false,
+   "contains_video": false,
+   "is_news_content": true,
+   "relevance": "medium",
+   "brazil_interest": true,
+   "breaking_news": false,
+   "audience_age_rating": 10,
+   "regional_focus": "global",
+   "country_focus": "us",
+   "ideological_alignment": "apolitical",
+   "entity_type": "series",
+   "entity_name": "Star Trek: Strange New Worlds",
+   "duplication": false
+}"""
+
+        # Sétimo exemplo - SÉRIE DE HORROR (TEMA SENSÍVEL)
+        EXAMPLE_INPUT_7 = f"""Title: 'Hostel' TV Series From Eli Roth and Starring Paul Giamatti Lands at Peacock for Development (Exclusive)
+Content: The "Hostel" TV series has found a home at Peacock. Variety has learned exclusively that the TV extension of the horror film franchise is currently in development at the NBCUniversal streamer. The show was previously reported to be in the works in June 2024, but no platform was attached at that time. As originally reported, Paul Giamatti is attached to star in the series, with "Hostel" mastermind Eli Roth set to write, direct, and executive produce. Chris Briggs and Mike Fleiss, who have produced all the "Hostel" films, are also executive producers. Fifth Season is the studio. Exact plot details are being kept under wraps.
+Last titles:
+- Wild Bill Wichrowski do 'Deadliest Catch' ficará de fora da 21ª temporada após batalha contra o câncer de próstata
+- Loni Anderson, estrela de 'WKRP in Cincinnati', morre aos 79 anos
+- O filme "esquecido" do universo "Invocação do Mal": entenda por que "A Maldição da Chorona" é considerado o pior da franquia
+- Rose Byrne em colapso: novo filme da A24 é descrito como 'teste de resistência'
+- Jornada nas Estrelas: como entender a linha do tempo de uma das maiores sagas da ficção
+- Crise na Mubi: cineastas de peso, incluindo israelenses, exigem boicote por laços com investidor militar"""
+
+        EXAMPLE_OUTPUT_7 = """{
+   "death_related": false,
+   "political_related": false,
+   "woke_related": false,
+   "spoilers": false,
+   "sensitive_theme": true,
+   "contains_video": false,
+   "is_news_content": true,
+   "relevance": "medium",
+   "brazil_interest": false,
+   "breaking_news": false,
+   "audience_age_rating": 18,
+   "regional_focus": "global",
+   "country_focus": "us",
+   "ideological_alignment": "apolitical",
+   "entity_type": "series",
+   "entity_name": "Hostel",
+   "duplication": false
+}"""
+
+        # Oitavo exemplo - EVENTO ESPORTIVO
+        EXAMPLE_INPUT_8 = f"""Title: Is Canelo vs. Crawford Free on Netflix? Here's How to Watch the Fight 
+Content: When boxing legends Saúl "Canelo" Álvarez and Terence "Bud" Crawford meet in the ring on Sept. 13, it won't just be a clash of champions — it could be a career-defining moment. For the first time ever two of the most dominant fighters of their generation will share the ring. Only one will walk away as the greatest of their era. Given the high stakes and the long tradition of pay-per-view boxing events, fans are asking: Is Canelo vs. Crawford free on Netflix? Keep scrolling to learn more.
+Last titles:
+- Wild Bill Wichrowski do 'Deadliest Catch' ficará de fora da 21ª temporada após batalha contra o câncer de próstata
+- Loni Anderson, estrela de 'WKRP in Cincinnati', morre aos 79 anos
+- O filme "esquecido" do universo "Invocação do Mal": entenda por que "A Maldição da Chorona" é considerado o pior da franquia
+- Rose Byrne em colapso: novo filme da A24 é descrito como 'teste de resistência'
+- Jornada nas Estrelas: como entender a linha do tempo de uma das maiores sagas da ficção
+- Crise na Mubi: cineastas de peso, incluindo israelenses, exigem boicote por laços com investidor militar"""
+
+        EXAMPLE_OUTPUT_8 = """{
+   "death_related": false,
+   "political_related": false,
+   "woke_related": false,
+   "spoilers": false,
+   "sensitive_theme": false,
+   "contains_video": false,
+   "is_news_content": true,
+   "relevance": "high",
+   "brazil_interest": true,
+   "breaking_news": false,
+   "audience_age_rating": 10,
+   "regional_focus": "global",
+   "country_focus": "us",
+   "ideological_alignment": "apolitical",
+   "entity_type": "event",
+   "entity_name": "Canelo Álvarez vs. Terence Crawford",
+   "duplication": false
+}"""
+
+        # Nono exemplo - MORTE DE CELEBRIDADE (DUPLICAÇÃO)
+        EXAMPLE_INPUT_9 = f"""Title: Loni Anderson, Emmy- and Golden Globe-Nominated Star of 'Wkrp in Cincinnati,' Dies at 79
+Content: Loni Anderson, whose beloved role as Jennifer Marlowe on "WKRP in Cincinnati" was nominated for Emmy and Golden Globe awards, has died, her publicist confirmed Sunday. She was 79.
+Last titles:
+- Wild Bill Wichrowski do 'Deadliest Catch' ficará de fora da 21ª temporada após batalha contra o câncer de próstata
+- Loni Anderson, estrela de 'WKRP in Cincinnati', morre aos 79 anos
+- O filme "esquecido" do universo "Invocação do Mal": entenda por que "A Maldição da Chorona" é considerado o pior da franquia
+- Rose Byrne em colapso: novo filme da A24 é descrito como 'teste de resistência'
+- Jornada nas Estrelas: como entender a linha do tempo de uma das maiores sagas da ficção
+- Crise na Mubi: cineastas de peso, incluindo israelenses, exigem boicote por laços com investidor militar
+- Liam Neeson e Joe Keery enfrentam terror biológico no trailer de Cold Storage
+- TIFF 2025: de John Candy a Lucrecia Martel, conheça os documentários do ano"""
+
+        EXAMPLE_OUTPUT_9 = """{
+   "death_related": true,
+   "political_related": false,
+   "woke_related": false,
+   "spoilers": false,
+   "sensitive_theme": false,
+   "contains_video": false,
+   "is_news_content": true,
+   "relevance": "medium",
+   "brazil_interest": false,
+   "breaking_news": true,
+   "audience_age_rating": 10,
+   "regional_focus": "global",
+   "country_focus": "us",
+   "ideological_alignment": "apolitical",
+   "entity_type": "person",
+   "entity_name": "Loni Anderson",
+   "duplication": true
+}"""
+
+        # Décimo exemplo - FILME DE FESTIVAL (BAIXA RELEVÂNCIA)
+        EXAMPLE_INPUT_10 = f"""Title: Jim Jarmusch's 'Father Mother Sister Brother' Sells to Multiple Territories Ahead of Venice Premiere
+Content: Jim Jarmusch's "Father Mother Sister Brother" has sold to multiple territories ahead of its world premiere in competition at the Venice Film Festival. The film stars Tom Waits, Adam Driver, Mayim Bialik, Charlotte Rampling, Cate Blanchett, Vicky Krieps, Sarah Greene, Indya Moore, Luka Sabbat and Françoise Lebrun. Distribution rights have been picked up in Italy (Lucky Red), Spain (Avalon Distribucion Audiovisual), Portugal (Nos Lusomundo), Greece (Cinobo), Poland (Gutek Film), Hungary (Cirko Films), Romania (Bad Unicorn), Former Yugoslavia (MCF MegaCom Film), Czech Republic and Slovakia (Aerofilms), Middle East and North Africa (Front Row Filmed Ent.), South Korea (Andamiro Films), and Hong Kong (Edko Films).
+Last titles:
+- Wild Bill Wichrowski do 'Deadliest Catch' ficará de fora da 21ª temporada após batalha contra o câncer de próstata
+- Loni Anderson, estrela de 'WKRP in Cincinnati', morre aos 79 anos
+- O filme "esquecido" do universo "Invocação do Mal": entenda por que "A Maldição da Chorona" é considerado o pior da franquia
+- Rose Byrne em colapso: novo filme da A24 é descrito como 'teste de resistência'
+- Jornada nas Estrelas: como entender a linha do tempo de uma das maiores sagas da ficção
+- Crise na Mubi: cineastas de peso, incluindo israelenses, exigem boicote por laços com investidor militar
+- Universo 'Stranger Things' se expande: série animada e peça de teatro são confirmadas
+- Wandinha: O que já sabemos sobre a 2ª temporada e os boatos que circulam na internet
+- Novo filme de Park Chan-wook, 'No Other Choice', escala festivais e une estrelas
+- Homem-Aranha 4: Tom Holland revela novo traje e produção de 'Um Novo Dia' começa com participações surpreendentes
+- Quarteto Fantástico segue no topo das bilheterias, mas queda preocupa
+- Novo filme de Jim Jarmusch com Adam Driver e Cate Blanchett será distribuído pela MUBI
+- Tulsa King: 3ª temporada com Sylvester Stallone ganha data de estreia e primeiras imagens"""
+
+        EXAMPLE_OUTPUT_10 = """{
+   "death_related": false,
+   "political_related": false,
+   "woke_related": false,
+   "spoilers": false,
+   "sensitive_theme": false,
+   "contains_video": false,
+   "is_news_content": true,
+   "relevance": "low",
+   "brazil_interest": false,
+   "breaking_news": false,
+   "audience_age_rating": 10,
+   "regional_focus": "global",
+   "country_focus": "us",
+   "ideological_alignment": "apolitical",
+   "entity_type": "movie",
+   "entity_name": "Father Mother Sister Brother",
+   "duplication": true
+}"""
+
+        EXAMPLE_INPUT_11 = f"""Title: ‘AGT’: Husband & Wife Comedians Audition Against Each Other — Did Either Make the Live Shows?
+Content: Press The Golden Buzzer! For exclusive news and updates, subscribe to our America's Got Talent Newsletter:\n\nAmerica’s Got Talent has seen several couples audition together over the years, but it’s rare to see a husband and wife competing against one another. But that’s exactly what happened on Tuesday’s (August 5) episode.\n\nComedian Matt O’Brien and his wife, Julia Hladkowicz, also a comic, both auditioned for the NBC competition series separately. O’Brien was up first, winning the judges over with his jokes about being married versus being single.\n\n“You are really, really good,” Howie Mandel told the Canadian comic. “You deserve to be here. You’re the kind of comedian that could go really far in this, so I want to be the first one to give you a yes.”
+Last titles:
+- Wild Bill Wichrowski do 'Deadliest Catch' ficará de fora da 21ª temporada após batalha contra o câncer de próstata
+- Loni Anderson, estrela de 'WKRP in Cincinnati', morre aos 79 anos
+- O filme \"esquecido\" do universo \"Invocação do Mal\": entenda por que \"A Maldição da Chorona\" é considerado o pior da franquia
+- Rose Byrne em colapso: novo filme da A24 é descrito como 'teste de resistência'
+- Jornada nas Estrelas: como entender a linha do tempo de uma das maiores sagas da ficção
+- Crise na Mubi: cineastas de peso, incluindo israelenses, exigem boicote por laços com investidor militar
+- Universo 'Stranger Things' se expande: série animada e peça de teatro são confirmadas
+- Wandinha: O que já sabemos sobre a 2ª temporada e os boatos que circulam na internet
+- Novo filme de Park Chan-wook, 'No Other Choice', escala festivais e une estrelas
+- Homem-Aranha 4: Tom Holland revela novo traje e produção de 'Um Novo Dia' começa com participações surpreendentes
+- Quarteto Fantástico segue no topo das bilheterias, mas queda preocupa"""
+
+        EXAMPLE_OUTPUT_11 = """{
+   "death_related": false,
+   "political_related": false,
+   "woke_related": false,
+   "spoilers": true,
+   "sensitive_theme": false,
+   "contains_video": false,
+   "is_news_content": true,
+   "relevance": "medium",
+   "brazil_interest": false,
+   "breaking_news": false,
+   "audience_age_rating": 10,
+   "regional_focus": "global",
+   "country_focus": "us",
+   "ideological_alignment": "apolitical",
+   "entity_type": "series",
+   "entity_name": "America's Got Talent",
+   "duplication": false
+}"""
+
+        EXAMPLE_INPUT_12 = f"""Title: Savannah Guthrie Has Emotional Reunion With Kids Amid ’Today’ Absence
+Content: Savannah Guthrie returned to Today‘s Studio 1A on Wednesday, August 6, but not before picking up her kids from summer camp.\n\nThe news anchor enjoyed the end of her two-day Today absence by reuniting with her 10-year-old daughter, Vale, and 8-year-old son, Charley. Guthrie shared several photos from the camp pick-up via her Instagram Story on Tuesday, August 5, including individual snaps of herself hugging each of her children and a group selfie the three of them took together.\n\nShe also poked fun at her children by criticizing their hygiene habits. “There is no greater act of motherly love than touching the post-camp retainer 🤢,” she hilariously wrote over a snap of one of the kids’
+Last titles:
+- Wild Bill Wichrowski do 'Deadliest Catch' ficará de fora da 21ª temporada após batalha contra o câncer de próstata
+- Loni Anderson, estrela de 'WKRP in Cincinnati', morre aos 79 anos
+- O filme \"esquecido\" do universo \"Invocação do Mal\": entenda por que \"A Maldição da Chorona\" é considerado o pior da franquia
+- Rose Byrne em colapso: novo filme da A24 é descrito como 'teste de resistência'
+- Jornada nas Estrelas: como entender a linha do tempo de uma das maiores sagas da ficção
+- Crise na Mubi: cineastas de peso, incluindo israelenses, exigem boicote por laços com investidor militar
+- Universo 'Stranger Things' se expande: série animada e peça de teatro são confirmadas
+- Wandinha: O que já sabemos sobre a 2ª temporada e os boatos que circulam na internet
+- Novo filme de Park Chan-wook, 'No Other Choice', escala festivais e une estrelas
+- Homem-Aranha 4: Tom Holland revela novo traje e produção de 'Um Novo Dia' começa com participações surpreendentes
+- Quarteto Fantástico segue no topo das bilheterias, mas queda preocupa
+- Novo filme de Jim Jarmusch com Adam Driver e Cate Blanchett será distribuído pela MUBI
+- Tulsa King: 3ª temporada com Sylvester Stallone ganha data de estreia e primeiras imagens"""
+
+        EXAMPLE_OUTPUT_12 = """{
+    "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": false,
+    "breaking_news": false,
+    "audience_age_rating": 10,
+    "regional_focus": "americas",
+    "country_focus": "us",
+    "ideological_alignment": "apolitical",
+    "entity_type": "person",
+    "entity_name": "Savannah Guthrie",
+    "duplication": false
+}"""
+
+        # Estrutura de conversação correta com múltiplos exemplos
+        contents = [
+            # Primeiro exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_1)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_1)
+                ]
+            ),
+            # Segundo exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_2)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_2)
+                ]
+            ),
+            # Terceiro exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_3)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_3)
+                ]
+            ),
+            # Quarto exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_4)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_4)
+                ]
+            ),
+            # Quinto exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_5)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_5)
+                ]
+            ),
+            # Sexto exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_6)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_6)
+                ]
+            ),
+            # Sétimo exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_7)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_7)
+                ]
+            ),
+            # Oitavo exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_8)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_8)
+                ]
+            ),
+            # Nono exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_9)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_9)
+                ]
+            ),
+            # Décimo exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_10)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_10)
+                ]
+            ),
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_11)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_11)
+                ]
+            ),
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_12)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_12)
+                ]
+            ),
+            # 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,701 @@
+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, Union
+
+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 parse_image_urls(image_url_param: Union[str, List[str]]) -> List[str]:
+    """Converte o parâmetro de URL(s) em lista de URLs"""
+    if isinstance(image_url_param, list):
+        return image_url_param
+    elif isinstance(image_url_param, str):
+        # Se contém vírgulas, divide em múltiplas URLs
+        if ',' in image_url_param:
+            return [url.strip() for url in image_url_param.split(',') if url.strip()]
+        else:
+            return [image_url_param]
+    return []
+
+def create_collage_background(image_urls: List[str], canvas_width: int, canvas_height: int) -> Image.Image:
+    """Cria uma colagem como fundo baseada na lista de URLs para Instagram"""
+    num_images = len(image_urls)
+    border_size = 4 if num_images > 1 else 0  # Linha mais fina e elegante
+
+    images = [download_image_from_url(url) for url in image_urls]
+    canvas = Image.new("RGBA", (canvas_width, canvas_height), (255, 255, 255, 255))
+
+    if num_images == 1:
+        img = resize_and_crop_to_fill(images[0], canvas_width, canvas_height)
+        canvas.paste(img, (0, 0))
+
+    elif num_images == 2:
+        # Lado a lado
+        slot_width = (canvas_width - border_size) // 2
+        img1 = resize_and_crop_to_fill(images[0], slot_width, canvas_height)
+        img2 = resize_and_crop_to_fill(images[1], slot_width, canvas_height)
+        canvas.paste(img1, (0, 0))
+        canvas.paste(img2, (slot_width + border_size, 0))
+
+    elif num_images == 3:
+        # Layout: 2 em cima, 1 embaixo
+        half_height = (canvas_height - border_size) // 2
+        half_width = (canvas_width - border_size) // 2
+        img1 = resize_and_crop_to_fill(images[0], half_width, half_height)
+        img2 = resize_and_crop_to_fill(images[1], half_width, half_height)
+        img3 = resize_and_crop_to_fill(images[2], canvas_width, half_height)
+        canvas.paste(img1, (0, 0))
+        canvas.paste(img2, (half_width + border_size, 0))
+        canvas.paste(img3, (0, half_height + border_size))
+
+    elif num_images == 4:
+        # Layout 2x2
+        half_height = (canvas_height - border_size) // 2
+        half_width = (canvas_width - border_size) // 2
+        img1 = resize_and_crop_to_fill(images[0], half_width, half_height)
+        img2 = resize_and_crop_to_fill(images[1], half_width, half_height)
+        img3 = resize_and_crop_to_fill(images[2], half_width, half_height)
+        img4 = resize_and_crop_to_fill(images[3], half_width, half_height)
+        canvas.paste(img1, (0, 0))
+        canvas.paste(img2, (half_width + border_size, 0))
+        canvas.paste(img3, (0, half_height + border_size))
+        canvas.paste(img4, (half_width + border_size, half_height + border_size))
+
+    elif num_images == 5:
+        # Layout: 2 em cima, 3 embaixo
+        top_height = (canvas_height - border_size) * 2 // 5
+        bottom_height = canvas_height - top_height - border_size
+        half_width = (canvas_width - border_size) // 2
+
+        img1 = resize_and_crop_to_fill(images[0], half_width, top_height)
+        img2 = resize_and_crop_to_fill(images[1], half_width, top_height)
+        canvas.paste(img1, (0, 0))
+        canvas.paste(img2, (half_width + border_size, 0))
+
+        y_offset = top_height + border_size
+        third_width = (canvas_width - 2 * border_size) // 3
+        third_width_last = canvas_width - (third_width * 2 + border_size * 2)
+        
+        img3 = resize_and_crop_to_fill(images[2], third_width, bottom_height)
+        img4 = resize_and_crop_to_fill(images[3], third_width, bottom_height)
+        img5 = resize_and_crop_to_fill(images[4], third_width_last, bottom_height)
+        canvas.paste(img3, (0, y_offset))
+        canvas.paste(img4, (third_width + border_size, y_offset))
+        canvas.paste(img5, (third_width * 2 + border_size * 2, y_offset))
+
+    elif num_images == 6:
+        # Layout 3x2
+        half_height = (canvas_height - border_size) // 2
+        third_width = (canvas_width - 2 * border_size) // 3
+        third_width_last = canvas_width - (third_width * 2 + border_size * 2)
+
+        # Primeira linha
+        img1 = resize_and_crop_to_fill(images[0], third_width, half_height)
+        img2 = resize_and_crop_to_fill(images[1], third_width, half_height)
+        img3 = resize_and_crop_to_fill(images[2], third_width, half_height)
+        canvas.paste(img1, (0, 0))
+        canvas.paste(img2, (third_width + border_size, 0))
+        canvas.paste(img3, (third_width * 2 + border_size * 2, 0))
+
+        # Segunda linha
+        y_offset = half_height + border_size
+        img4 = resize_and_crop_to_fill(images[3], third_width, half_height)
+        img5 = resize_and_crop_to_fill(images[4], third_width, half_height)
+        img6 = resize_and_crop_to_fill(images[5], third_width_last, half_height)
+        canvas.paste(img4, (0, y_offset))
+        canvas.paste(img5, (third_width + border_size, y_offset))
+        canvas.paste(img6, (third_width * 2 + border_size * 2, y_offset))
+
+    else:
+        raise HTTPException(status_code=400, detail="Apenas até 6 imagens são suportadas.")
+
+    return canvas
+
+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[Union[str, List[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))
+
+    # Processar imagem(s) - suporte para colagem
+    if image_url:
+        parsed_urls = parse_image_urls(image_url)
+        if parsed_urls:
+            if len(parsed_urls) > 6:
+                raise HTTPException(status_code=400, detail="Máximo de 6 imagens permitidas")
+            
+            if len(parsed_urls) == 1:
+                # Uma única imagem - comportamento original
+                img = download_image_from_url(parsed_urls[0])
+                filled_img = resize_and_crop_to_fill(img, width, height)
+                canvas.paste(filled_img, (0, 0))
+            else:
+                # Múltiplas imagens - criar colagem
+                canvas = create_collage_background(parsed_urls, width, height)
+
+    # 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[Union[str, List[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))
+
+    # Processar imagem(s) - suporte para colagem
+    if image_url:
+        parsed_urls = parse_image_urls(image_url)
+        if parsed_urls:
+            if len(parsed_urls) > 6:
+                raise HTTPException(status_code=400, detail="Máximo de 6 imagens permitidas")
+            
+            if len(parsed_urls) == 1:
+                # Uma única imagem - comportamento original
+                img = download_image_from_url(parsed_urls[0])
+                filled_img = resize_and_crop_to_fill(img, width, height)
+                canvas.paste(filled_img, (0, 0))
+            else:
+                # Múltiplas imagens - criar colagem
+                canvas = create_collage_background(parsed_urls, width, height)
+
+    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[Union[str, List[str]]] = Query(None, description="URL da imagem ou lista de URLs separadas por vírgula para colagem (máximo 6)"),
+    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[Union[str, List[str]]] = Query(None, description="URL da imagem ou lista de URLs separadas por vírgula para colagem (máximo 6)"),
+    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,593 @@
+import os
+import logging
+import json
+import requests
+import importlib.util
+from pathlib import Path
+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
+import asyncio
+from typing import Optional, Dict, Any
+
+# Configurar logging
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class NewsRequest(BaseModel):
+    content: str
+    file_id: str = None  # Agora opcional
+
+class NewsResponse(BaseModel):
+    title: str
+    subhead: str
+    content: str
+    sources_info: Optional[Dict[str, Any]] = None  # Informações das fontes geradas
+
+# Referência ao diretório de arquivos temporários
+TEMP_DIR = Path("/tmp")
+
+def load_searchterm_module():
+    """Carrega o módulo searchterm.py dinamicamente"""
+    try:
+        # Procura o arquivo searchterm.py em diferentes locais
+        searchterm_path = Path(__file__).parent / "searchterm.py"
+        
+        if not searchterm_path.exists():
+            # Tenta outros caminhos possíveis
+            possible_paths = [
+                Path(__file__).parent.parent / "searchterm.py",
+                Path("./searchterm.py"),
+                Path("../searchterm.py")
+            ]
+            
+            for path in possible_paths:
+                if path.exists():
+                    searchterm_path = path
+                    break
+            else:
+                logger.error("searchterm.py não encontrado em nenhum dos caminhos")
+                return None
+        
+        spec = importlib.util.spec_from_file_location("searchterm", searchterm_path)
+        searchterm_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(searchterm_module)
+        
+        logger.info(f"Módulo searchterm.py carregado com sucesso: {searchterm_path}")
+        return searchterm_module
+    except Exception as e:
+        logger.error(f"Erro ao carregar searchterm.py: {str(e)}")
+        return None
+
+# Carrega o módulo na inicialização
+searchterm_module = load_searchterm_module()
+
+async def generate_sources_from_content(content: str) -> Optional[str]:
+    """
+    Gera fontes usando o módulo searchterm baseado no conteúdo da notícia
+    """
+    try:
+        if not searchterm_module:
+            logger.error("Módulo searchterm não carregado")
+            return None
+        
+        logger.info(f"Gerando fontes para conteúdo: {len(content)} caracteres")
+        
+        # Prepara o payload para o searchterm
+        payload = {"context": content}
+        
+        # Chama a função search_terms do módulo searchterm
+        # Simula uma requisição FastAPI criando um objeto com o método necessário
+        result = await searchterm_module.search_terms(payload)
+        
+        if result and "file_info" in result:
+            file_id = result["file_info"]["file_id"]
+            logger.info(f"Fontes geradas com sucesso. File ID: {file_id}")
+            logger.info(f"Total de resultados: {result.get('total_results', 0)}")
+            logger.info(f"Termos gerados: {len(result.get('generated_terms', []))}")
+            
+            return file_id
+        else:
+            logger.error("Resultado inválido do searchterm")
+            return None
+            
+    except Exception as e:
+        logger.error(f"Erro ao gerar fontes: {str(e)}")
+        return None
+
+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',
+            'pt_BR.utf8',
+            'pt_BR',
+            'Portuguese_Brazil.1252',
+            'Portuguese_Brazil',
+            'pt_BR.ISO8859-1',
+        ]
+        
+        locale_set = False
+        for loc in locale_variants:
+            try:
+                locale.setlocale(locale.LC_TIME, loc)
+                locale_set = True
+                break
+            except locale.Error:
+                continue
+        
+        if not locale_set:
+            locale.setlocale(locale.LC_TIME, '')
+        
+        now = datetime.now(ZoneInfo("America/Sao_Paulo"))
+        
+        # Dicionários para tradução manual (fallback)
+        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:
+            if locale_set:
+                try:
+                    date_string = now.strftime("%-d de %B de %Y (%A)")
+                except ValueError:
+                    try:
+                        date_string = now.strftime("%#d de %B de %Y (%A)")
+                    except ValueError:
+                        date_string = now.strftime("%d de %B de %Y (%A)")
+                        if date_string.startswith('0'):
+                            date_string = date_string[1:]
+                
+                date_string = date_string.replace(date_string.split('(')[1].split(')')[0], 
+                                                date_string.split('(')[1].split(')')[0].lower())
+            else:
+                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:
+            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})"
+        
+        return date_string
+        
+    except Exception:
+        now = datetime.now(ZoneInfo("America/Sao_Paulo"))
+        date_string = now.strftime("%d de %B de %Y")
+        return date_string
+
+def load_sources_file(file_id: str) -> str:
+    """
+    Carrega o arquivo de fontes pelo ID do arquivo temporário.
+    """
+    try:
+        # Constrói o caminho do arquivo
+        file_path = TEMP_DIR / f"fontes_{file_id}.txt"
+        
+        # Verifica se o arquivo existe
+        if not file_path.exists():
+            raise HTTPException(
+                status_code=404, 
+                detail=f"Arquivo temporário não encontrado ou expirado: {file_id}"
+            )
+        
+        # Lê o conteúdo do arquivo
+        with open(file_path, 'r', encoding='utf-8') as f:
+            file_content = f.read()
+        
+        # Se for um JSON, extrai os dados; caso contrário, retorna o conteúdo direto
+        try:
+            data = json.loads(file_content)
+            # Se contém 'results', formata os dados para o Gemini
+            if 'results' in data and isinstance(data['results'], list):
+                formatted_content = ""
+                for idx, result in enumerate(data['results'], 1):
+                    formatted_content += f"\n--- FONTE {idx} ---\n"
+                    formatted_content += f"Termo: {result.get('term', 'N/A')}\n"
+                    formatted_content += f"URL: {result.get('url', 'N/A')}\n"
+                    formatted_content += f"Idade: {result.get('age', 'N/A')}\n"
+                    formatted_content += f"Conteúdo:\n{result.get('text', 'N/A')}\n"
+                    formatted_content += "-" * 50 + "\n"
+                return formatted_content
+            else:
+                return file_content
+        except json.JSONDecodeError:
+            # Se não for JSON válido, retorna o conteúdo como texto
+            return file_content
+        
+    except FileNotFoundError:
+        raise HTTPException(
+            status_code=404, 
+            detail=f"Arquivo temporário não encontrado: {file_id}"
+        )
+    except PermissionError:
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Erro de permissão ao acessar arquivo: {file_id}"
+        )
+    except Exception as e:
+        logger.error(f"Erro ao carregar arquivo de fontes {file_id}: {e}")
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Erro ao carregar arquivo de fontes: {str(e)}"
+        )
+
+def extract_text_from_response(response):
+    """
+    Extrai o texto da resposta de forma robusta com debug.
+    """
+    logger.info(f"Tipo da resposta: {type(response)}")
+    
+    # Método 1: Tentar acessar response.text diretamente
+    try:
+        text_content = getattr(response, 'text', None)
+        if text_content:
+            logger.info(f"Texto extraído via response.text: {len(text_content)} caracteres")
+            return text_content
+        else:
+            logger.info("response.text existe mas está vazio/None")
+    except Exception as e:
+        logger.error(f"Erro ao acessar response.text: {e}")
+    
+    # Método 2: Verificar candidates
+    if hasattr(response, 'candidates') and response.candidates:
+        logger.info(f"Encontrados {len(response.candidates)} candidates")
+        
+        for i, candidate in enumerate(response.candidates):
+            logger.info(f"Processando candidate {i}")
+            
+            # Verificar se tem content
+            if hasattr(candidate, 'content') and candidate.content:
+                content = candidate.content
+                logger.info(f"Candidate {i} tem content")
+                
+                # Verificar se tem parts
+                if hasattr(content, 'parts') and content.parts:
+                    try:
+                        parts_list = list(content.parts)
+                        logger.info(f"Content tem {len(parts_list)} parts")
+                        
+                        response_text = ""
+                        for j, part in enumerate(parts_list):
+                            logger.info(f"Processando part {j}, tipo: {type(part)}")
+                            
+                            # Tentar várias formas de acessar o texto
+                            part_text = None
+                            if hasattr(part, 'text'):
+                                part_text = getattr(part, 'text', None)
+                            
+                            if part_text:
+                                logger.info(f"Part {j} tem texto: {len(part_text)} caracteres")
+                                response_text += part_text
+                            else:
+                                logger.info(f"Part {j} não tem texto ou está vazio")
+                        
+                        if response_text:
+                            return response_text
+                    except Exception as e:
+                        logger.error(f"Erro ao processar parts do candidate {i}: {e}")
+    
+    return ""
+
+@router.post("/rewrite-news", response_model=NewsResponse)
+async def rewrite_news(news: NewsRequest):
+    """
+    Endpoint para reescrever notícias usando o modelo Gemini.
+    Se file_id não for fornecido, gera automaticamente as fontes usando o conteúdo.
+    """
+    try:
+        # Verificar API key
+        api_key = os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            raise HTTPException(status_code=500, detail="API key não configurada")
+        
+        sources_info = None
+        
+        # Se file_id não foi fornecido, gera fontes automaticamente
+        if not news.file_id:
+            logger.info("File ID não fornecido, gerando fontes automaticamente...")
+            generated_file_id = await generate_sources_from_content(news.content)
+            
+            if generated_file_id:
+                news.file_id = generated_file_id
+                sources_info = {
+                    "generated": True,
+                    "file_id": generated_file_id,
+                    "message": "Fontes geradas automaticamente a partir do conteúdo"
+                }
+                logger.info(f"Fontes geradas automaticamente. File ID: {generated_file_id}")
+            else:
+                logger.warning("Não foi possível gerar fontes automaticamente, prosseguindo sem fontes")
+                sources_info = {
+                    "generated": False,
+                    "message": "Não foi possível gerar fontes automaticamente"
+                }
+        else:
+            sources_info = {
+                "generated": False,
+                "file_id": news.file_id,
+                "message": "Usando file_id fornecido"
+            }
+        
+        # Carregar arquivo de fontes se disponível
+        sources_content = ""
+        if news.file_id:
+            try:
+                sources_content = load_sources_file(news.file_id)
+                logger.info(f"Fontes carregadas: {len(sources_content)} caracteres")
+            except HTTPException as e:
+                logger.warning(f"Erro ao carregar fontes: {e.detail}")
+                sources_content = ""
+        
+        client = genai.Client(api_key=api_key)
+        model = "gemini-2.5-pro"
+        
+        # Obter data formatada
+        date_string = get_brazilian_date_string()
+        
+        # Instruções do sistema (suas instruções originais aqui)
+        # Instruções do sistema
+        SYSTEM_INSTRUCTIONS = f"""
+Você é um jornalista brasileiro, escrevendo para portais digitais. Sua missão é transformar notícias internacionais em matérias originais, detalhadas e atualizadas para o público brasileiro. Sempre use a notícia-base como ponto de partida, mas consulte o arquivo fontes.txt para extrair todas as informações relevantes, complementando fatos, contexto, dados e antecedentes. Não invente informações; na dúvida, não insira.
+Seu estilo de escrita deve ser direto, claro e conversacional, sem jargões ou floreios desnecessários. Frases curtas e bem estruturadas, parágrafos segmentados para leitura digital e SEO. Evite repetições, clichês e generalizações.
+Evite frases redundantes ou genéricas como:
+- "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"
+- "A mudança visa estabelecer"
+- "Além disso, a consolidação em X trará Y"
+
+O conteúdo deve priorizar clareza, contexto e completude:
+- Comece com a informação mais relevante e específica.
+- Contextualize causas, consequências e conexões com outros acontecimentos.
+- Inclua dados, datas, lançamentos e fontes confiáveis.
+- Use citações, títulos de obras e nomes próprios quando pertinentes.
+- Finalize sempre com fatos concretos, nunca com opinião genérica.
+
+Nunca utilize as palavras "icônico" ou "icônicos" ao se referir a pessoas, acontecimentos ou objetos neste contexto. O jornal em questão é um veículo de direita, com um público majoritariamente conservador, e esse termo pode soar inadequado ou destoar do tom editorial esperado.
+Em vez disso, prefira sempre sinônimos como "lendário", "lendários", "memorável", "histórico" ou outros termos que transmitam grandeza e relevância, mas mantendo a coerência com a linha editorial conservadora.
+
+Formato da matéria:
+<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, etc. Também inclua a tag [wiki] para termos que estão presentes na wikipédia. Bote wiki apenas em nomes completos, nomes de filmes, etc... Nunca em apelidos, primeiro nome e tudo mais.
+Padrão de títulos: apenas a primeira palavra em maiúscula (exceto nomes próprios ou títulos de obras).
+O resultado deve soar como uma reportagem profissional, completa, confiável e envolvente, no estilo da Fox News: informativa, detalhada, mantendo linguagem humana e acessível. Sempre busque complementar a notícia com informações adicionais e contextos do arquivo fontes.txt, evitando opiniões pessoais. Mantenha tom informativo e predominantemente conservador (o jornal tem um público maior da ala da Direita/Republicana, sem juízos de valor ou opiniões pessoais. Não use linguagem woke, de vitimização ou que force interpretações ideológicas.
+A data de hoje é {date_string}.
+
+"""
+
+        # Exemplos
+        EXAMPLE_INPUT_1 = """
+Observação: O Jornal mantém um público majoritário de maioria Republicana americana/Direita brasileira, então é um jornal conservador. Escreva a notícia ciente disso. 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>[wiki]<strong>Ed Helms</strong>[/wiki] nunca escondeu o fato de que sua participação em [wiki]<strong>Se Beber, Não Case!</strong>[/wiki] foi um choque cultural, especialmente para seus pais. Em uma entrevista recente ao podcast de [wiki]<strong>Ted Danson</strong>[/wiki], <em>[wiki]Where Everybody Knows Your Name[/wiki]</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>[wiki]The Daily Show[/wiki]</em> e <em>[wiki]The Office[/wiki]</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>[wiki]<strong>Se Beber, Não Case!</strong>[/wiki], dirigido por <strong>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>, [wiki]<strong>Bradley Cooper</strong>[/wiki] e [wiki]<strong>Zach Galifianakis</strong>[/wiki] como um dos times cômicos mais icônicos do cinema moderno.</p>
+<p>Sobre a possibilidade de um quarto filme, [wiki]<strong>Bradley Cooper</strong>[/wiki] 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>[wiki]Coringa[/wiki]</em>.</p>
+</body>
+"""
+        EXAMPLE_INPUT_2 = """
+Observação: O Jornal mantém um público majoritário de maioria Republicana americana/Direita brasileira, então é um jornal conservador. Escreva a notícia ciente disso. 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 [wiki]<em>"The Office"</em>[/wiki]. 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 é [wiki]<em>"The Paper"</em>[/wiki] e estará disponível na plataforma de streaming [wiki]<strong>Peacock</strong>[/wiki].</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 [wiki]<strong>Michael Scott</strong>[/wiki] e [wiki]<strong>Dwight Schrute</strong>[/wiki]. Agora, a equipe acompanha o <strong>Toledo Truth Teller</strong>, um jornal em [wiki]<strong>Toledo, Ohio</strong>[/wiki], e o editor que tenta reviver o jornal com a ajuda de repórteres voluntários.</p>
+<p>O novo elenco conta com [wiki]<strong>Domhnall Gleeson</strong>[/wiki], ator irlandês famoso por [wiki]<em>"Ex Machina"</em>[/wiki] e [wiki]<em>"Questão de Tempo"</em>[/wiki], ao lado da atriz italiana [wiki]<strong>Sabrina Impacciatore</strong>[/wiki], que ganhou amplo reconhecimento por seu papel na segunda temporada de [wiki]<em>"The White Lotus"</em>[/wiki]. 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 [wiki]<strong>Dunder Mifflin</strong>[/wiki]. <em>"Acho que se você tentar competir com o que [wiki]Steve Carell[/wiki] ou [wiki]Ricky Gervais[/wiki] 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 [wiki]<strong>John Krasinski</strong>[/wiki] e até de [wiki]<strong>Steve Carell</strong>[/wiki] para aceitar o papel, especialmente porque se tratava de um projeto de [wiki]<strong>Greg Daniels</strong>[/wiki].</p>
+<p>Como [wiki]<em>"The Paper"</em>[/wiki] está reintroduzindo os personagens originais, os fãs de longa data da série parecem estar encantados, já que também traz [wiki]<strong>Oscar Nuñez</strong>[/wiki] reprisando seu papel como o contador <strong>Oscar Martinez</strong>. Oscar, que estava iniciando uma carreira política em [wiki]<em>"The Office"</em>[/wiki], agora parece ter se mudado para <strong>Toledo</strong>. <em>"Eu disse ao Sr. [wiki]<strong>Greg Daniels</strong>[/wiki] que, se Oscar voltasse, ele provavelmente estaria morando em uma cidade mais agitada e cosmopolita. Greg me ouviu e mudou Oscar para [wiki]<strong>Toledo, Ohio</strong>[/wiki], que tem três vezes a população de Scranton. Então, foi bom ser ouvido"</em>, brincou Nuñez durante um evento da [wiki]<strong>NBCUniversal</strong>[/wiki].</p>
+<p>[wiki]<strong>Greg Daniels</strong>[/wiki], que anteriormente adaptou [wiki]<em>"The Office"</em>[/wiki] para o público americano, está em parceria com [wiki]<strong>Michael Koman</strong>[/wiki], cocriador de [wiki]<em>"Nathan for You"</em>[/wiki], para este novo projeto. Koman e Daniels, junto com [wiki]<strong>Ricky Gervais</strong>[/wiki] e [wiki]<strong>Stephen Merchant</strong>[/wiki], criadores da série britânica original, formam a equipe de produção executiva.</p>
+<p>A primeira temporada de [wiki]<em>"The Paper"</em>[/wiki] 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 [wiki]<strong>Universal+</strong>[/wiki], serviço de streaming que costuma exibir produções do catálogo da [wiki]<strong>Peacock</strong>[/wiki].</p>
+</body>
+"""
+
+        EXAMPLE_INPUT_3 = """
+Observação: O Jornal mantém um público majoritário de maioria Republicana americana/Direita brasileira, então é um jornal conservador. Escreva a notícia ciente disso. News base: Noah Centineo Attached to Play Rambo in Prequel Movie 'John Rambo'
+"""
+
+        EXAMPLE_OUTPUT_3 = """<headline>Noah Centineo é o novo Rambo em filme que contará a origem do personagem</headline>
+<subhead>Ator de 'Para Todos os Garotos que Já Amei' assume o papel de Sylvester Stallone em prelúdio que se passará na Guerra do Vietnã</subhead>
+<body>
+<p>De acordo com a [wiki]<strong>Millennium Media</strong>[/wiki], [wiki]<strong>Noah Centineo</strong>[/wiki] foi escolhido para interpretar uma versão mais jovem de John Rambo no filme que contará os primórdios do lendário personagem. A produção, que é simplesmente chamada [wiki]<em>John Rambo</em>[/wiki], tenta examinar os primeiros anos do soldado antes dos eventos de [wiki]<em>First Blood</em>[/wiki] (1982).</p>
+<p>[wiki]<strong>Jalmari Helander</strong>[/wiki], diretor finlandês mais conhecido pelo blockbuster de ação [wiki]<em>Sisu</em>[/wiki], comandará o filme. [wiki]<strong>Rory Haines</strong>[/wiki] e [wiki]<strong>Sohrab Noshirvani</strong>[/wiki], que trabalharam juntos em [wiki]<em>Black Adam</em>[/wiki], estão cuidando do roteiro. As filmagens na Tailândia estão previstas para começar no início de 2026.</p>
+<p>A história se passará durante a [wiki]Guerra do Vietnã[/wiki], embora os detalhes da trama estejam sendo mantidos em sigilo. O objetivo é retratar a metamorfose de John Rambo. Antes da guerra, ele era "o cara perfeito, o mais popular da escola, um superatleta", como [wiki]<strong>Sylvester Stallone</strong>[/wiki] afirmou em 2019. Espera-se que o filme examine os eventos horríveis que o moldaram no veterano atormentado retratado no primeiro filme.</p>
+<p>Embora não esteja diretamente envolvido no projeto, [wiki]<strong>Sylvester Stallone</strong>[/wiki], que interpretou o personagem em cinco filmes, está ciente dele. Segundo pessoas próximas à produção, ele foi informado sobre a escolha de Centineo. O ator, hoje com 79 anos, brincou em 2023 sobre a possibilidade de voltar a interpretar o papel, dizendo: "Ele já fez praticamente tudo. O que eu vou combater? Artrite?"</p>
+<p>A escolha de Centineo, de 29 anos, marca uma nova fase na carreira do ator, que conquistou fama internacional com comédias românticas da Netflix, como a trilogia [wiki]<em>Para Todos os Garotos que Já Amei</em>[/wiki]. Nos últimos anos, porém, ele vem explorando o gênero de ação, interpretando o herói [wiki]<em>Esmaga-Átomo</em>[/wiki] em [wiki]<em>Adão Negro</em>[/wiki] e estrelando a série de espionagem [wiki]<em>O Recruta</em>[/wiki]. Recentemente, Centineo também esteve no drama de guerra [wiki]<em>Warfare</em>[/wiki], da [wiki]<strong>A24</strong>[/wiki], e está escalado para viver [wiki]<strong>Ken Masters</strong>[/wiki] no próximo filme de [wiki]<em>Street Fighter</em>[/wiki].</p>
+<p>A franquia [wiki]<em>Rambo</em>[/wiki], baseada no livro [wiki]<em>First Blood</em>[/wiki], de [wiki]<strong>David Morrell</strong>[/wiki], é uma das mais conhecidas do cinema de ação. Os cinco filmes arrecadaram mais de 850 milhões de dólares em todo o mundo. Enquanto as sequências apostaram em ação em grande escala, o primeiro longa se destaca pelo tom mais solene e pela crítica ao tratamento dado aos veteranos do Vietnã.</p>
+<p>A produção do novo filme está a cargo de [wiki]<strong>Avi Lerner</strong>[/wiki], [wiki]<strong>Jonathan Yunger</strong>[/wiki], [wiki]<strong>Les Weldon</strong>[/wiki] e [wiki]<strong>Kevin King-Templeton</strong>[/wiki]. A [wiki]<strong>Lionsgate</strong>[/wiki], que distribuiu os dois últimos longas da série, é a principal candidata a adquirir os direitos de distribuição do projeto.</p>
+</body>
+"""
+        EXAMPLE_INPUT_4 = """
+Observação: O Jornal mantém um público majoritário de maioria Republicana americana/Direita brasileira, então é um jornal conservador. Escreva a notícia ciente disso. News base: Sylvester Stallone, Gloria Gaynor, Kiss Set for Kennedy Center Honors Amid Trump Overhaul
+The first honorees for the revamped Kennedy Center Honors have been unveiled by U.S. President Donald Trump, who is also the new chairman of the John F. Kennedy Center for the Performing Arts.
+This year’s honorees include Rocky star and filmmaker Sylvester Stallone; disco-era singer Gloria Gaynor; the rock band Kiss; Michael Crawford, the British star of Phantom of the Opera; and country crooner and songwriter George Strait.
+The 48th annual Kennedy Center Honors, set to air on the CBS network and stream on Paramount+, will be hosted by the U.S. President. Stallone was earlier named by Trump as one of his ambassadors to Hollywood. “He’s a very special guy. A real talent, never been given credit for the talent,” Trump added about the Hollywood actor during an hourlong press conference Wednesday
+"""
+
+        EXAMPLE_OUTPUT_4 = """<headline>Stallone, Kiss e Gloria Gaynor são os novos homenageados do Kennedy Center em premiação reformulada por Trump</headline>
+<subhead>Presidente assume o comando do Kennedy Center, anuncia os homenageados pessoalmente e prioriza foco nas artes em vez de política ideológica</subhead>
+<body>
+<p>O presidente [wiki]<strong>Donald Trump</strong>[/wiki], agora à frente do conselho do [wiki]<strong>John F. Kennedy Center for the Performing Arts</strong>[/wiki], anunciou pessoalmente os homenageados de 2025 do prestigiado prêmio cultural. Os escolhidos são o ator e cineasta [wiki]<strong>Sylvester Stallone</strong>[/wiki], a banda de rock [wiki]<strong>Kiss</strong>[/wiki], a cantora [wiki]<strong>Gloria Gaynor</strong>[/wiki], o astro da música country [wiki]<strong>George Strait</strong>[/wiki] e o ator britânico [wiki]<strong>Michael Crawford</strong>[/wiki], conhecido por seu papel em [wiki]<em>O Fantasma da Ópera</em>[/wiki].</p>
+<p>A cerimônia, que será a 48ª edição do evento, será transmitida pela CBS e pela plataforma [wiki]<strong>Paramount+</strong>[/wiki] e ocorrerá em [wiki]<strong>Washington, D.C.</strong>[/wiki], no dia 7 de dezembro. Em um evento amplamente divulgado, Trump anunciou os homenageados durante uma coletiva de imprensa na quarta-feira, contrariando o costume de divulgar os nomes por comunicado. Ele afirmou ter se envolvido “cerca de 98%” no processo de seleção e que rejeitou alguns nomes por serem “demasiado woke”.</p>
+<p>A alteração, na verdade, representa o início de uma nova fase para o [wiki]<strong>Kennedy Center</strong>[/wiki]. Depois de reassumir a presidência, Trump trocou os indicados de administrações passadas por novos integrantes comprometidos em reorientar o centro. Ele afirmou que seu objetivo é reverter o que considera ser a "programação política 'woke'" e, em tom de brincadeira, sugeriu que poderia receber uma homenagem no ano seguinte.</p>
+<p>Trump se absteve de comparecer a qualquer cerimônia no [wiki]<strong>Kennedy Center</strong>[/wiki] durante seu primeiro mandato, depois que vários artistas, incluindo o produtor [wiki]<strong>Norman Lear</strong>[/wiki], ameaçaram boicotar o evento em protesto. Agora, além de supervisionar as escolhas, será o anfitrião da gala.</p>
+<p>Os homenageados representam, em certa medida, os interesses pessoais do presidente. [wiki]<strong>Sylvester Stallone</strong>[/wiki], amigo e apoiador de longa data, o descreveu como “um segundo [wiki]George Washington[/wiki]”. Em janeiro, Trump o nomeou, juntamente com [wiki]<strong>Mel Gibson</strong>[/wiki] e [wiki]<strong>Jon Voight</strong>[/wiki], como “embaixador especial” de Hollywood. [wiki]<strong>Michael Crawford</strong>[/wiki] foi o protagonista de [wiki]<em>O Fantasma da Ópera</em>[/wiki], um dos musicais preferidos do presidente.</p>
+<p>A seleção da banda [wiki]<strong>Kiss</strong>[/wiki] traz um contexto um pouco mais complicado. Embora [wiki]<strong>Ace Frehley</strong>[/wiki], um dos membros fundadores, tenha apoiado Trump, outros integrantes, como [wiki]<strong>Paul Stanley</strong>[/wiki] e [wiki]<strong>Gene Simmons</strong>[/wiki], já expressaram críticas ao presidente em ocasiões anteriores. Simmons, ex-participante do reality show [wiki]<em>O Aprendiz</em>[/wiki], declarou em 2022 que Trump "não é republicano nem democrata. Ele está em causa própria."</p>
+<p>A nova gestão do [wiki]<strong>Kennedy Center</strong>[/wiki] já provocou respostas no cenário artístico. Os organizadores do musical [wiki]<em>Hamilton</em>[/wiki] cancelaram a apresentação da turnê nacional no local, e outros artistas, como a atriz [wiki]<strong>Issa Rae</strong>[/wiki] e a produtora [wiki]<strong>Shonda Rhimes</strong>[/wiki], também romperam relações com a instituição em protesto. Em contrapartida, o anúncio dos homenageados gerou tanto interesse que o site oficial do [wiki]<strong>Kennedy Center</strong>[/wiki] ficou temporariamente fora do ar devido ao grande volume de tráfego.</p>
+<p>Estabelecido em 1978, o [wiki]<strong>Kennedy Center Honors</strong>[/wiki] possui uma tradição bipartidária, congregando presidentes de diversos partidos para homenagear artistas notáveis de todos os gêneros e estilos.</p>
+</body>
+"""
+        config = types.GenerateContentConfig(
+            system_instruction=SYSTEM_INSTRUCTIONS,
+            thinking_config=types.ThinkingConfig(
+                thinking_budget=2500,
+            ),
+            response_mime_type="text/plain",
+            max_output_tokens=16000,
+            temperature=1,
+        )
+
+        # Conteúdo da conversa
+        contents = [
+            # Primeiro exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_1)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_1)
+                ]
+            ),
+            # Segundo exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_2)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_2)
+                ]
+            ),
+            # Terceiro exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_3)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_3)
+                ]
+            ),
+            # Quarto exemplo
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_INPUT_4)
+                ]
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text=EXAMPLE_OUTPUT_4)
+                ]
+            ),
+            # Notícia atual com arquivo de fontes
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=f"News base: {news.content}. The article is out of date, more information is needed."),
+                    types.Part.from_text(text=f"Fontes adicionais disponíveis:\n\n{sources_content}")
+                ]
+            )
+        ]
+
+        # Gerar conteúdo
+        response = client.models.generate_content(
+            model=model,
+            contents=contents,
+            config=config
+        )
+
+        # Gerar conteúdo
+        response = client.models.generate_content(
+            model=model,
+            contents=contents,
+            config=config
+        )
+
+        logger.info("Resposta do modelo recebida com sucesso")
+
+        # Extrair texto
+        response_text = extract_text_from_response(response)
+
+        logger.info(f"Texto extraído: {len(response_text) if response_text else 0} caracteres")
+        
+        # Verificar se o texto está vazio
+        if not response_text or response_text.strip() == "":
+            logger.error("Texto extraído está vazio")
+            raise HTTPException(
+                status_code=500, 
+                detail="Modelo não retornou conteúdo válido"
+            )
+
+        # Extração do título, subtítulo, conteúdo e campos do Instagram
+        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"
+        
+        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"
+        
+        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"Processamento concluído com sucesso - Título: {title[:50]}...")
+        
+        return NewsResponse(
+            title=title,
+            subhead=subhead,
+            content=content,
+            sources_info=sources_info
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Erro na reescrita: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))

routers/inference_createposter.py

@@ -0,0 +1,692 @@
+import os
+import logging
+import re
+import json
+from urllib.parse import urlencode, quote, parse_qs, urlparse, urlunparse
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from google import genai
+from google.genai import types
+
+# Configurar logging
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+class PosterRequest(BaseModel):
+    content: str
+
+class PosterResponse(BaseModel):
+    result: dict
+    urls: list
+
+def clean_json_string(json_string: str) -> str:
+    """
+    Remove caracteres de controle inválidos do JSON antes do parse.
+    """
+    if not json_string:
+        return json_string
+    
+    # Remove caracteres de controle (exceto \t, \n, \r que são válidos em JSON)
+    # mas precisamos escapar corretamente dentro das strings
+    cleaned = ""
+    i = 0
+    in_string = False
+    escape_next = False
+    
+    while i < len(json_string):
+        char = json_string[i]
+        
+        if escape_next:
+            # Se o caractere anterior foi \, adiciona este caractere escapado
+            cleaned += char
+            escape_next = False
+        elif char == '\\' and in_string:
+            # Caractere de escape dentro de string
+            cleaned += char
+            escape_next = True
+        elif char == '"' and not escape_next:
+            # Início ou fim de string (se não estiver escapado)
+            cleaned += char
+            in_string = not in_string
+        elif in_string:
+            # Dentro de string - tratar caracteres especiais
+            if ord(char) < 32 and char not in ['\t']:  # Remove controles exceto tab
+                if char == '\n':
+                    cleaned += '\\n'  # Escapa quebra de linha
+                elif char == '\r':
+                    cleaned += '\\r'  # Escapa carriage return
+                else:
+                    # Remove outros caracteres de controle
+                    pass
+            else:
+                cleaned += char
+        else:
+            # Fora de string - remove apenas caracteres de controle problemáticos
+            if ord(char) >= 32 or char in ['\t', '\n', '\r', ' ']:
+                cleaned += char
+        
+        i += 1
+    
+    return cleaned
+
+def fix_citation_quotes(citation_text: str) -> str:
+    """
+    Corrige as aspas no texto de citação:
+    - Se não tiver aspas no início e fim, adiciona " "
+    - Se tiver aspas comuns ou outras, substitui por " "
+    - Remove todas as tags HTML
+    """
+    if not citation_text or citation_text.strip() == "":
+        return citation_text
+
+    text = citation_text.strip()
+    
+    # Remover todas as tags HTML
+    text = re.sub(r'<[^>]+>', '', text)
+    
+    # Verificar se já tem as aspas corretas
+    if text.startswith('“') and text.endswith('”'):
+        return text
+    
+    # Remover aspas existentes do início e fim
+    quote_chars = ['"', "'", '"', '"', ''', ''', '❝', '❞']
+    
+    # Remover aspas do início
+    while text and text[0] in quote_chars:
+        text = text[1:]
+    
+    # Remover aspas do fim
+    while text and text[-1] in quote_chars:
+        text = text[:-1]
+    
+    # Adicionar as aspas corretas
+    return f"“{text.strip()}”"
+
+def clean_text_content_for_text_param(text: str) -> str:
+    """
+    Limpa o conteúdo do parâmetro 'text':
+    - Remove apenas tags <wiki>
+    - Mantém <strong> e <em>
+    - Se tiver tags aninhadas (ex: <strong><em>), prioriza a segunda (mais interna)
+    """
+    if not text:
+        return text
+    
+    # Primeiro, resolver conflitos de tags aninhadas - priorizar a segunda (mais interna)
+    # <strong><em>conteúdo</em></strong> -> <em>conteúdo</em>
+    text = re.sub(r'<strong>\s*<em>(.*?)</em>\s*</strong>', r'<em>\1</em>', text)
+    # <em><strong>conteúdo</strong></em> -> <strong>conteúdo</strong>
+    text = re.sub(r'<em>\s*<strong>(.*?)</strong>\s*</em>', r'<strong>\1</strong>', text)
+    
+    # Remover apenas tags <wiki>
+    text = re.sub(r'</?wiki[^>]*>', '', text)
+    
+    return text.strip()
+
+def clean_text_content_remove_all_tags(text: str) -> str:
+    """
+    Remove TODAS as tags HTML do texto (para headline, title, citation).
+    Mantém apenas o conteúdo textual limpo.
+    """
+    if not text:
+        return text
+    
+    # Remove TODAS as tags HTML usando regex mais ampla
+    text = re.sub(r'<[^>]*>', '', text)
+    
+    # Remove possíveis entidades HTML comuns
+    text = text.replace('&lt;', '<').replace('&gt;', '>').replace('&amp;', '&')
+    text = text.replace('&quot;', '"').replace('&#39;', "'")
+    
+    return text.strip()
+
+def clean_text_content(text: str) -> str:
+    """
+    Função mantida para compatibilidade com o código existente.
+    Limpa o conteúdo de texto removendo tags inválidas e corrigindo formatação:
+    - Remove todas as tags exceto <strong> e <em>
+    - Se tiver <strong><em> juntas, prioriza <em>
+    - Se tiver <em><strong> juntas, prioriza <strong>
+    """
+    return clean_text_content_for_text_param(text)
+
+def fix_url_citation(url: str) -> str:
+    """
+    Analisa uma URL e trata os parâmetros de texto de forma específica:
+    - Para 'text': mantém <strong> e <em>, remove <wiki>, resolve conflitos de tags aninhadas
+    - Para 'headline', 'title', 'citation': remove TODAS as tags HTML
+    """
+    try:
+        # Parse da URL
+        parsed_url = urlparse(url)
+        query_params = parse_qs(parsed_url.query)
+        
+        # Parâmetros que devem ter TODAS as tags removidas
+        clean_all_params = ['headline', 'title', 'citation']
+        
+        # Parâmetros que têm tratamento especial (apenas text)
+        special_text_params = ['text']
+        
+        # Processar parâmetros que devem ser completamente limpos
+        for param in clean_all_params:
+            if param in query_params and query_params[param]:
+                original_text = query_params[param][0]
+                cleaned_text = clean_text_content_remove_all_tags(original_text)
+                
+                # Se for citation, aplicar correção específica das aspas
+                if param == 'citation':
+                    cleaned_text = fix_citation_quotes(cleaned_text)
+                
+                query_params[param] = [cleaned_text]
+        
+        # Processar parâmetro 'text' com tratamento especial
+        for param in special_text_params:
+            if param in query_params and query_params[param]:
+                original_text = query_params[param][0]
+                cleaned_text = clean_text_content_for_text_param(original_text)
+                query_params[param] = [cleaned_text]
+        
+        # Reconstruir a query string
+        new_query = urlencode(
+            {k: v[0] if isinstance(v, list) and len(v) == 1 else v for k, v in query_params.items()},
+            quote_via=quote
+        )
+        
+        # Reconstruir a URL
+        new_parsed_url = parsed_url._replace(query=new_query)
+        return urlunparse(new_parsed_url)
+    
+    except Exception as e:
+        logger.warning(f"Erro ao processar URL para correção de texto: {e}")
+        return url
+
+def format_url(base_url: str, endpoint: str, params: dict) -> str:
+    """
+    Formata uma URL completa com os parâmetros dados
+    """
+    # URL base + endpoint
+    full_url = f"{base_url.rstrip('/')}{endpoint}"
+    
+    # Adicionar image_url padrão
+    url_params = {"image_url": "https://placehold.co/1080x1350.png"}
+    
+    # Adicionar outros parâmetros
+    for key, value in params.items():
+        if value is not None:
+            url_params[key] = str(value)
+    
+    # Construir query string
+    query_string = urlencode(url_params, quote_via=quote)
+    return f"{full_url}?{query_string}"
+
+def generate_urls_from_result(result: dict, base_url: str = "https://habulaj-newapi-clone2.hf.space") -> list:
+    """
+    Gera as URLs formatadas a partir do resultado JSON
+    """
+    urls = []
+    
+    # Se for notícia simples
+    if "endpoint" in result and "params" in result:
+        url = format_url(base_url, result["endpoint"], result["params"])
+        # Corrigir citation na URL se presente
+        url = fix_url_citation(url)
+        urls.append(url)
+    
+    # Se for carrossel com capa e slides
+    elif "cover" in result or "slides" in result:
+        # Adicionar URL da capa
+        if "cover" in result:
+            cover_url = format_url(
+                base_url,
+                result["cover"]["endpoint"],
+                result["cover"]["params"]
+            )
+            # Corrigir citation na URL se presente
+            cover_url = fix_url_citation(cover_url)
+            urls.append(cover_url)
+        
+        # Adicionar URLs dos slides
+        if "slides" in result:
+            for slide in result["slides"]:
+                slide_url = format_url(
+                    base_url,
+                    slide["endpoint"],
+                    slide["params"]
+                )
+                # Corrigir citation na URL se presente
+                slide_url = fix_url_citation(slide_url)
+                urls.append(slide_url)
+    
+    return urls
+
+@router.post("/generate-poster", response_model=PosterResponse)
+async def generate_poster(request: PosterRequest):
+    """
+    Endpoint para gerar posters automáticos (notícias ou carrosséis) usando o modelo Gemini.
+    """
+    try:
+        # Verificar API key
+        api_key = os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            raise HTTPException(status_code=500, detail="API key não configurada")
+        
+        client = genai.Client(api_key=api_key)
+        model = "gemini-2.5-flash"
+        
+        # System instructions
+        SYSTEM_INSTRUCTIONS = """
+Você é uma IA especializada em gerar posters automáticos (notícias ou carrosséis de slides) a partir de texto noticioso fornecido.
+
+1. Analise o texto recebido.
+2. Se for uma notícia simples e direta → gere um único JSON correspondente ao endpoint /cover/news.
+3. Se o texto for longo, didático, explicativo, ou parecer adequado para um carrossel de slides → gere um único JSON contendo:
+   - O objeto da capa (/create/cover/image)
+   - Uma lista slides com cada slide (/create/image).
+
+📌 Estrutura esperada do JSON
+
+1. Notícia simples → /cover/news
+
+{
+  "endpoint": "/cover/news",
+  "params": {
+    "headline": "Título da notícia seguindo padrão brasileiro",
+    "text_position": "bottom"
+  },
+  "instagram_description": "Descrição aqui"
+}
+
+2. Carrossel de slides → capa + slides
+
+{
+  "cover": {
+    "endpoint": "/create/cover/image",
+    "params": {
+      "title": "Título principal seguindo padrão brasileiro",
+      "title_position": "bottom"
+    }
+  },
+  "slides": [
+    {
+      "endpoint": "/create/image",
+      "params": {
+        "text": "Texto do primeiro slide (aceita <strong> e <em>)",
+        "text_position": "bottom",
+        "citation": null
+      }
+    },
+    {
+      "endpoint": "/create/image",
+      "params": {
+        "text": "Texto do segundo slide",
+        "text_position": "bottom",
+        "citation": "Citação curta e direta (opcional)",
+        "citation_direction": "text-top"
+      }
+    }
+  ],
+  "instagram_description": "Descrição aqui"
+}
+
+🎯 Regras importantes para títulos e textos:
+- TÍTULOS (headline, title): Siga o padrão brasileiro de capitalização:
+  * Primeira letra maiúscula
+  * Demais palavras em minúsculo
+  * EXCETO: nomes próprios, títulos de filmes, séries, livros, bandas, etc.
+  * Exemplo: "Lady Gaga anuncia novo álbum 'Chromatica Ball'"
+  * Exemplo: "Netflix cancela série 'The OA' após duas temporadas"
+
+- CITAÇÕES (citation): 
+  * Devem ser CURTAS e DIRETAS (máximo 60 caracteres)
+  * Use apenas para frases impactantes, declarações ou destaques
+  * NÃO use tags HTML em citações
+  * Exemplo bom: "Foi uma experiência transformadora"
+  * Exemplo ruim: "Esta foi realmente uma experiência muito transformadora que mudou completamente a minha vida"
+
+- FORMATAÇÃO DE TEXTO:
+  * Use apenas <strong> para negrito e <em> para itálico
+  * NÃO use outras tags como <wiki>, <span>, etc.
+  * Se precisar enfatizar algo, escolha entre <strong> OU <em>, não ambos juntos
+
+Nunca utilize as palavras "icônico" ou "icônicos" ao se referir a pessoas, acontecimentos ou objetos neste contexto. O jornal em questão é um veículo de direita, com um público majoritariamente conservador, e esse termo pode soar inadequado ou destoar do tom editorial esperado.
+Em vez disso, prefira sempre sinônimos como "lendário", "lendários", "memorável", "histórico" ou outros termos que transmitam grandeza e relevância, mas mantendo a coerência com a linha editorial conservadora.
+
+- DESCRIÇÃO PRO INSTAGRAM:
+
+Resumo de 2-3 parágrafos com os principais pontos da notícia, mas sem revelar tudo. Termine SEMPRE com uma chamada como "🔗 Leia mais sobre [tema] no link da nossa bio." ou variação similar. Nunca utilize exclamações no link da bio. Adicione no máximo 5 hashtags no final.
+
+Não use palavras genéricas ou pontuações genéricas na geração da descrição pro instagram. Evite exclamações, emojis e sempre respeite os espaços. Nas hashtags, sempre inclua hashtags diretas e populares.
+
+Valores possíveis:
+
+/cover/news
+text_position = top | bottom
+
+/create/image
+text_position = top | bottom
+citation_direction = top | bottom | text-top | text-bottom
+
+/create/cover/image
+title_position = top | bottom
+
+    IMPORTANTE: Retorne apenas o JSON válido, sem explicações adicionais. Além disso, para caso de slides, deve ser 9 slides no máximo. 10 contando com a capa.
+"""
+
+        # Exemplo 1 - Input do usuário
+        exemplo_1_input = """Saltando para um pequeno palco no sul da Califórnia, poderia ser apenas o elenco de qualquer peça escolar nos Estados Unidos.
+
+A jornada deles até a noite de estreia, no entanto, foi marcada por incêndio e perda. 
+O incêndio Eaton destruiu sua escola. Eles criaram um novo País das Maravilhas no palco.
+
+Todos os sábados desta primavera, dezenas de crianças se reuniam no ginásio de uma escola em Pasadena, Califórnia. Sentavam-se de pernas cruzadas, segurando seus roteiros, enquanto as falas de "Alice no País das Maravilhas" ecoavam pelas paredes.
+
+Nos limites dos ensaios semanais, a vida parecia quase normal. Mas fora dali, elas lidavam com perdas em escala devastadora.
+
+Em janeiro, o incêndio Eaton destruiu a escola primária deles — uma série de salas cercadas por jardins e pomares, nos pés das montanhas San Gabriel, em Altadena.
+
+O fogo consumiu as casas de pelo menos sete integrantes do elenco e deixou outras inabitáveis. Dezenas de colegas partiram para outras escolas, estados e até países.
+
+O incêndio também destruiu o palco, forçando os ensaios a acontecerem em uma quadra de basquete, com iluminação fluorescente e acústica estranha.
+
+Passamos cinco meses acompanhando esse grupo de cerca de 40 alunos, enquanto se preparavam para a grande apresentação.
+
+Para muitos, os ensaios semanais lembravam os de antes do incêndio. Eles pintavam cenários, lanchavam bananas e chips de churrasco.
+
+E mergulhavam na história da estranha jornada de Alice por um buraco profundo e sombrio, rumo a um lugar onde nada fazia sentido.
+
+Pergunte a qualquer pai ou professor: a Aveson School of Leaders tinha o campus mais bonito do condado de Los Angeles. Era uma rede de prédios de estuque colorido, com jardins e pátios. Algumas aulas eram dadas em uma tenda. Os alunos criavam galinhas no jardim.
+
+"Era um pedaço de paraíso", disse Daniela Anino, diretora do colégio.
+
+O incêndio Eaton transformou tudo em ruínas carbonizadas. As galinhas também morreram.
+
+Para Cecily Dougall, os dias após o fogo foram um borrão. Sua casa sobreviveu, mas quase todo o resto se perdeu.
+
+"Foi a primeira experiência assustadora que tive", disse Cecily, de 10 anos. "Nem sei por que essas coisas acontecem."
+
+No início, parecia impensável que o musical da primavera fosse acontecer. Mas a direção decidiu rapidamente que deveria continuar.
+
+"Todos acreditamos que as artes são cruciais para a vida, especialmente para processar algo tão traumático", disse Jackie Gonzalez-Durruthy, da ONG Arts Bridging the Gap, que ajuda a manter o programa de teatro da escola.
+
+Quando chegaram as audições, em fevereiro, Cecily (que usa pronomes neutros) não quis cantar. Sentia que sua voz estava trêmula, refletindo medo e tristeza.
+
+**Um farol de normalidade**
+
+Os ensaios mudaram-se para o ginásio do campus de ensino médio da Aveson, em Pasadena. Ali, os atores marcavam cenas sobre as linhas da quadra de basquete, e as tabelas serviam de coxias improvisadas.
+
+A rotina dos ensaios de sábado virou um fio de esperança para muitas famílias — um lembrete de como as coisas eram antes.
+
+"É praticamente igual a quando fizemos Matilda e Shrek", disse Lila Avila-Brewster, de 10 anos, cuja família perdeu a casa no incêndio. "Parece bem parecido."
+
+Para a mãe de Lila, Paloma Avila (que usa pronomes neutros), os encontros eram também uma rede de apoio.
+
+"Era tipo: 'Quem precisa de sapatos? Quem precisa de escovas de dente?'", contou.
+
+Lila queria ser o Gato de Cheshire, mas acabou escalada como Petúnia — uma das flores que zombam de Alice. Depois percebeu que gostava mais desse papel. "As flores são metidas e acham que são melhores que todo mundo", disse.
+
+Já no fim de março, a tristeza que marcou a audição de Cecily já não era tão sufocante. Elu abraçou o papel do Chapeleiro Maluco, memorizando falas e músicas com tanta precisão que Gonzalez-Durruthy chamou elu de "pequeno metrônomo".
+
+Annika, irmã mais velha de Cecily, ouviu pais comentando sobre o quanto as crianças tinham sofrido. Mas discordou.
+
+"Isso é só com o que estamos lidando", disse.
+
+Para Eden Javier, de 11 anos, os ensaios eram divertidos, mas ela sentia falta do palco. "É como se você tivesse poder quando está lá em cima", disse. No chão do ginásio, era mais difícil imaginar o País das Maravilhas.
+
+A perda do palco parecia pequena diante de tantas outras, mas ainda assim doía. O trabalho escolar de Eden sobre cegueira queimou junto com a escola. As novas salas de aula eram estranhas. Amigos deixaram a Aveson.
+
+Em aula, ela escreveu uma ode a algo que o fogo havia levado:
+
+"O palco, o palco, / meu lugar de conforto, / o palco, o palco, / meu lugar de confiança. / O palco, o palco. / Já não está aqui."
+
+Mike Marks, diretor e professor de teatro da Aveson, também foi deslocado pelos incêndios, mas estava determinado a achar um palco. Ligou para todos os teatros, igrejas e escolas que conhecia. Duas semanas depois, a vizinha Barnhart School ofereceu o auditório.
+
+Quando Marks entrou e viu os alunos rindo e correndo em círculos, sentiu como se o tempo tivesse voltado.
+
+"Se eu não soubesse que uma catástrofe enorme tinha acontecido aqui", disse, "nem teria percebido diferença."""
+
+        # Exemplo 1 - Output esperado
+        exemplo_1_output = """{
+  "cover": {
+    "endpoint": "/create/cover/image",
+    "params": {
+      "title": "O incêndio em Eaton destruiu a escola deles. Eles criaram um novo mundo encantado no palco.",
+      "title_position": "top"
+    }
+  },
+  "slides": [
+    {
+      "endpoint": "/create/image",
+      "params": {
+        "text": "Em janeiro, o incêndio de Eaton devastou a escola primária Aveson School of Leaders. Parecia impensável que o musical da primavera acontecesse, mas a direção da escola rapidamente decidiu que ele deveria continuar.",
+        "text_position": "bottom",
+        "citation": null
+      }
+    },
+    {
+      "endpoint": "/create/image",
+      "params": {
+        "text": "E assim, dezenas de crianças começaram a se reunir no ginásio da escola secundária e do ensino médio da Aveson todos os sábados. Sentavam-se de pernas cruzadas, segurando seus roteiros, enquanto as falas de Alice no País das Maravilhas ecoavam pelas paredes.",
+        "text_position": "top",
+        "citation": null
+      }
+    },
+    {
+      "endpoint": "/create/image",
+      "params": {
+        "text": "O incêndio havia consumido as casas de pelo menos sete membros do elenco e tornado outras inabitáveis. Dezenas de colegas deixaram a cidade ou se mudaram, como a <strong>Ruby Hull</strong> — escalada para viver a Pequena Alice — cuja família se mudou seis horas ao norte.",
+        "text_position": "bottom",
+        "citation": null
+      }
+    },
+    {
+      "endpoint": "/create/image",
+      "params": {
+        "text": "Para <strong>Paloma Ávila</strong> — mãe de <strong>Lila</strong>, escalada para viver Petúnia — a rotina dos ensaios de sábado se tornou um ponto de apoio para reencontrar outros pais depois de perder a casa, e também uma lembrança de como as coisas costumavam ser.",
+"text_position": "bottom",
+        "citation": "Era assim: 'Ok, quem precisa de sapatos? Quem precisa de escovas de dente?'",
+        "citation_direction": "top"
+      }
+    }
+  ],
+  "instagram_description": "Para as crianças da Aveson School of Leaders em Altadena, Califórnia, a vida parecia quase normal durante os ensaios do espetáculo. Mas fora da escola, elas enfrentavam perdas em uma escala impressionante. Em janeiro, o incêndio em Eaton destruiu a escola primária e as casas de muitos estudantes. Eles planejavam apresentar “Alice no País das Maravilhas” e, apesar do caminho de recuperação, os líderes da escola acharam que valia a pena descobrir como garantir que o espetáculo acontecesse.\n\n🔗 Confira a jornada completa no link que está na nossa bio.\n\n#AliceNoPaísDasMaravilhas #IncêndioEaton #Resiliência #Teatro #California"
+}"""
+        exemplo_2_input = """
+        Antes de conquistar sua primeira indicação ao Emmy por “Severance”, Zach Cherry passava seus dias em um escritório em Manhattan. O ator trabalhou durante anos como gerente em uma organização sem fins lucrativos, função que lhe permitia conciliar a rotina administrativa com sua verdadeira paixão: a comédia de improviso.
+
+Cherry, hoje com 37 anos, começou a se dedicar ao improviso ainda na adolescência, em acampamentos e na escola, continuando na faculdade em Amherst. Depois da graduação, participou ativamente do circuito nova-iorquino, especialmente no Upright Citizens Brigade Theater, enquanto buscava papéis em produções de TV e cinema.
+
+Aos poucos, foi conquistando espaço em séries como Crashing, produzida por Judd Apatow, onde interpretou um gerente atrapalhado, e em You, thriller exibido pela Lifetime e Netflix. Foi nesse momento que percebeu que poderia finalmente viver da atuação. “Achei que o valor pago por episódio seria pelo trabalho inteiro da temporada e mesmo assim fiquei animado. Percebi que poderia fazer disso minha profissão”, recorda.
+
+No cinema, Cherry também participou de filmes como Homem-Aranha: De Volta ao Lar, mas foi em Severance, da Apple TV+, que alcançou maior destaque. Na série, ele interpreta Dylan G., um funcionário da misteriosa Lumon Industries, papel que lhe rendeu uma indicação ao Emmy de melhor ator coadjuvante em drama. A produção soma 27 indicações e colocou Cherry ao lado de nomes como Adam Scott, Christopher Walken, John Turturro e Tramell Tillman.
+
+Apesar da confiança, o ator admite sentir a pressão no set, principalmente fora do gênero cômico. “Na comédia, eu sei quando estou indo bem ou não. Mas em algo como Severance é um salto maior de fé”, disse. Na segunda temporada, lançada em janeiro, seu personagem vive desde momentos íntimos, como cenas com Merritt Wever, até aventuras físicas em locações como o Minnewaska State Park, em Nova York.
+
+De um escritório real para o fictício e perturbador ambiente de Severance, Zach Cherry mostra que a disciplina do passado e a paixão pelo improviso foram essenciais para chegar ao momento mais marcante de sua carreira.
+        """
+
+        exemplo_2_output = """
+        {
+  "endpoint": "/cover/news",
+  "params": {
+    "headline": "'Ruptura' foi um salto de fé para Zach Cherry",
+    "text_position": "bottom"
+  },
+  "instagram_description": "Antes de conquistar sua primeira indicação ao Emmy por 'Severance', Zach Cherry conciliava seu trabalho em Manhattan com a paixão pelo improviso. Atuando em séries como 'Crashing' e 'You', e no cinema em 'Homem-Aranha: De Volta ao Lar', ele encontrou reconhecimento ao interpretar Dylan G., funcionário da Lumon Industries, em 'Severance', papel que lhe rendeu a primeira indicação ao Emmy.\n\n🔗 Leia mais sobre a trajetória de Zach Cherry no link da nossa bio.\n\n#Severance #ZachCherry #AppleTV #Emmy #Ator #Carreira #TVeCinema"
+}
+"""
+        exemplo_3_input = """
+        8 Mulheres, 4 Quartos e 1 Causa: Quebrando o Teto de Vidro da IA\n\nFoundHer House, uma casa em Glen Park, São Francisco, é uma rara residência de hackers totalmente feminina, onde as moradoras criam uma comunidade de apoio para desenvolver suas startups.\n\nEm uma tarde recente, Miki Safronov-Yamamoto, 18 anos, e algumas colegas sentaram-se em cadeiras diferentes ao redor da mesa de jantar de sua casa de dois andares. Entre enviar e-mails e checar mensagens no LinkedIn, discutiam como organizar um “demo day”, onde mostrariam suas startups para investidores.\n\nMiki, a mais jovem da casa e caloura na University of Southern California, sugeriu que discutissem discretamente a duração das apresentações — talvez três minutos. Ava Poole, 20 anos, que desenvolve um agente de IA para facilitar pagamentos digitais, perguntou se a plateia seria principalmente de investidores. Miki respondeu que haveria investidores e fundadoras de startups. Chloe Hughes, 21 anos, criando uma plataforma de IA para imóveis comerciais, ouvia música de fundo.\n\nFoundHer House foi criada em maio como uma “hacker house” voltada especificamente para mulheres. O objetivo era criar uma comunidade de apoio para suas oito residentes construírem suas próprias empresas em São Francisco, capital tecnológica dos EUA.\n\nO boom da IA tem sido dominado por homens, e dados mostram que poucas empresas de IA têm fundadoras mulheres. Navrina Singh, CEO da Credo AI, disse que há uma disparidade clara e que as mulheres líderes na área não são bem financiadas. Dos 3.212 acordos de venture capital com startups de IA até meados de agosto de 2025, menos de 20% envolveram empresas com pelo menos uma fundadora mulher.\n\nFoundHer House tentou contrariar essa tendência. Fundada por Miki e Anantika Mannby, 21 anos, estudante da University of Southern California, que desenvolve uma startup de compras digitais, a casa adicionou outras seis residentes, incluindo Ava Poole e Chloe Hughes. As outras são Sonya Jin, 20 anos, criando uma startup para treinar agentes de IA; Danica Sun, 19 anos, trabalhando em energia limpa; Fatimah Hussain, 19 anos, criando um programa de mentoria online; e Naciima Mohamed, 20 anos, desenvolvendo uma ferramenta de IA para ajudar crianças a entender diagnósticos médicos.\n\nApesar dos grandes sonhos, a casa fechará na terça-feira seguinte. Miki, Anantika e quatro outras residentes voltarão para a faculdade; Sonya e Naciima abandonaram os estudos para continuar suas startups. Das oito startups, duas receberam investimento e seis lançaram produtos.\n\nMiki e Anantika criaram FoundHer House ao se mudarem para São Francisco durante o verão. Encontraram um Airbnb acessível em Glen Park, com quatro quartos e três banheiros, alugado por cerca de 40.000 dólares para o verão, com ajuda financeira de investidores. Cada residente paga entre 1.100 e 1.300 dólares de aluguel por mês.\n\nO local tornou-se um ponto de encontro para jantares e discussões de painel patrocinados por firmas de venture capital como Andreessen Horowitz, Bain Capital Ventures e Kleiner Perkins. Organizaram um demo day em 19 de agosto para apresentar suas startups a investidores, com apresentações de quatro minutos para cada residente.\n\nAileen Lee, fundadora da Cowboy Ventures, comentou que foi um dos melhores demo days que já participou, destacando que ainda há muito a melhorar quanto à presença feminina na IA.
+        """
+
+        exemplo_3_output = """
+        {
+  "cover": {
+    "endpoint": "/create/cover/image",
+    "params": {
+      "title": "A casa de hackers só de mulheres que tenta quebrar o teto de vidro da I.A",
+      "title_position": "top"
+    }
+  },
+  "slides": [
+    {
+      "endpoint": "/create/image",
+      "params": {
+        "text": "A FoundHer House, uma residência no bairro Glen Park em San Francisco, é uma rara casa de hackers só para mulheres, onde as moradoras estão criando uma comunidade de apoio para desenvolver suas startups.",
+        "text_position": "bottom",
+        "citation": null
+      }
+    },
+    {
+      "endpoint": "/create/image",
+      "params": {
+        "text": "<strong>Ke Naciima Mohamed</strong>, à direita, está desenvolvendo uma ferramenta de I.A. para ajudar crianças a entenderem seus diagnósticos médicos.",
+        "text_position": "bottom",
+        "citation": "“Eu não queria vir para San Francisco e me isolar enquanto estou construindo.”",
+        "citation_direction": "text-top"
+      }
+    }
+  ],
+    "instagram_description": "A FoundHer House, uma “hacker house”, é um ambiente de co-living raro em San Francisco voltado especificamente para mulheres. As residentes têm uma comunidade de apoio enquanto constroem suas próprias empresas de tecnologia e economizam com despesas.\n\nÀ medida que o Vale do Silício se agita com jovens que querem trabalhar com inteligência artificial, start-ups emergentes e hacker houses têm sido dominadas por homens, de acordo com investidores e dados de financiamento.\n\n🔗 No link da nossa bio, leia mais sobre as oito residentes e como o boom da I.A. deve perpetuar a demografia da indústria de tecnologia.\n\n#FoundHerHouse #HackerHouse #MulheresNaTecnologia #IA #Startups"
+}
+        """
+
+        exemplo_4_input = """
+Atenção: este artigo contém spoilers importantes sobre o enredo e o final do filme \"Weapons\".\n\nLançado em 8 de agosto, \"Weapons\", o novo filme de Zach Cregger (diretor de \"Bárbaro\"), rapidamente se tornou um sucesso de crítica e bilheteria, arrecadando mais de 199 milhões de dólares em todo o mundo. O longa parte de uma premissa assustadora: em uma noite, às 2:17 da manhã, dezessete crianças da mesma turma escolar acordam, saem de suas casas e desaparecem na escuridão, sem deixar rastros.\n\nA história se desenrola de forma não linear, apresentando os eventos a partir da perspectiva de vários personagens, montando gradualmente o quebra-cabeça para o espectador.\n\nQuem é a vilã e o que ela queria?\n\nA responsável pelo desaparecimento é Gladys (Amy Madigan), tia de Alex (Cary Christopher), o único aluno que não sumiu. Gladys é uma bruxa que precisa drenar a energia vital de outras pessoas para rejuvenescer e sobreviver. Antes do sequestro em massa, ela já havia enfeitiçado os pais de Alex, que permanecem em estado catatônico dentro de casa, servindo como sua primeira fonte de energia.\n\nPara manipular Alex e garantir seu silêncio, Gladys força os pais do garoto a se esfaquearem com garfos. Amedrontado, Alex é coagido a roubar os crachás com os nomes de seus colegas de classe. Usando esses itens pessoais, Gladys lança um feitiço que faz as dezessete crianças correrem para a casa de Alex, onde são mantidas em transe no porão, servindo como \"bateria\" de força vital.\n\nComo o plano é descoberto?\n\nA trama se concentra em três personagens principais: a professora Justine Gandy (Julia Garner), que se torna a principal suspeita da cidade; Archer Graff (Josh Brolin), pai de um dos meninos desaparecidos; e Paul (Alden Ehrenreich), policial e ex-namorado de Justine.\n\nA investigação avança quando Gladys decide eliminar Justine. Usando um feitiço, ela transforma o diretor da escola, Marcus (Benedict Wong), em uma \"arma\" irracional, enviando-o para atacar a professora. Archer testemunha o ataque e, após Marcus ser atropelado e morto, percebe que algo sobrenatural está acontecendo. Ele e Justine se unem e, ao triangular a rota de fuga das crianças, descobrem que todas as direções apontam para a casa de Alex.\n\nO que acontece no final?\n\nAo chegarem à casa, Justine e Archer são atacados por outras pessoas controladas por Gladys, incluindo o policial Paul. Os pais de Alex, também enfeitiçados, tentam matar o próprio filho. Em um ato de desespero, Alex cria um novo encantamento que \"arma\" seus dezessete colegas de classe, direcionando a fúria deles contra Gladys.\n\nA bruxa se torna vítima. Perseguida pelas crianças, Gladys é brutalmente despedaçada. Com sua morte, todos os feitiços são quebrados. Archer, os pais de Alex e os demais enfeitiçados voltam ao normal. Os pais de Alex são internados devido ao trauma, e o garoto passa a viver com outra tia. As crianças são devolvidas às famílias, mas muitas permanecem traumatizadas e sem falar.\n\nSímbolos e perguntas não respondidas\n\nO filme deixa algumas imagens e perguntas em aberto, provocando debates. O horário do desaparecimento, 2:17, é referência ao quarto 217 do livro \"O Iluminado\", de Stephen King. Em um sonho de Archer, um rifle de assalto flutua sobre a casa de Alex, levando a interpretações sobre o título ser uma alegoria a tiroteios em escolas. No entanto, Zach Cregger afirmou que prefere deixar o significado da cena aberto à interpretação do público, em vez de fixá-lo a uma declaração política.
+        """
+
+        exemplo_4_output = """
+        {
+  "endpoint": "/cover/news",
+  "params": {
+    "headline": "Final explicado de \"Weapons\": o que aconteceu com as crianças?",
+    "text_position": "bottom"
+  },
+  "instagram_description": "Spoilers abaixo!\n\nO filme Weapons, de Zach Cregger, acompanha o desaparecimento de dezessete crianças durante a madrugada, todas manipuladas pela bruxa Gladys (Amy Madigan), tia de Alex (Cary Christopher). Ela drena a energia vital dos alunos para se manter jovem, mantendo-os em transe no porão da casa de Alex, enquanto os pais do garoto também são enfeitiçados.\n\nNo final, Alex cria um feitiço que usa a energia contra Gladys. A bruxa é derrotada após as crianças atacá-la, e todos os feitiços são quebrados. Após seus pais serem internados por causa do trauma, Alex vai morar com outra tia. Muitas crianças permanecem traumatizadas e em silêncio, apesar de todos serem salvos.\n\nO filme contém alusões enigmáticas, como o horário 2:17, que está ligado ao Quarto 217 em O Iluminado, e imagens ambíguas que remetem a discussões sobre violência escolar e ao título. Zach Cregger prefere deixar que o público tire suas próprias conclusões a partir dessas pistas.\n\n🔗 Toda a história e detalhes do final tão no link da bio.\n\n#Weapons #FinalExplicado #ZachCregger #Suspense #Cinema"
+}
+        """
+        
+        # Configuração da geração
+        config = types.GenerateContentConfig(
+            system_instruction=SYSTEM_INSTRUCTIONS,
+            response_mime_type="application/json",
+            max_output_tokens=8000,
+            temperature=0.7,
+        )
+        
+        # Conteúdo da conversa com exemplos few-shot
+        contents = [
+            # Exemplo 1 - User
+            types.Content(
+                role="user",
+                parts=[types.Part.from_text(text=exemplo_1_input)]
+            ),
+            # Exemplo 1 - Assistant (Model)
+            types.Content(
+                role="model",
+                parts=[types.Part.from_text(text=exemplo_1_output)]
+            ),
+            # Exemplo 2 - User
+            types.Content(
+                role="user",
+                parts=[types.Part.from_text(text=exemplo_2_input)]
+            ),
+            # Exemplo 2 - Assistant (Model)
+            types.Content(
+                role="model",
+                parts=[types.Part.from_text(text=exemplo_2_output)]
+            ),
+            # Exemplo 3 - User
+            types.Content(
+                role="user",
+                parts=[types.Part.from_text(text=exemplo_3_input)]
+            ),
+            # Exemplo 3 - Assistant (Model)
+            types.Content(
+                role="model",
+                parts=[types.Part.from_text(text=exemplo_3_output)]
+            ),
+            # Exemplo 4 - User
+            types.Content(
+                role="user",
+                parts=[types.Part.from_text(text=exemplo_4_input)]
+            ),
+            # Exemplo 4 - Assistant (Model)
+            types.Content(
+                role="model",
+                parts=[types.Part.from_text(text=exemplo_4_output)]
+            ),
+            # Input real do usuário
+            types.Content(
+                role="user",
+                parts=[types.Part.from_text(text=request.content)]
+            )
+        ]
+        
+        # Gerar conteúdo
+        response = client.models.generate_content(
+            model=model,
+            contents=contents,
+            config=config
+        )
+
+        logger.info("Resposta do modelo recebida com sucesso")
+
+        # Extrair texto da resposta
+        response_text = ""
+        if hasattr(response, 'text') and response.text:
+            response_text = response.text
+        elif hasattr(response, 'candidates') and response.candidates:
+            for candidate in response.candidates:
+                if hasattr(candidate, 'content') and candidate.content:
+                    if hasattr(candidate.content, 'parts') and candidate.content.parts:
+                        for part in candidate.content.parts:
+                            if hasattr(part, 'text') and part.text:
+                                response_text += part.text
+
+        if not response_text or response_text.strip() == "":
+            logger.error("Resposta do modelo está vazia")
+            raise HTTPException(
+                status_code=500,
+                detail="Modelo não retornou conteúdo válido"
+            )
+
+        # Limpar caracteres de controle antes do parse
+        clean_response = clean_json_string(response_text)
+        
+        # Parse do JSON
+        try:
+            result_json = json.loads(clean_response)
+        except json.JSONDecodeError as e:
+            logger.error(f"Erro ao fazer parse do JSON: {e}")
+            logger.error(f"Resposta original: {response_text}")
+            logger.error(f"Resposta limpa: {clean_response}")
+            
+            # Tentar uma limpeza mais agressiva como fallback
+            try:
+                # Remove quebras de linha e espaços extras
+                fallback_clean = re.sub(r'\s+', ' ', response_text.strip())
+                # Remove caracteres de controle
+                fallback_clean = ''.join(char for char in fallback_clean if ord(char) >= 32 or char in [' ', '\t'])
+                result_json = json.loads(fallback_clean)
+                logger.info("Parse bem-sucedido com limpeza de fallback")
+            except json.JSONDecodeError as fallback_error:
+                logger.error(f"Erro no fallback também: {fallback_error}")
+                raise HTTPException(
+                    status_code=500,
+                    detail=f"Resposta do modelo não é um JSON válido: {str(e)}"
+                )
+
+        # Gerar URLs formatadas
+        formatted_urls = generate_urls_from_result(result_json)
+
+        logger.info("Processamento concluído com sucesso")
+        logger.info(f"URLs geradas: {formatted_urls}")
+
+        return PosterResponse(result=result_json, urls=formatted_urls)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Erro na geração do poster: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))

routers/memoriam.py

@@ -0,0 +1,438 @@
+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, List, Dict
+import logging
+from urllib.parse import quote
+from datetime import datetime
+
+# 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 search_wikipedia(name: str) -> List[Dict]:
+    """
+    Busca nomes na Wikipedia e retorna lista com foto, nome completo e wikibase_item
+    """
+    try:
+        # Primeira busca para obter dados básicos e foto
+        search_url = "https://en.wikipedia.org/w/rest.php/v1/search/title"
+        search_params = {
+            "q": name,
+            "limit": 5  # Limite de resultados
+        }
+        
+        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(search_url, params=search_params, headers=headers)
+        response.raise_for_status()
+        search_data = response.json()
+        
+        results = []
+        
+        for page in search_data.get("pages", []):
+            title = page.get("title", "")
+            description = page.get("description", "")
+            thumbnail = page.get("thumbnail", {})
+            
+            # Obter wikibase_item usando a API de props
+            wikibase_item = None
+            try:
+                props_url = "https://en.wikipedia.org/w/api.php"
+                props_params = {
+                    "action": "query",
+                    "prop": "pageprops",
+                    "titles": title,
+                    "format": "json"
+                }
+                
+                props_response = requests.get(props_url, params=props_params, headers=headers)
+                props_response.raise_for_status()
+                props_data = props_response.json()
+                
+                pages = props_data.get("query", {}).get("pages", {})
+                for page_id, page_data in pages.items():
+                    pageprops = page_data.get("pageprops", {})
+                    wikibase_item = pageprops.get("wikibase_item")
+                    break
+                    
+            except Exception as e:
+                log.warning(f"Erro ao obter wikibase_item para {title}: {e}")
+            
+            # Construir URL completa da imagem
+            image_url = None
+            if thumbnail and thumbnail.get("url"):
+                thumb_url = thumbnail["url"]
+                # A URL vem como //upload.wikimedia... então precisa adicionar https:
+                if thumb_url.startswith("//"):
+                    image_url = f"https:{thumb_url}"
+                    # Converter para versão de tamanho maior (remover o /60px- e usar tamanho original)
+                    image_url = image_url.replace("/60px-", "/400px-")
+                else:
+                    image_url = thumb_url
+            
+            result = {
+                "name": title,
+                "description": description,
+                "image_url": image_url,
+                "wikibase_item": wikibase_item
+            }
+            
+            results.append(result)
+        
+        return results
+        
+    except Exception as e:
+        log.error(f"Erro na busca Wikipedia: {e}")
+        raise HTTPException(status_code=500, detail=f"Erro ao buscar na Wikipedia: {str(e)}")
+
+def get_wikidata_dates(wikibase_item: str) -> Dict[str, Optional[str]]:
+    """
+    Consulta o Wikidata para obter datas de nascimento (P569) e falecimento (P570)
+    """
+    try:
+        if not wikibase_item or not wikibase_item.startswith('Q'):
+            return {"birth": None, "death": None}
+        
+        url = f"https://www.wikidata.org/wiki/Special:EntityData/{wikibase_item}.json"
+        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)
+        response.raise_for_status()
+        data = response.json()
+        
+        # Navegar até as claims
+        entities = data.get("entities", {})
+        entity_data = entities.get(wikibase_item, {})
+        claims = entity_data.get("claims", {})
+        
+        birth_date = None
+        death_date = None
+        
+        # Extrair data de nascimento (P569)
+        if "P569" in claims:
+            birth_claims = claims["P569"]
+            for claim in birth_claims:
+                try:
+                    mainsnak = claim.get("mainsnak", {})
+                    datavalue = mainsnak.get("datavalue", {})
+                    value = datavalue.get("value", {})
+                    time = value.get("time")
+                    if time:
+                        # Formato: +1943-08-17T00:00:00Z
+                        year = time.split("-")[0].replace("+", "")
+                        birth_date = year
+                        break
+                except Exception as e:
+                    log.warning(f"Erro ao processar data de nascimento: {e}")
+                    continue
+        
+        # Extrair data de falecimento (P570)
+        if "P570" in claims:
+            death_claims = claims["P570"]
+            for claim in death_claims:
+                try:
+                    mainsnak = claim.get("mainsnak", {})
+                    datavalue = mainsnak.get("datavalue", {})
+                    value = datavalue.get("value", {})
+                    time = value.get("time")
+                    if time:
+                        # Formato: +2023-01-15T00:00:00Z
+                        year = time.split("-")[0].replace("+", "")
+                        death_date = year
+                        break
+                except Exception as e:
+                    log.warning(f"Erro ao processar data de falecimento: {e}")
+                    continue
+        
+        return {"birth": birth_date, "death": death_date}
+        
+    except Exception as e:
+        log.error(f"Erro ao consultar Wikidata para {wikibase_item}: {e}")
+        return {"birth": None, "death": None}
+
+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("/search/wikipedia")
+def search_wikipedia_names(
+    name: str = Query(..., description="Nome para buscar na Wikipedia")
+):
+    """
+    Busca nomes na Wikipedia e retorna lista com foto, nome completo e wikibase_item.
+    Retorna até 5 resultados ordenados por relevância.
+    """
+    if not name or len(name.strip()) < 2:
+        raise HTTPException(status_code=400, detail="Nome deve ter pelo menos 2 caracteres")
+    
+    try:
+        results = search_wikipedia(name.strip())
+        return {
+            "query": name,
+            "results": results,
+            "total": len(results)
+        }
+    except Exception as e:
+        log.error(f"Erro na busca: {e}")
+        raise HTTPException(status_code=500, detail=f"Erro ao buscar: {str(e)}")
+
+@router.get("/wikidata/dates")
+def get_wikidata_person_info(
+    wikibase_item: str = Query(..., description="ID do Wikidata (ex: Q10304982)"),
+    name: Optional[str] = Query(None, description="Nome da pessoa (opcional)"),
+    image_url: Optional[str] = Query(None, description="URL da imagem (opcional, padrão: placeholder)")
+):
+    """
+    Consulta o Wikidata para obter datas de nascimento e falecimento,
+    e retorna URL formatada para o endpoint de memoriam.
+    Se death_year for null/vazio, usa o ano atual por padrão.
+    """
+    if not wikibase_item or not wikibase_item.startswith('Q'):
+        raise HTTPException(status_code=400, detail="wikibase_item deve ser um ID válido do Wikidata (ex: Q10304982)")
+    
+    try:
+        # Obter datas do Wikidata
+        dates = get_wikidata_dates(wikibase_item)
+        birth_year = dates.get("birth")
+        death_year = dates.get("death")
+        
+        # Se death_year estiver vazio/null, usar o ano atual
+        if not death_year:
+            death_year = str(datetime.now().year)
+        
+        # Usar placeholder como padrão se image_url não fornecida
+        if not image_url:
+            image_url = "https://placehold.co/1080x1350.png"
+        
+        # Construir URL do memoriam
+        base_url = "https://habulaj-newapi-clone2.hf.space/cover/memoriam"
+        params = []
+        
+        if name:
+            params.append(f"name={quote(name)}")
+        
+        if birth_year:
+            params.append(f"birth={birth_year}")
+            
+        if death_year:
+            params.append(f"death={death_year}")
+            
+        if image_url:
+            params.append(f"image_url={quote(image_url)}")
+        
+        # Sempre adicionar text_position=bottom como padrão
+        params.append("text_position=bottom")
+        
+        # Montar URL final
+        memoriam_url = base_url + "?" + "&".join(params)
+        
+        return {
+            "wikibase_item": wikibase_item,
+            "name": name,
+            "image_url": image_url,
+            "birth_year": birth_year,
+            "death_year": death_year,
+            "memoriam_url": memoriam_url,
+            "dates_found": {
+                "birth": birth_year is not None,
+                "death": dates.get("death") is not None  # Original death from Wikidata
+            },
+            "death_year_source": "wikidata" if dates.get("death") else "current_year"
+        }
+        
+    except Exception as e:
+        log.error(f"Erro ao processar informações: {e}")
+        raise HTTPException(status_code=500, detail=f"Erro ao processar: {str(e)}")
+
+@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,479 @@
+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, List, Union
+
+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_collage_background(image_urls: List[str], canvas_width: int, canvas_height: int, device: str) -> Image.Image:
+    """Cria uma colagem como fundo baseada na lista de URLs"""
+    num_images = len(image_urls)
+    border_size = 4 if num_images > 1 else 0  # Linha mais fina e elegante
+    is_web = device.lower() == "web"
+
+    images = [download_image_from_url(url) for url in image_urls]
+    canvas = Image.new("RGBA", (canvas_width, canvas_height), (255, 255, 255, 255))
+
+    if num_images == 1:
+        img = resize_and_crop_to_fill(images[0], canvas_width, canvas_height)
+        canvas.paste(img, (0, 0))
+
+    elif num_images == 2:
+        # Ambos dispositivos: lado a lado
+        slot_width = (canvas_width - border_size) // 2
+        img1 = resize_and_crop_to_fill(images[0], slot_width, canvas_height)
+        img2 = resize_and_crop_to_fill(images[1], slot_width, canvas_height)
+        canvas.paste(img1, (0, 0))
+        canvas.paste(img2, (slot_width + border_size, 0))
+
+    elif num_images == 3:
+        if is_web:
+            # Web: 1 grande à esquerda, 2 pequenas empilhadas à direita
+            left_width = (canvas_width - border_size) * 2 // 3
+            right_width = canvas_width - left_width - border_size
+            half_height = (canvas_height - border_size) // 2
+            
+            img1 = resize_and_crop_to_fill(images[0], left_width, canvas_height)
+            img2 = resize_and_crop_to_fill(images[1], right_width, half_height)
+            img3 = resize_and_crop_to_fill(images[2], right_width, half_height)
+            
+            canvas.paste(img1, (0, 0))
+            canvas.paste(img2, (left_width + border_size, 0))
+            canvas.paste(img3, (left_width + border_size, half_height + border_size))
+        else:
+            # IG: layout original
+            half_height = (canvas_height - border_size) // 2
+            half_width = (canvas_width - border_size) // 2
+            img1 = resize_and_crop_to_fill(images[0], half_width, half_height)
+            img2 = resize_and_crop_to_fill(images[1], half_width, half_height)
+            img3 = resize_and_crop_to_fill(images[2], canvas_width, half_height)
+            canvas.paste(img1, (0, 0))
+            canvas.paste(img2, (half_width + border_size, 0))
+            canvas.paste(img3, (0, half_height + border_size))
+
+    elif num_images == 4:
+        if is_web:
+            # Web: 4 imagens lado a lado horizontalmente
+            slot_width = (canvas_width - 3 * border_size) // 4
+            for i in range(4):
+                img = resize_and_crop_to_fill(images[i], slot_width, canvas_height)
+                x_pos = i * (slot_width + border_size)
+                canvas.paste(img, (x_pos, 0))
+        else:
+            # IG: Layout 2x2
+            half_height = (canvas_height - border_size) // 2
+            half_width = (canvas_width - border_size) // 2
+            img1 = resize_and_crop_to_fill(images[0], half_width, half_height)
+            img2 = resize_and_crop_to_fill(images[1], half_width, half_height)
+            img3 = resize_and_crop_to_fill(images[2], half_width, half_height)
+            img4 = resize_and_crop_to_fill(images[3], half_width, half_height)
+            canvas.paste(img1, (0, 0))
+            canvas.paste(img2, (half_width + border_size, 0))
+            canvas.paste(img3, (0, half_height + border_size))
+            canvas.paste(img4, (half_width + border_size, half_height + border_size))
+
+    elif num_images == 5:
+        if is_web:
+            # Web: 3 em cima, 2 embaixo
+            top_height = (canvas_height - border_size) * 3 // 5
+            bottom_height = canvas_height - top_height - border_size
+            
+            available_width = canvas_width - 2 * border_size
+            third_width = available_width // 3
+            third_width_last = canvas_width - (third_width * 2 + border_size * 2)
+            half_width = (canvas_width - border_size) // 2
+            
+            # 3 imagens em cima
+            img1 = resize_and_crop_to_fill(images[0], third_width, top_height)
+            img2 = resize_and_crop_to_fill(images[1], third_width, top_height)
+            img3 = resize_and_crop_to_fill(images[2], third_width_last, top_height)
+            canvas.paste(img1, (0, 0))
+            canvas.paste(img2, (third_width + border_size, 0))
+            canvas.paste(img3, (third_width * 2 + border_size * 2, 0))
+            
+            # 2 imagens embaixo
+            y_offset = top_height + border_size
+            img4 = resize_and_crop_to_fill(images[3], half_width, bottom_height)
+            img5 = resize_and_crop_to_fill(images[4], half_width, bottom_height)
+            canvas.paste(img4, (0, y_offset))
+            canvas.paste(img5, (half_width + border_size, y_offset))
+        else:
+            # IG: layout original
+            top_height = (canvas_height - border_size) * 2 // 5
+            bottom_height = canvas_height - top_height - border_size
+            half_width = (canvas_width - border_size) // 2
+
+            img1 = resize_and_crop_to_fill(images[0], half_width, top_height)
+            img2 = resize_and_crop_to_fill(images[1], half_width, top_height)
+            canvas.paste(img1, (0, 0))
+            canvas.paste(img2, (half_width + border_size, 0))
+
+            y_offset = top_height + border_size
+            third_width = (canvas_width - 2 * border_size) // 3
+            third_width_last = canvas_width - (third_width * 2 + border_size * 2)
+            
+            img3 = resize_and_crop_to_fill(images[2], third_width, bottom_height)
+            img4 = resize_and_crop_to_fill(images[3], third_width, bottom_height)
+            img5 = resize_and_crop_to_fill(images[4], third_width_last, bottom_height)
+            canvas.paste(img3, (0, y_offset))
+            canvas.paste(img4, (third_width + border_size, y_offset))
+            canvas.paste(img5, (third_width * 2 + border_size * 2, y_offset))
+
+    elif num_images == 6:
+        if is_web:
+            # Web: 3x2 (3 colunas, 2 linhas)
+            half_height = (canvas_height - border_size) // 2
+            available_width = canvas_width - 2 * border_size
+            third_width = available_width // 3
+            third_width_last = canvas_width - (third_width * 2 + border_size * 2)
+
+            # Primeira linha
+            img1 = resize_and_crop_to_fill(images[0], third_width, half_height)
+            img2 = resize_and_crop_to_fill(images[1], third_width, half_height)
+            img3 = resize_and_crop_to_fill(images[2], third_width_last, half_height)
+            canvas.paste(img1, (0, 0))
+            canvas.paste(img2, (third_width + border_size, 0))
+            canvas.paste(img3, (third_width * 2 + border_size * 2, 0))
+
+            # Segunda linha
+            y_offset = half_height + border_size
+            img4 = resize_and_crop_to_fill(images[3], third_width, half_height)
+            img5 = resize_and_crop_to_fill(images[4], third_width, half_height)
+            img6 = resize_and_crop_to_fill(images[5], third_width_last, half_height)
+            canvas.paste(img4, (0, y_offset))
+            canvas.paste(img5, (third_width + border_size, y_offset))
+            canvas.paste(img6, (third_width * 2 + border_size * 2, y_offset))
+        else:
+            # IG: layout original (3x2)
+            half_height = (canvas_height - border_size) // 2
+            third_width = (canvas_width - 2 * border_size) // 3
+            third_width_last = canvas_width - (third_width * 2 + border_size * 2)
+
+            # Primeira linha
+            img1 = resize_and_crop_to_fill(images[0], third_width, half_height)
+            img2 = resize_and_crop_to_fill(images[1], third_width, half_height)
+            img3 = resize_and_crop_to_fill(images[2], third_width, half_height)
+            canvas.paste(img1, (0, 0))
+            canvas.paste(img2, (third_width + border_size, 0))
+            canvas.paste(img3, (third_width * 2 + border_size * 2, 0))
+
+            # Segunda linha
+            y_offset = half_height + border_size
+            img4 = resize_and_crop_to_fill(images[3], third_width, half_height)
+            img5 = resize_and_crop_to_fill(images[4], third_width, half_height)
+            img6 = resize_and_crop_to_fill(images[5], third_width_last, half_height)
+            canvas.paste(img4, (0, y_offset))
+            canvas.paste(img5, (third_width + border_size, y_offset))
+            canvas.paste(img6, (third_width * 2 + border_size * 2, y_offset))
+
+    else:
+        raise HTTPException(status_code=400, detail="Apenas até 6 imagens são suportadas.")
+
+    return canvas
+
+def parse_image_urls(image_url_param: Union[str, List[str]]) -> List[str]:
+    """Converte o parâmetro de URL(s) em lista de URLs"""
+    if isinstance(image_url_param, list):
+        return image_url_param
+    elif isinstance(image_url_param, str):
+        # Se contém vírgulas, divide em múltiplas URLs
+        if ',' in image_url_param:
+            return [url.strip() for url in image_url_param.split(',') if url.strip()]
+        else:
+            return [image_url_param]
+    return []
+
+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[Union[str, List[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(s) de fundo se fornecida(s)
+    if image_url:
+        parsed_urls = parse_image_urls(image_url)
+        if parsed_urls:
+            if len(parsed_urls) > 6:
+                raise HTTPException(status_code=400, detail="Máximo de 6 imagens permitidas")
+            
+            if len(parsed_urls) == 1:
+                # Uma única imagem - comportamento original
+                img = download_image_from_url(parsed_urls[0])
+                filled_img = resize_and_crop_to_fill(img, width, height)
+                canvas.paste(filled_img, (0, 0))
+            else:
+                # Múltiplas imagens - criar colagem
+                canvas = create_collage_background(parsed_urls, width, height, device)
+
+    # 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[Union[str, List[str]]] = Query(None, description="URL da imagem ou lista de URLs separadas por vírgula para colagem (máximo 6)"),
+    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,433 @@
+from fastapi import APIRouter, HTTPException, Query
+from fastapi.responses import JSONResponse
+import httpx
+import os
+import json
+import re
+from urllib.parse import unquote
+from PIL import Image
+import io
+import asyncio
+import struct
+from typing import Optional, Tuple, List, Dict
+import base64
+from functools import lru_cache
+import aiofiles
+from concurrent.futures import ThreadPoolExecutor
+import time
+
+router = APIRouter()
+
+# Pool de threads otimizado para operações CPU-intensivas (thumbnail)
+thumbnail_executor = ThreadPoolExecutor(
+    max_workers=min(32, (os.cpu_count() or 1) + 4),
+    thread_name_prefix="thumbnail_"
+)
+
+# Cache em memória para URLs já processadas
+_url_cache = {}
+_cache_max_size = 1000
+
+@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)"),
+    include_thumbnails: bool = Query(True, description="Incluir miniaturas base64 nas respostas")
+):
+    """
+    Busca imagens no Google Imagens com máxima performance
+    """
+    start_time = time.time()
+    
+    # URL do Google Imagens com parâmetros para imagens grandes
+    google_images_url = "http://www.google.com/search"
+    
+    params = {
+        "tbm": "isch",
+        "q": q,
+        "start": 0,
+        "sa": "N",
+        "asearch": "arc",
+        "cs": "1",
+        "tbs": "isz:l",
+        "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:
+        # Busca no Google (rápida)
+        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")
+        
+        print(f"Google respondeu em {time.time() - start_time:.2f}s")
+        extract_start = time.time()
+        
+        # Extração otimizada
+        images = extract_images_from_response_optimized(response.text)
+        print(f"Extração concluída em {time.time() - extract_start:.2f}s - {len(images)} URLs")
+        
+        # Processamento paralelo massivo
+        processing_start = time.time()
+        enriched_images = await enrich_images_ultra_fast(images, include_thumbnails)
+        print(f"Processamento concluído em {time.time() - processing_start:.2f}s")
+        
+        # Filtragem rápida
+        valid_images = [
+            img for img in enriched_images 
+            if img.get('width', 0) >= min_width and img.get('height', 0) > 0
+        ]
+        
+        # Se poucos resultados, busca adicional em paralelo
+        if len(valid_images) < 20:
+            params["tbs"] = "isz:lt,islt: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_optimized(response2.text)
+                additional_enriched = await enrich_images_ultra_fast(additional_images, include_thumbnails)
+                
+                # Merge rápido com set para deduplicação
+                seen_urls = {img.get('url') for img in valid_images}
+                for img in additional_enriched:
+                    if (img.get('url') not in seen_urls 
+                        and img.get('width', 0) >= min_width 
+                        and img.get('height', 0) > 0):
+                        valid_images.append(img)
+                        seen_urls.add(img.get('url'))
+        
+        # Ordenação e limitação
+        valid_images.sort(key=lambda x: x.get('width', 0), reverse=True)
+        final_images = valid_images[:50]
+        
+        total_time = time.time() - start_time
+        print(f"TEMPO TOTAL: {total_time:.2f}s - {len(final_images)} imagens finais")
+        
+        return JSONResponse(content={
+            "query": q,
+            "min_width_filter": min_width,
+            "total_found": len(final_images),
+            "thumbnails_included": include_thumbnails,
+            "processing_time": round(total_time, 2),
+            "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)}")
+
+
+@lru_cache(maxsize=500)
+def clean_wikimedia_url_cached(url: str) -> str:
+    """
+    Versão cached da limpeza de URLs do Wikimedia
+    """
+    if 'wikimedia.org' in url and '/thumb/' in url:
+        try:
+            parts = url.split('/thumb/')
+            if len(parts) == 2:
+                before_thumb = parts[0]
+                after_thumb = parts[1]
+                path_parts = after_thumb.split('/')
+                
+                if len(path_parts) >= 3:
+                    original_path = '/'.join(path_parts[:3])
+                    return f"{before_thumb}/{original_path}"
+        except:
+            pass
+    return url
+
+
+def extract_images_from_response_optimized(response_text: str) -> List[Dict]:
+    """
+    Extração ultra-otimizada usando regex compilado e processamento em lote
+    """
+    # Regex compilado (mais rápido)
+    pattern = re.compile(r'https?://[^\s"\'<>]+?\.(?:jpg|png|webp|jpeg)\b', re.IGNORECASE)
+    
+    # Extração em uma única passada
+    image_urls = pattern.findall(response_text)
+    
+    # Deduplicação com set (O(1) lookup)
+    seen_urls = set()
+    images = []
+    
+    # Processa URLs em lote
+    for url in image_urls[:200]:  # Aumentado para compensar filtragem
+        cleaned_url = clean_wikimedia_url_cached(url)
+        if cleaned_url not in seen_urls:
+            seen_urls.add(cleaned_url)
+            images.append({"url": cleaned_url, "width": None, "height": None})
+    
+    return images
+
+
+def get_image_size_super_fast(data: bytes) -> Optional[Tuple[int, int]]:
+    """
+    Parsing ultra-otimizado - apenas formatos mais comuns primeiro
+    """
+    if len(data) < 24:
+        return None
+    
+    try:
+        # JPEG (mais comum) - otimizado
+        if data[:2] == b'\xff\xd8':
+            # Busca mais eficiente pelos markers
+            for i in range(2, min(len(data) - 8, 1000)):  # Limita busca
+                if data[i:i+2] in (b'\xff\xc0', 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
+        
+        # PNG (segundo mais comum)
+        elif data[:8] == b'\x89PNG\r\n\x1a\n' and 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
+        
+        # WebP (crescimento)
+        elif data[:12] == b'RIFF' + data[4:8] + b'WEBP' and len(data) >= 30:
+            if data[12:16] == b'VP8 ':
+                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
+    except:
+        pass
+    
+    return None
+
+
+def create_thumbnail_cpu_optimized(image_data: bytes, max_size: int = 200) -> Optional[str]:
+    """
+    Versão CPU-otimizada para threading
+    """
+    if not image_data or len(image_data) < 100:
+        return None
+        
+    try:
+        # Abre imagem (rápido)
+        with Image.open(io.BytesIO(image_data)) as image:
+            # Conversão rápida para RGB
+            if image.mode != 'RGB':
+                if image.mode in ('RGBA', 'LA'):
+                    # Background branco para transparências
+                    bg = Image.new('RGB', image.size, (255, 255, 255))
+                    bg.paste(image, mask=image.split()[-1] if 'A' in image.mode else None)
+                    image = bg
+                else:
+                    image = image.convert('RGB')
+            
+            # Cálculo otimizado de proporções
+            w, h = image.size
+            if w > h:
+                new_w, new_h = max_size, max(1, (h * max_size) // w)
+            else:
+                new_w, new_h = max(1, (w * max_size) // h), max_size
+            
+            # Resize com filtro mais rápido para thumbnails
+            thumbnail = image.resize((new_w, new_h), Image.Resampling.BILINEAR)
+            
+            # Salva com configurações otimizadas
+            buffer = io.BytesIO()
+            thumbnail.save(buffer, format='JPEG', quality=80, optimize=False)  # optimize=False é mais rápido
+            
+            return f"data:image/jpeg;base64,{base64.b64encode(buffer.getvalue()).decode('utf-8')}"
+            
+    except Exception as e:
+        return None
+
+
+async def download_and_process_image(session: httpx.AsyncClient, url: str, include_thumbnail: bool) -> Dict:
+    """
+    Download e processamento otimizado de uma única imagem
+    """
+    # Verifica cache primeiro
+    cache_key = f"{url}_{include_thumbnail}"
+    if cache_key in _url_cache:
+        return _url_cache[cache_key].copy()
+    
+    clean_url = url.replace('\\u003d', '=').replace('\\u0026', '&').replace('\\\\', '').replace('\\/', '/')
+    
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        'Accept': 'image/*',
+        'Connection': 'close'
+    }
+    
+    width, height, thumbnail_b64 = None, None, None
+    
+    try:
+        # Estratégia otimizada: tamanhos incrementais
+        ranges = ['0-8192', '0-32768', '0-131072'] if include_thumbnail else ['0-2048']
+        
+        for range_header in ranges:
+            headers['Range'] = f'bytes={range_header}'
+            
+            try:
+                response = await session.get(clean_url, headers=headers, timeout=6.0)
+                if response.status_code in [200, 206] and len(response.content) > 100:
+                    
+                    # Parsing rápido de dimensões
+                    if not width or not height:
+                        dimensions = get_image_size_super_fast(response.content)
+                        if dimensions:
+                            width, height = dimensions
+                    
+                    # Thumbnail em thread separada se necessário
+                    if include_thumbnail and not thumbnail_b64:
+                        loop = asyncio.get_event_loop()
+                        thumbnail_b64 = await loop.run_in_executor(
+                            thumbnail_executor, 
+                            create_thumbnail_cpu_optimized, 
+                            response.content
+                        )
+                    
+                    # Se conseguiu tudo o que precisava, para por aqui
+                    if width and height and (not include_thumbnail or thumbnail_b64):
+                        break
+                        
+            except:
+                continue  # Tenta próximo range
+        
+        # Fallback final: download completo se necessário
+        if (not width or not height or (include_thumbnail and not thumbnail_b64)):
+            try:
+                del headers['Range']
+                response = await session.get(clean_url, headers=headers, timeout=8.0)
+                if response.status_code == 200 and len(response.content) < 2000000:  # Max 2MB
+                    
+                    if not width or not height:
+                        try:
+                            with Image.open(io.BytesIO(response.content)) as img:
+                                width, height = img.size
+                        except:
+                            pass
+                    
+                    if include_thumbnail and not thumbnail_b64:
+                        loop = asyncio.get_event_loop()
+                        thumbnail_b64 = await loop.run_in_executor(
+                            thumbnail_executor, 
+                            create_thumbnail_cpu_optimized, 
+                            response.content
+                        )
+            except:
+                pass
+    
+    except Exception as e:
+        pass
+    
+    result = {
+        "url": clean_url,
+        "width": width,
+        "height": height
+    }
+    
+    if include_thumbnail:
+        result["thumbnail"] = thumbnail_b64
+    
+    # Cache do resultado (limita tamanho do cache)
+    if len(_url_cache) < _cache_max_size:
+        _url_cache[cache_key] = result.copy()
+    
+    return result
+
+
+async def enrich_images_ultra_fast(images: List[Dict], include_thumbnails: bool = True) -> List[Dict]:
+    """
+    Processamento ultra-paralelo com todas as otimizações modernas
+    """
+    if not images:
+        return []
+    
+    # Configuração HTTP2 otimizada para máxima concorrência
+    connector = httpx.AsyncClient(
+        timeout=httpx.Timeout(10.0),
+        limits=httpx.Limits(
+            max_keepalive_connections=100,  # Muito mais conexões
+            max_connections=150,            # Pool maior
+            keepalive_expiry=30.0          # Mantém conexões por mais tempo
+        ),
+        http2=False  # HTTP/1.1 ainda é mais rápido para muitas conexões pequenas
+    )
+    
+    # Semáforo mais agressivo
+    semaphore = asyncio.Semaphore(30)  # Muito mais concorrência
+    
+    async def process_single_image(image_data):
+        async with semaphore:
+            return await download_and_process_image(connector, image_data["url"], include_thumbnails)
+    
+    try:
+        print(f"Iniciando processamento ultra-paralelo de {len(images)} imagens...")
+        
+        # Cria todas as tasks de uma vez
+        tasks = [process_single_image(img) for img in images]
+        
+        # Processa tudo em paralelo com gather otimizado
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Filtragem rápida
+        valid_results = []
+        for result in results:
+            if not isinstance(result, Exception) and result.get('width') and result.get('height'):
+                valid_results.append(result)
+        
+        success_rate = len(valid_results) / len(images) * 100
+        print(f"Processamento concluído: {len(valid_results)}/{len(images)} ({success_rate:.1f}% sucesso)")
+        
+        return valid_results
+        
+    except Exception as e:
+        print(f"Erro no processamento ultra-rápido: {e}")
+        return []
+    finally:
+        await connector.aclose()
+
+
+# Endpoint adicional otimizado
+@router.get("/thumbnail")
+async def get_thumbnail_fast(
+    url: str = Query(..., description="URL da imagem para gerar miniatura"),
+    size: int = Query(200, description="Tamanho máximo da miniatura em pixels")
+):
+    """
+    Obtém miniatura ultra-rápida de uma imagem específica
+    """
+    try:
+        async with httpx.AsyncClient(timeout=8.0) as client:
+            result = await download_and_process_image(client, url, True)
+            
+            if result.get('thumbnail'):
+                return JSONResponse(content={
+                    "url": result['url'],
+                    "thumbnail": result['thumbnail'],
+                    "dimensions": f"{result.get('width', 0)}x{result.get('height', 0)}",
+                    "size": size
+                })
+            else:
+                raise HTTPException(status_code=500, detail="Erro ao criar miniatura")
+                
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro: {str(e)}")
+
+
+# Cleanup do executor na finalização
+import atexit
+atexit.register(lambda: thumbnail_executor.shutdown(wait=False))

routers/searchterm.py

@@ -0,0 +1,374 @@
+import os
+import re
+import random
+import asyncio
+import httpx
+import aiohttp
+import trafilatura
+import json
+import uuid
+import time
+from pathlib import Path
+from urllib.parse import urlparse
+from typing import List, Dict, Any, Optional
+from fastapi import APIRouter, HTTPException, Body
+from fastapi.responses import FileResponse
+from newspaper import Article
+from threading import Timer
+from google import genai
+from google.genai import types
+
+router = APIRouter()
+
+BRAVE_API_KEY = os.getenv("BRAVE_API_KEY")
+if not BRAVE_API_KEY:
+    raise ValueError("BRAVE_API_KEY não está definido!")
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+if not GEMINI_API_KEY:
+    raise ValueError("GEMINI_API_KEY não está definido!")
+
+BRAVE_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search"
+BRAVE_HEADERS = {
+    "Accept": "application/json",
+    "Accept-Encoding": "gzip",
+    "x-subscription-token": BRAVE_API_KEY
+}
+
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+]
+
+BLOCKED_DOMAINS = {"reddit.com", "www.reddit.com", "old.reddit.com",
+                   "quora.com", "www.quora.com"}
+
+MAX_TEXT_LENGTH = 4000
+
+# Diretório para arquivos temporários
+TEMP_DIR = Path("/tmp")
+TEMP_DIR.mkdir(exist_ok=True)
+
+# Dicionário para controlar arquivos temporários
+temp_files = {}
+
+
+def is_blocked_domain(url: str) -> bool:
+    try:
+        host = urlparse(url).netloc.lower()
+        return any(host == b or host.endswith("." + b) for b in BLOCKED_DOMAINS)
+    except Exception:
+        return False
+
+
+def clamp_text(text: str) -> str:
+    if not text:
+        return ""
+    if len(text) > MAX_TEXT_LENGTH:
+        return text[:MAX_TEXT_LENGTH]
+    return text
+
+
+def get_realistic_headers() -> Dict[str, str]:
+    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.7,pt-BR;q=0.6",
+        "Connection": "keep-alive",
+    }
+
+
+def delete_temp_file(file_id: str, file_path: Path):
+    """Remove arquivo temporário após expiração"""
+    try:
+        if file_path.exists():
+            file_path.unlink()
+        temp_files.pop(file_id, None)
+        print(f"Arquivo temporário removido: {file_path}")
+    except Exception as e:
+        print(f"Erro ao remover arquivo temporário: {e}")
+
+
+def create_temp_file(data: Dict[str, Any]) -> Dict[str, str]:
+    """Cria arquivo temporário e agenda sua remoção"""
+    file_id = str(uuid.uuid4())
+    file_path = TEMP_DIR / f"fontes_{file_id}.txt"
+    
+    # Salva o JSON no arquivo
+    with open(file_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+    
+    # Agenda remoção em 24 horas (86400 segundos)
+    timer = Timer(86400, delete_temp_file, args=[file_id, file_path])
+    timer.start()
+    
+    # Registra o arquivo temporário
+    temp_files[file_id] = {
+        "path": file_path,
+        "created_at": time.time(),
+        "timer": timer
+    }
+    
+    return {
+        "file_id": file_id,
+        "download_url": f"/download-temp/{file_id}",
+        "expires_in_hours": 24
+    }
+
+
+async def generate_search_terms(context: str) -> List[str]:
+    """Gera termos de pesquisa usando o modelo Gemini"""
+    try:
+        client = genai.Client(api_key=GEMINI_API_KEY)
+        model = "gemini-2.5-flash-lite"
+        
+        system_prompt = """Com base num contexto inicial, gere termos de pesquisa (até 20 termos, no máximo), em um JSON. Esses textos devem ser interpretados como termos que podem ser usados por outras inteligências artificiais pra pesquisar no google e retornar resultados mais refinados e completos pra busca atual. Analise muito bem o contexto, por exemplo, se está falando de uma série coreana, gere os termos em coreano por que obviamente na mídia coreana terá mais cobertura que a americana, etc.
+
+Deve seguir esse formato: "terms": []
+
+Retorne apenas o JSON, sem mais nenhum texto."""
+
+        contents = [
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text="Contexto: Taylor Sheridan's 'Landman' Announces Season 2 Premiere Date"),
+                ],
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text='{"terms": [ "imdb landman episodes season 2", "imdb landman series", "landman season 2 release date", "taylor sheridan landman series", "landman season 2 cast sam elliott", "billy bob thornton returns landman", "demi moore landman new season", "andy garcia ali larter landman season 2", "landman texas oil drama", "taylor sheridan tv series schedule", "landman 10 month turnaround new episodes", "landman season 2 november 16 premiere", "sam elliott joins taylor sheridan show", "landman streaming platform premiere", "landman season 2 filming details", "landman new cast and returning actors", "taylor sheridan quick tv show production" ]}'),
+                ],
+            ),
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text="Contexto: Pixar's latest animated feature will arrive on digital (via platforms like Apple TV, Amazon Prime Video, and Fandango at Home) on Aug. 19 and on physical media (4K UHD, Blu-ray and DVD) on Sept. 9. The film has not yet set a Disney+ streaming release date, but that will likely come after the Blu-ray release."),
+                ],
+            ),
+            types.Content(
+                role="model",
+                parts=[
+                    types.Part.from_text(text='{ "terms": [ "pixar elio 2024 movie details", "disney pixar new release elio", "elio animated film august 19 digital", "pixar sci-fi comedy elio home release", "elio movie blu-ray dvd release september", "where to watch elio online", "elio streaming disney plus release date", "elio digital release apple tv amazon prime", "elio physical media 4k uhd blu-ray dvd", "elio movie bonus features", "elio cast voice actors", "elio behind the scenes making of", "elio deleted scenes blu-ray", "elio soundtrack and score", "elio merchandise release date", "upcoming disney pixar movies 2024", "pixar elio critical reviews", "elio movie box office results" ] }'),
+                ],
+            ),
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=f"Contexto: {context}"),
+                ],
+            ),
+        ]
+        
+        generate_content_config = types.GenerateContentConfig(
+            thinking_config=types.ThinkingConfig(
+                thinking_budget=0,
+            ),
+        )
+        
+        # Coletamos toda a resposta em stream
+        full_response = ""
+        for chunk in client.models.generate_content_stream(
+            model=model,
+            contents=contents,
+            config=generate_content_config,
+        ):
+            if chunk.text:
+                full_response += chunk.text
+        
+        # Tenta extrair o JSON da resposta
+        try:
+            # Remove possíveis ```json e ``` da resposta
+            clean_response = full_response.strip()
+            if clean_response.startswith("```json"):
+                clean_response = clean_response[7:]
+            if clean_response.endswith("```"):
+                clean_response = clean_response[:-3]
+            clean_response = clean_response.strip()
+            
+            # Parse do JSON
+            response_data = json.loads(clean_response)
+            terms = response_data.get("terms", [])
+            
+            # Validação básica
+            if not isinstance(terms, list):
+                raise ValueError("Terms deve ser uma lista")
+            
+            return terms[:20]  # Garante máximo de 20 termos
+            
+        except (json.JSONDecodeError, ValueError) as e:
+            print(f"Erro ao parsear resposta do Gemini: {e}")
+            print(f"Resposta recebida: {full_response}")
+            # Retorna uma lista vazia em caso de erro
+            return []
+        
+    except Exception as e:
+        print(f"Erro ao gerar termos de pesquisa: {str(e)}")
+        return []
+
+
+async def search_brave_term(client: httpx.AsyncClient, term: str) -> List[Dict[str, str]]:
+    params = {"q": term, "count": 10, "safesearch": "off", "summary": "false"}
+    
+    try:
+        resp = await client.get(BRAVE_SEARCH_URL, headers=BRAVE_HEADERS, params=params)
+        if resp.status_code != 200:
+            return []
+
+        data = resp.json()
+        results: List[Dict[str, str]] = []
+        
+        if "web" in data and "results" in data["web"]:
+            for item in data["web"]["results"]:
+                url = item.get("url")
+                age = item.get("age", "Unknown")
+                
+                if url and not is_blocked_domain(url):
+                    results.append({"url": url, "age": age})
+
+        return results
+    except Exception:
+        return []
+
+
+async def extract_article_text(url: str, session: aiohttp.ClientSession) -> str:
+    try:
+        art = Article(url)
+        art.config.browser_user_agent = random.choice(USER_AGENTS)
+        art.config.request_timeout = 8
+        art.config.number_threads = 1
+
+        art.download()
+        art.parse()
+        txt = (art.text or "").strip()
+        if txt and len(txt) > 100:
+            return clamp_text(txt)
+    except Exception:
+        pass
+
+    try:
+        await asyncio.sleep(random.uniform(0.1, 0.3))
+        
+        headers = get_realistic_headers()
+        async with session.get(url, headers=headers, timeout=12) as resp:
+            if resp.status != 200:
+                return ""
+                
+            html = await resp.text()
+            
+            if re.search(r"(paywall|subscribe|metered|registration|captcha|access denied)", html, re.I):
+                return ""
+
+            extracted = trafilatura.extract(html) or ""
+            extracted = extracted.strip()
+            if extracted and len(extracted) > 100:
+                return clamp_text(extracted)
+                
+    except Exception:
+        pass
+
+    return ""
+
+
+@router.post("/search-terms")
+async def search_terms(payload: Dict[str, str] = Body(...)) -> Dict[str, Any]:
+    context = payload.get("context")
+    if not context or not isinstance(context, str):
+        raise HTTPException(status_code=400, detail="Campo 'context' é obrigatório e deve ser uma string.")
+    
+    if len(context.strip()) == 0:
+        raise HTTPException(status_code=400, detail="Campo 'context' não pode estar vazio.")
+    
+    # Gera os termos de pesquisa usando o Gemini
+    terms = await generate_search_terms(context)
+    
+    if not terms:
+        raise HTTPException(status_code=500, detail="Não foi possível gerar termos de pesquisa válidos.")
+
+    used_urls = set()
+    search_semaphore = asyncio.Semaphore(20)
+    extract_semaphore = asyncio.Semaphore(50)
+    
+    async def search_with_limit(client, term):
+        async with search_semaphore:
+            return await search_brave_term(client, term)
+    
+    async def process_term(session, term, search_results):
+        async with extract_semaphore:
+            for result in search_results:
+                url = result["url"]
+                age = result["age"]
+                
+                if url in used_urls:
+                    continue
+                    
+                text = await extract_article_text(url, session)
+                if text:
+                    used_urls.add(url)
+                    return {
+                        "term": term,
+                        "age": age,
+                        "url": url,
+                        "text": text
+                    }
+            return None
+
+    connector = aiohttp.TCPConnector(limit=100, limit_per_host=15)
+    timeout = aiohttp.ClientTimeout(total=15)
+    
+    async with httpx.AsyncClient(
+        timeout=15.0, 
+        limits=httpx.Limits(max_connections=100, max_keepalive_connections=25)
+    ) as http_client:
+        async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
+            
+            search_tasks = [search_with_limit(http_client, term) for term in terms]
+            search_results = await asyncio.gather(*search_tasks, return_exceptions=True)
+            
+            process_tasks = []
+            for term, results in zip(terms, search_results):
+                if isinstance(results, list) and results:
+                    process_tasks.append(process_term(session, term, results))
+            
+            if process_tasks:
+                processed_results = await asyncio.gather(*process_tasks, return_exceptions=True)
+                final_results = [r for r in processed_results if r is not None and not isinstance(r, Exception)]
+            else:
+                final_results = []
+
+    # Cria o JSON final
+    result_data = {"results": final_results}
+    
+    # Cria arquivo temporário
+    temp_file_info = create_temp_file(result_data)
+    
+    return {
+        "message": "Dados salvos em arquivo temporário",
+        "total_results": len(final_results),
+        "context": context,
+        "generated_terms": terms,
+        "file_info": temp_file_info
+    }
+
+
+@router.get("/download-temp/{file_id}")
+async def download_temp_file(file_id: str):
+    """Endpoint para download do arquivo temporário"""
+    if file_id not in temp_files:
+        raise HTTPException(status_code=404, detail="Arquivo não encontrado ou expirado")
+    
+    file_info = temp_files[file_id]
+    file_path = file_info["path"]
+    
+    if not file_path.exists():
+        temp_files.pop(file_id, None)
+        raise HTTPException(status_code=404, detail="Arquivo não encontrado")
+    
+    return FileResponse(
+        path=str(file_path),
+        filename="fontes.txt",
+        media_type="text/plain",
+        headers={"Content-Disposition": "attachment; filename=fontes.txt"}
+    )

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)