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>
178 lines
8.8 KiB
Python
178 lines
8.8 KiB
Python
"""Executa conferência de sessão e envios no navegador do perfil (Playwright conectado por CDP).
|
|
|
|
Ciclo da janela (para a porta de depuração ficar aberta o mínimo):
|
|
- "Conectar"/"Entrar de novo": abre a janela na página de login e deixa o usuário entrar (fecha sozinha após 15 min
|
|
ociosa);
|
|
- "Já entrei" (check): conferiu que está logado ⇒ fecha a janela (os cookies ficam no perfil); não está ⇒ deixa
|
|
aberta para o usuário terminar o login;
|
|
- envio: abre, envia e fecha. Se a rede pedir login/captcha, deixa aberta para o usuário resolver.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import threading
|
|
import time
|
|
from contextlib import contextmanager
|
|
from pathlib import Path
|
|
from typing import Any, Callable
|
|
|
|
from ..base import JobSpec, Progress, PublishError, PublishResult, Sleep
|
|
from . import instagram_web, tiktok_studio, youtube_studio
|
|
from .browser import BrowserManager
|
|
from .common import Uploader, screenshot
|
|
|
|
UPLOADERS: dict[str, Uploader] = {
|
|
"youtube": youtube_studio.UPLOADER,
|
|
"tiktok": tiktok_studio.UPLOADER,
|
|
"instagram": instagram_web.UPLOADER,
|
|
}
|
|
|
|
# Onde o usuário faz o login à mão (a janela abre aqui).
|
|
LOGIN_URLS = {
|
|
"youtube": "https://studio.youtube.com/",
|
|
"tiktok": "https://www.tiktok.com/login",
|
|
"instagram": "https://www.instagram.com/accounts/login/",
|
|
}
|
|
|
|
|
|
def browser_error_text(detail: str) -> str:
|
|
"""Frase em pt-BR para um erro do Playwright (o detalhe técnico vai junto, depois)."""
|
|
if "larger than 50Mb" in detail:
|
|
return "O navegador recusou o arquivo do vídeo por ser grande demais para a conexão atual. Reinicie o pnpm dev."
|
|
if "Timeout" in detail and ".click" in detail:
|
|
return ("Um botão ou campo da página não respondeu ao clique a tempo — em geral um aviso do site aberto por "
|
|
"cima, ou o site mudou de layout. Veja a captura e tente de novo.")
|
|
if "Timeout" in detail:
|
|
return "A página demorou demais para responder. Confira a internet e a janela, e tente de novo."
|
|
if "Target page, context or browser has been closed" in detail or "has been closed" in detail:
|
|
return "A janela do navegador foi fechada no meio do envio. Deixe a janela aberta e tente de novo."
|
|
return "O navegador travou ou mudou de página no meio do envio. Confira a janela e tente de novo."
|
|
|
|
|
|
class SessionRunner:
|
|
def __init__(self, browsers: BrowserManager, logs_dir: Path, sleep: Sleep = time.sleep):
|
|
self.browsers = browsers
|
|
self.logs_dir = logs_dir
|
|
self.sleep = sleep
|
|
# Uma ação de navegador por vez (conferência e envio não se atropelam).
|
|
self.lock = threading.Lock()
|
|
|
|
@contextmanager
|
|
def _busy_guard(self, wait_s: float):
|
|
if not self.lock.acquire(timeout=wait_s):
|
|
raise PublishError("O navegador do Publicador está ocupado com um envio agora. Espere terminar e tente de novo.")
|
|
try:
|
|
yield
|
|
finally:
|
|
self.lock.release()
|
|
|
|
def open_for_login(self, profile_id: str, platform: str) -> None:
|
|
url = LOGIN_URLS[platform]
|
|
was_open = self.browsers.is_open(profile_id)
|
|
port = self.browsers.open(profile_id, url, for_login=True)
|
|
if was_open: # janela já aberta: abre uma aba na página de login e traz para a frente
|
|
with self._busy_guard(3), self.browsers.in_use(profile_id):
|
|
self._with_page(port, lambda page: (page.goto(url), page.bring_to_front()), keep_page=True,
|
|
label=f"{platform}-{profile_id}-abrir")
|
|
|
|
def check(self, profile_id: str, platform: str) -> str | None:
|
|
"""None = sessão válida (e a janela é fechada); texto = motivo para entrar de novo (janela fica aberta)."""
|
|
uploader = UPLOADERS[platform]
|
|
holder: dict[str, Any] = {}
|
|
with self._busy_guard(5):
|
|
port = self.browsers.open(profile_id, uploader.upload_url, for_login=True)
|
|
with self.browsers.in_use(profile_id):
|
|
def run(page: Any) -> None:
|
|
holder["reason"] = uploader.check(page, self.sleep)
|
|
|
|
self._with_page(port, run, keep_page=lambda: holder.get("reason") is not None,
|
|
label=f"{platform}-{profile_id}-check")
|
|
if holder.get("reason") is None:
|
|
self.browsers.close(profile_id)
|
|
return holder.get("reason")
|
|
|
|
def publish(self, spec: JobSpec, progress: Progress) -> PublishResult:
|
|
uploader = UPLOADERS[spec.platform]
|
|
holder: dict[str, Any] = {}
|
|
with self.lock:
|
|
port = self.browsers.open(spec.profile_id, uploader.upload_url)
|
|
keep_window = False
|
|
try:
|
|
with self.browsers.in_use(spec.profile_id):
|
|
def run(page: Any) -> None:
|
|
holder["result"] = uploader.upload(page, spec, progress, self.sleep)
|
|
|
|
self._with_page(port, run, keep_page=lambda: "result" not in holder,
|
|
label=f"{spec.platform}-{spec.job_id}")
|
|
except PublishError as exc:
|
|
# Login/captcha: a janela fica para o usuário resolver (fecha sozinha se ficar ociosa).
|
|
keep_window = exc.kind == "needs_login"
|
|
raise
|
|
finally:
|
|
if not keep_window:
|
|
self.browsers.close(spec.profile_id)
|
|
return holder["result"]
|
|
|
|
def read_stats(self, profile_id: str, platform: str, ids: list[str]) -> dict[str, Any]:
|
|
"""Números dos posts pela janela logada (só lê). Espera até 2 min um envio em andamento terminar.
|
|
Fecha a janela no fim, a não ser que ela já estivesse aberta antes (o usuário pode estar usando)."""
|
|
from .stats import READERS
|
|
|
|
url, reader = READERS[platform]
|
|
holder: dict[str, Any] = {}
|
|
with self._busy_guard(120):
|
|
was_open = self.browsers.is_open(profile_id)
|
|
port = self.browsers.open(profile_id, url)
|
|
try:
|
|
with self.browsers.in_use(profile_id):
|
|
def run(page: Any) -> None:
|
|
holder["stats"] = reader(page, ids, self.sleep)
|
|
|
|
self._with_page(port, run, keep_page=False, label=f"{platform}-{profile_id}-numeros")
|
|
finally:
|
|
if not was_open:
|
|
self.browsers.close(profile_id)
|
|
return holder.get("stats", {})
|
|
|
|
def _with_page(self, port: int, fn: Callable[[Any], Any], keep_page: bool | Callable[[], bool], label: str) -> None:
|
|
try:
|
|
from playwright.sync_api import Error as PlaywrightError
|
|
from playwright.sync_api import sync_playwright
|
|
except ImportError as exc: # pragma: no cover - depende da venv
|
|
raise PublishError("O Playwright não está instalado no Publicador. Rode o setup.bat de novo.") from exc
|
|
with sync_playwright() as pw:
|
|
try:
|
|
# is_local: o Chrome roda NESTE computador (127.0.0.1, a porta é conferida como nossa). Sem isso o
|
|
# Playwright trata o navegador como remoto e recusa enviar arquivo > 50 MB ("Cannot transfer files
|
|
# larger than 50Mb to a browser not co-located with the server") — e os cortes passam de 100 MB.
|
|
browser = pw.chromium.connect_over_cdp(f"http://127.0.0.1:{port}", timeout=15000, is_local=True)
|
|
except PlaywrightError as exc:
|
|
raise PublishError("Não consegui me conectar à janela do navegador. Feche a janela do perfil e tente "
|
|
"de novo.") from exc
|
|
context = browser.contexts[0] if browser.contexts else browser.new_context()
|
|
page = context.new_page()
|
|
page.set_default_timeout(30000)
|
|
keep = True
|
|
try:
|
|
fn(page)
|
|
keep = keep_page() if callable(keep_page) else keep_page
|
|
except PublishError as exc:
|
|
# Sem captura em login/captcha/verificação (a tela pode ter dados pessoais); só em falha comum.
|
|
if exc.kind == "failed":
|
|
shot = screenshot(page, self.logs_dir, label)
|
|
if shot:
|
|
exc.message += f" (Captura: {shot.name})"
|
|
exc.args = (exc.message,)
|
|
raise
|
|
except PlaywrightError as exc:
|
|
shot = screenshot(page, self.logs_dir, label)
|
|
raise PublishError(f"{browser_error_text(str(exc))}{f' (Captura: {shot.name})' if shot else ''} "
|
|
f"Detalhe: {str(exc)[:160]}") from exc
|
|
finally:
|
|
if not keep:
|
|
try:
|
|
page.close()
|
|
except PlaywrightError:
|
|
pass
|
|
# Aqui só desconectamos; quem fecha a janela (quando deve) é o BrowserManager.close, fora deste bloco.
|