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