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>
This commit is contained in:
@@ -0,0 +1,237 @@
|
||||
"""TikTok pela API oficial (Login Kit desktop + Content Posting API).
|
||||
|
||||
OAuth: PKCE S256 com o desafio em HEXADECIMAL (particularidade do TikTok), redirect
|
||||
http://127.0.0.1:4530/oauth/callback/tiktok. Access token vale 2 h; o refresh token vale 180 dias e é ROTATIVO:
|
||||
toda renovação devolve um novo e o antigo morre — por isso o serviço grava o novo sempre (ver service.py).
|
||||
|
||||
Envio por FILE_UPLOAD (PULL_FROM_URL exige domínio verificado). Dois modos:
|
||||
- `direct`: Direct Post (`video.publish`) — antes consulta `creator_info`. Sem auditoria do app só sai SELF_ONLY.
|
||||
- `draft`: vai para a caixa de entrada do app do TikTok (`video.upload`); o usuário termina de publicar no celular.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import time
|
||||
from typing import Callable
|
||||
from urllib.parse import urlencode
|
||||
|
||||
import httpx
|
||||
|
||||
from .base import (JobSpec, Progress, PublishError, PublishResult, Sleep, Tokens, challenge_s256_hex, expires_in,
|
||||
file_size, network_error, response_json)
|
||||
|
||||
AUTH_URL = "https://www.tiktok.com/v2/auth/authorize/"
|
||||
API = "https://open.tiktokapis.com"
|
||||
TOKEN_URL = f"{API}/v2/oauth/token/"
|
||||
SCOPES = "user.info.basic,video.upload,video.publish"
|
||||
|
||||
MB = 1024 * 1024
|
||||
PRIVACY = {"public": "PUBLIC_TO_EVERYONE", "private": "SELF_ONLY",
|
||||
# "Não listado" não existe no TikTok: o mais próximo sem expor o vídeo é "Somente eu".
|
||||
"unlisted": "SELF_ONLY"}
|
||||
|
||||
UNAUDITED = ("O TikTok só permite publicar como privado (Somente eu) até o app ser auditado. "
|
||||
"Use o modo Rascunho ou a Sessão logada.")
|
||||
|
||||
TokenProvider = Callable[[bool], str]
|
||||
|
||||
|
||||
def chunk_plan(size: int, single_max: int = 64 * MB, chunk: int = 32 * MB) -> tuple[int, int]:
|
||||
"""(chunk_size, total_chunk_count) pelas regras do TikTok: até 64 MB vai inteiro; acima, blocos de 5–64 MB em
|
||||
que o último absorve o resto (pode passar do tamanho do bloco, até 128 MB)."""
|
||||
if size <= single_max:
|
||||
return size, 1
|
||||
return chunk, max(1, size // chunk)
|
||||
|
||||
|
||||
def explain(code: str, message: str = "") -> PublishError:
|
||||
if code == "unaudited_client_can_only_post_to_private_accounts":
|
||||
return PublishError(UNAUDITED + " (A conta do TikTok também precisa estar como privada.)")
|
||||
if code == "privacy_level_option_mismatch":
|
||||
return PublishError("A privacidade escolhida não está disponível para esta conta do TikTok. "
|
||||
"Escolha outra no canal de publicação.")
|
||||
if code in ("spam_risk_too_many_posts", "spam_risk_too_many_pending_share", "spam_risk_user_banned_from_posting"):
|
||||
return PublishError("O TikTok bloqueou novos envios por enquanto (limite diário atingido — no modo Rascunho são "
|
||||
"até 5 pendentes por dia). Publique os rascunhos no app ou tente de novo amanhã.")
|
||||
if code == "reached_active_user_cap":
|
||||
return PublishError("O app do TikTok ainda sem auditoria aceita só 5 contas por dia. Tente amanhã.")
|
||||
if code in ("access_token_invalid", "token_not_authorized_for_specified_url"):
|
||||
return PublishError("A autorização do TikTok venceu. Conecte o TikTok de novo em Canais de publicação.", "expired")
|
||||
if code == "scope_not_authorized":
|
||||
return PublishError("Falta permissão no TikTok. Conecte de novo e aceite todas as permissões pedidas.", "expired")
|
||||
if code == "rate_limit_exceeded":
|
||||
return PublishError("O TikTok pediu para ir mais devagar (muitas chamadas por minuto). Tente de novo daqui a pouco.")
|
||||
return PublishError(f"O TikTok recusou o envio ({code or 'erro desconhecido'}). {message}".strip())
|
||||
|
||||
|
||||
def _check(response: httpx.Response) -> dict:
|
||||
body = response_json(response)
|
||||
error = body.get("error") or {}
|
||||
code = str(error.get("code") or "") if isinstance(error, dict) else str(error)
|
||||
if response.status_code >= 400 or (code and code != "ok"):
|
||||
raise explain(code or str(response.status_code), str(error.get("message") or "") if isinstance(error, dict) else "")
|
||||
return body.get("data") or {}
|
||||
|
||||
|
||||
class TikTokApi:
|
||||
# Limites dos blocos (sobrescritos nos testes para não precisar de arquivo de 64 MB).
|
||||
single_max = 64 * MB
|
||||
chunk = 32 * MB
|
||||
poll_s = 5.0
|
||||
poll_max = 180 # ~15 min
|
||||
|
||||
def __init__(self, client: httpx.Client, client_key: str, client_secret: str, redirect_uri: str,
|
||||
sleep: Sleep = time.sleep):
|
||||
self.client, self.client_key, self.client_secret = client, client_key, client_secret
|
||||
self.redirect_uri, self.sleep = redirect_uri, sleep
|
||||
|
||||
# ---------- OAuth
|
||||
def authorize_url(self, state: str, verifier: str) -> str:
|
||||
params = {"client_key": self.client_key, "scope": SCOPES, "response_type": "code",
|
||||
"redirect_uri": self.redirect_uri, "state": state,
|
||||
"code_challenge": challenge_s256_hex(verifier), "code_challenge_method": "S256"}
|
||||
return f"{AUTH_URL}?{urlencode(params)}"
|
||||
|
||||
def _token_request(self, data: dict) -> Tokens:
|
||||
try:
|
||||
response = self.client.post(TOKEN_URL, data={**data, "client_key": self.client_key,
|
||||
"client_secret": self.client_secret},
|
||||
headers={"Content-Type": "application/x-www-form-urlencoded"})
|
||||
except httpx.HTTPError as exc:
|
||||
raise network_error("TikTok", exc) from exc
|
||||
body = response_json(response)
|
||||
if response.status_code >= 400 or body.get("error") or not body.get("access_token"):
|
||||
error = str(body.get("error") or response.status_code)
|
||||
if error in ("invalid_grant", "invalid_request") and data.get("grant_type") == "refresh_token":
|
||||
raise PublishError("A autorização do TikTok expirou. Conecte o TikTok de novo em Canais de publicação.",
|
||||
"expired")
|
||||
if error in ("invalid_client", "unauthorized_client"):
|
||||
raise PublishError("O TikTok recusou o Client Key/Secret do app. Confira em Configurações → Apps das redes.")
|
||||
raise PublishError(f"O TikTok recusou a autorização ({error}). Tente conectar de novo.")
|
||||
return Tokens(body["access_token"], expires_in(body.get("expires_in")), body.get("refresh_token"),
|
||||
expires_in(body.get("refresh_expires_in")), {"openId": body.get("open_id")})
|
||||
|
||||
def exchange_code(self, code: str, verifier: str) -> Tokens:
|
||||
return self._token_request({"code": code, "grant_type": "authorization_code",
|
||||
"redirect_uri": self.redirect_uri, "code_verifier": verifier})
|
||||
|
||||
def refresh(self, refresh_token: str) -> Tokens:
|
||||
# Rotativo: o refresh devolvido substitui o antigo (quem chama grava o novo no cofre na hora).
|
||||
return self._token_request({"grant_type": "refresh_token", "refresh_token": refresh_token})
|
||||
|
||||
def _post(self, path: str, access_token: str, json: dict | None = None) -> dict:
|
||||
try:
|
||||
response = self.client.post(f"{API}{path}", json=json or {}, headers={
|
||||
"Authorization": f"Bearer {access_token}", "Content-Type": "application/json; charset=UTF-8"})
|
||||
except httpx.HTTPError as exc:
|
||||
raise network_error("TikTok", exc) from exc
|
||||
return _check(response)
|
||||
|
||||
def user_info(self, access_token: str) -> tuple[str | None, str | None]:
|
||||
"""(nome de exibição, @usuário). O usuário vem do creator_info (o user.info.basic não traz)."""
|
||||
name = handle = None
|
||||
try:
|
||||
response = self.client.get(f"{API}/v2/user/info/", params={"fields": "open_id,display_name"},
|
||||
headers={"Authorization": f"Bearer {access_token}"})
|
||||
name = ((response_json(response).get("data") or {}).get("user") or {}).get("display_name")
|
||||
except httpx.HTTPError:
|
||||
pass
|
||||
try:
|
||||
info = self.creator_info(access_token)
|
||||
name = name or info.get("creator_nickname")
|
||||
handle = info.get("creator_username")
|
||||
except PublishError:
|
||||
pass
|
||||
return name, (f"@{handle}" if handle and not str(handle).startswith("@") else handle)
|
||||
|
||||
def creator_info(self, access_token: str) -> dict:
|
||||
return self._post("/v2/post/publish/creator_info/query/", access_token)
|
||||
|
||||
# ---------- envio
|
||||
def post_info(self, spec: JobSpec, creator: dict) -> dict:
|
||||
privacy = PRIVACY.get(spec.privacy, "SELF_ONLY")
|
||||
options = list(creator.get("privacy_level_options") or [])
|
||||
if options and privacy not in options:
|
||||
if options == ["SELF_ONLY"]:
|
||||
raise PublishError(UNAUDITED)
|
||||
raise PublishError(f"A privacidade \"{spec.privacy}\" não está disponível nesta conta do TikTok "
|
||||
f"(a conta oferece: {', '.join(options)}). Mude a privacidade no canal de publicação.")
|
||||
return {
|
||||
"title": spec.caption[:2200], "privacy_level": privacy,
|
||||
# Diretriz do TikTok: interações começam DESMARCADAS (o criador escolhe permitir). Sem campo para isso no
|
||||
# contrato do job, ficam desligadas — e desligadas também se o criador já desligou na conta.
|
||||
"disable_comment": True, "disable_duet": True, "disable_stitch": True,
|
||||
"brand_content_toggle": False, "brand_organic_toggle": False,
|
||||
"is_aigc": bool(spec.ai_generated),
|
||||
}
|
||||
|
||||
def upload(self, spec: JobSpec, token: TokenProvider, progress: Progress) -> PublishResult:
|
||||
total = file_size(spec.file)
|
||||
chunk_size, count = chunk_plan(total, self.single_max, self.chunk)
|
||||
source = {"source": "FILE_UPLOAD", "video_size": total, "chunk_size": chunk_size, "total_chunk_count": count}
|
||||
access = token(False)
|
||||
draft = spec.tiktok_mode == "draft"
|
||||
username = None
|
||||
if draft:
|
||||
progress("Abrindo o envio para a caixa de entrada do TikTok…", 0.02)
|
||||
data = self._post("/v2/post/publish/inbox/video/init/", access, {"source_info": source})
|
||||
else:
|
||||
progress("Consultando a conta do TikTok…", 0.01)
|
||||
creator = self.creator_info(access)
|
||||
username = creator.get("creator_username")
|
||||
body = {"post_info": self.post_info(spec, creator), "source_info": source}
|
||||
progress("Abrindo a publicação no TikTok…", 0.03)
|
||||
data = self._post("/v2/post/publish/video/init/", access, body)
|
||||
publish_id, upload_url = data.get("publish_id"), data.get("upload_url")
|
||||
if not publish_id or not upload_url:
|
||||
raise PublishError("O TikTok não devolveu o endereço de envio. Tente de novo daqui a pouco.")
|
||||
|
||||
self._put_chunks(spec, upload_url, total, chunk_size, count, progress)
|
||||
return self._wait(publish_id, token, progress, draft, username, spec.privacy)
|
||||
|
||||
def _put_chunks(self, spec: JobSpec, upload_url: str, total: int, chunk_size: int, count: int,
|
||||
progress: Progress) -> None:
|
||||
with spec.file.open("rb") as handle:
|
||||
for index in range(count):
|
||||
start = index * chunk_size
|
||||
# O último bloco leva o resto do arquivo.
|
||||
length = total - start if index == count - 1 else chunk_size
|
||||
handle.seek(start)
|
||||
data = handle.read(length)
|
||||
end = start + len(data) - 1
|
||||
try:
|
||||
response = self.client.put(upload_url, content=data, headers={
|
||||
"Content-Type": "video/mp4", "Content-Length": str(len(data)),
|
||||
"Content-Range": f"bytes {start}-{end}/{total}"})
|
||||
except httpx.HTTPError as exc:
|
||||
raise network_error("TikTok", exc) from exc
|
||||
if response.status_code not in (200, 201, 206):
|
||||
raise PublishError(f"O TikTok recusou um pedaço do vídeo (código {response.status_code}). "
|
||||
"Tente de novo; se repetir, confira se o vídeo tem até 10 min e 4 GB.")
|
||||
progress(f"Enviando vídeo… {int((end + 1) * 100 / total)}%", 0.05 + 0.8 * (end + 1) / total)
|
||||
|
||||
def _wait(self, publish_id: str, token: TokenProvider, progress: Progress, draft: bool,
|
||||
username: str | None, privacy: str) -> PublishResult:
|
||||
progress("Aguardando o TikTok processar…", 0.88)
|
||||
for _ in range(self.poll_max):
|
||||
data = self._post("/v2/post/publish/status/fetch/", token(False), {"publish_id": publish_id})
|
||||
status = data.get("status")
|
||||
if status == "FAILED":
|
||||
reason = str(data.get("fail_reason") or "")
|
||||
raise explain(reason, "O TikTok não conseguiu processar o vídeo.")
|
||||
if draft and status == "SEND_TO_USER_INBOX":
|
||||
return PublishResult(publish_id, None, True,
|
||||
"Enviado para a caixa de entrada do TikTok: abra o app para revisar e publicar")
|
||||
if status == "PUBLISH_COMPLETE":
|
||||
# (sic) o campo da API é "publicaly_available_post_id".
|
||||
posts = data.get("publicaly_available_post_id") or []
|
||||
if posts and username:
|
||||
post = str(posts[0])
|
||||
return PublishResult(post, f"https://www.tiktok.com/@{username}/video/{post}", False, "Publicado no TikTok")
|
||||
if PRIVACY.get(privacy) == "SELF_ONLY":
|
||||
return PublishResult(publish_id, None, False, "Publicado no TikTok como privado (Somente eu)")
|
||||
return PublishResult(str(posts[0]) if posts else publish_id, None, False,
|
||||
"Publicado no TikTok; o link ainda não apareceu (confira no app)")
|
||||
self.sleep(self.poll_s)
|
||||
raise PublishError("O TikTok demorou demais para processar o vídeo. Confira no app antes de tentar de novo "
|
||||
"(pode ter publicado).")
|
||||
Reference in New Issue
Block a user