Files
MateuusandClaude Opus 5.5 84f30bbc2d CenaForge: primeira versão pública
Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz,
Clipador de lives e Publicador para YouTube, TikTok e Instagram.

Inclui a leitura das visualizações dos posts para o Dashboard e o botão
"Publicar no <rede>" nos cartões das publicações.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 16:35:09 -03:00

204 lines
8.9 KiB
Python

"""Peças comuns aos uploaders do modo sessão (YouTube Studio, TikTok Studio, Instagram web).
Regras invioláveis (doc/publicacao/PLANO.md §2):
- navegador VISÍVEL; o usuário faz login À MÃO; nunca digitar senha, nunca resolver captcha;
- nada de stealth/patchright/stealth.js nem qualquer burla de detecção;
- página de login, captcha, "confirme que é você"/checkpoint ⇒ PARAR com `needs_login` e avisar o usuário;
- intervalo mínimo entre envios: pausas curtas entre passos e um envio por vez (o worker garante um job por vez).
É só ritmo para não sobrecarregar a conta — não é tentativa de imitar uma pessoa nem de esconder a automação.
Seletores: cada rede tem um dicionário `SELECTORS` no próprio arquivo, com candidatos em PT e EN, do mais
estável (role/label/atributo) ao menos estável (texto). Quando a rede mudar a tela, é só ali que se corrige.
"""
from __future__ import annotations
import random
import re
import time
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from typing import Any, Callable, Iterable
from ..base import JobSpec, Progress, PublishError, PublishResult, Sleep
# Um candidato de seletor: (estratégia, valor[, nome]). Estratégias:
# ("role", "button", r"regex do nome acessível") ("label", r"regex") ("placeholder", r"regex")
# ("text", r"regex") ("css", "seletor CSS")
Candidate = tuple
def locate(page: Any, candidate: Candidate) -> Any:
kind = candidate[0]
if kind == "role":
return page.get_by_role(candidate[1], name=re.compile(candidate[2], re.I))
if kind == "label":
return page.get_by_label(re.compile(candidate[1], re.I))
if kind == "placeholder":
return page.get_by_placeholder(re.compile(candidate[1], re.I))
if kind == "text":
return page.get_by_text(re.compile(candidate[1], re.I))
if kind == "css":
return page.locator(candidate[1])
raise ValueError(f"estratégia de seletor desconhecida: {kind}")
def find(page: Any, candidates: Iterable[Candidate], timeout_s: float = 10, visible: bool = True,
sleep: Sleep = time.sleep) -> Any | None:
"""Primeiro candidato que aparece na tela dentro do prazo (ou None). `visible=False` aceita elemento oculto
(ex.: <input type=file>)."""
candidates = list(candidates)
deadline = time.time() + timeout_s
while True:
for candidate in candidates:
try:
matches = locate(page, candidate)
total = matches.count()
if total and not visible:
return matches.first
# A 1ª ocorrência pode ser uma cópia escondida (Instagram, 17/11/2026: botão "Original" do formato):
# olha as primeiras até achar uma visível.
for i in range(min(total, 6)):
if matches.nth(i).is_visible():
return matches.nth(i)
except Exception: # noqa: BLE001 - página navegando no meio da busca: tenta de novo
continue
if time.time() >= deadline:
return None
sleep(0.5)
def require(page: Any, candidates: Iterable[Candidate], what: str, timeout_s: float = 15, visible: bool = True,
sleep: Sleep = time.sleep) -> Any:
found = find(page, candidates, timeout_s, visible, sleep)
if found is None:
raise PublishError(f"Não achei {what} na página. O site pode ter mudado de layout; veja a captura de tela em "
"data/publisher/logs/ e avise para ajustarmos os seletores.")
return found
def step_pause(sleep: Sleep = time.sleep, low: float = 0.8, high: float = 2.2) -> None:
sleep(random.uniform(low, high))
# Avisos de novidade/dica que as redes abrem por cima da página e que bloqueiam os cliques (ex.: TikTok Studio,
# 17/11/2026: "Veja a prévia do seu vídeo no seu celular" → "Entendi"). SÓ botões de "entendi": fechar um aviso
# desses não muda nada no post. Nunca aceitar/recusar opções (verificação de conteúdo, música, etc.) por aqui.
TIP_BUTTONS: list[Candidate] = [("role", "button", r"^(Entendi|Entendido|Ok, entendi|Got it)$")]
def dismiss_tips(page: Any, sleep: Sleep = time.sleep, rounds: int = 3) -> int:
"""Fecha os avisos de novidade abertos (até `rounds`). Devolve quantos fechou."""
closed = 0
for _ in range(rounds):
button = find(page, TIP_BUTTONS, timeout_s=0.5, sleep=sleep)
if button is None:
break
try:
button.click(timeout=3000)
except Exception: # noqa: BLE001 - o aviso sumiu sozinho
break
closed += 1
step_pause(sleep, 0.3, 0.8)
return closed
def click_through(locator: Any, sleep: Sleep = time.sleep, timeout_ms: float = 8000) -> None:
"""Clica; se algo cobrir o elemento (aviso de novidade), fecha os avisos e tenta mais uma vez."""
try:
locator.click(timeout=timeout_ms)
return
except Exception: # noqa: BLE001 - quase sempre um aviso por cima; se não for, o segundo clique mostra o erro
if not dismiss_tips(locator.page, sleep):
raise
locator.click(timeout=timeout_ms)
def caption_key(caption: str, size: int = 24) -> str:
"""Começo da legenda sem hashtags/menções: é o que aparece primeiro nas listas/páginas da rede. Serve para achar
o vídeo recém-publicado sem nunca pegar o link de outro."""
words = [w for w in (caption or "").split() if not w.startswith(("#", "@"))]
return " ".join(words)[:size].strip()
def fill_text(locator: Any, text: str, sleep: Sleep = time.sleep) -> None:
"""Escreve num campo (inclusive contenteditable): foca, limpa e insere o texto como um colar."""
click_through(locator, sleep)
step_pause(sleep, 0.3, 0.8)
page = locator.page
page.keyboard.press("Control+A")
page.keyboard.press("Delete")
step_pause(sleep, 0.2, 0.5)
page.keyboard.insert_text(text)
step_pause(sleep, 0.4, 1.0)
# Sinais universais de que é preciso a pessoa agir (login, captcha, verificação de identidade).
BLOCK_URL = re.compile(r"(/login|/signin|/accounts/login|ServiceLogin|/challenge|checkpoint|captcha|/verify)", re.I)
BLOCK_TEXT: list[Candidate] = [
("css", "iframe[src*='captcha'], iframe[title*='captcha' i], #captcha-verify-container, .captcha_verify_container"),
("text", r"^(Verifique|Verify|Confirme|Confirm)( que)? (é você|it's you|you're human|you are human)"),
("text", r"(Arraste o controle|Drag the slider|Selecione todas as imagens|Select all images)"),
("text", r"(Este navegador ou app pode não ser seguro|This browser or app may not be secure)"),
]
def detect_block(page: Any, login_candidates: Iterable[Candidate] = ()) -> str | None:
"""Motivo (pt-BR) se a página pede login/captcha/verificação; None se está liberada."""
url = str(getattr(page, "url", "") or "")
if BLOCK_URL.search(url):
return "a rede pediu para entrar na conta de novo"
if find(page, BLOCK_TEXT, timeout_s=0, visible=True) is not None:
return "a rede pediu uma verificação (captcha ou \"confirme que é você\")"
if find(page, login_candidates, timeout_s=0, visible=True) is not None:
return "a rede mostrou a tela de login"
return None
def needs_login(reason: str) -> PublishError:
return PublishError(f"É preciso entrar de novo: {reason}. Clique em \"Entrar de novo\", faça o login (e a "
"verificação, se aparecer) na janela que abrir e depois clique em \"Já entrei\".", "needs_login")
SCREENSHOT_KEEP_DAYS = 7
def screenshot(page: Any, logs_dir: Path, name: str) -> Path | None:
"""Captura só a área VISÍVEL (nada de página inteira) para diagnosticar seletor quebrado. Quem chama não captura
telas de login/captcha/verificação (podem mostrar dados pessoais)."""
try:
if detect_block(page) is not None:
return None
logs_dir.mkdir(parents=True, exist_ok=True)
path = logs_dir / f"{datetime.now():%Y%m%d-%H%M%S}-{name}.png"
page.screenshot(path=str(path), full_page=False)
return path
except Exception: # noqa: BLE001 - a captura é ajuda de diagnóstico; não pode mascarar o erro real
return None
def prune_screenshots(logs_dir: Path, keep_days: float = SCREENSHOT_KEEP_DAYS) -> int:
"""Apaga capturas com mais de `keep_days` dias (roda na subida do serviço). Devolve quantas apagou."""
if not logs_dir.is_dir():
return 0
limit = time.time() - keep_days * 86400
removed = 0
for path in logs_dir.glob("*.png"):
try:
if path.stat().st_mtime < limit:
path.unlink()
removed += 1
except OSError:
continue
return removed
@dataclass
class Uploader:
"""Contrato de cada rede no modo sessão."""
platform: str
upload_url: str
check: Callable[[Any, Sleep], str | None] # página → motivo do bloqueio ou None (logado)
upload: Callable[[Any, JobSpec, Progress, Sleep], PublishResult]