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>
204 lines
8.9 KiB
Python
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]
|