Files
CenaForge/publisher/app/platforms/tiktok_api.py
T
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

238 lines
14 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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).")