"""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.: ).""" 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]