"""Tipos comuns aos envios (API oficial e sessão logada).""" from __future__ import annotations import base64 import hashlib import os import secrets import time from dataclasses import dataclass, field from pathlib import Path from typing import Callable, Literal import httpx # Callback de progresso: (texto curto em pt-BR para a UI, fração 0..1). Progress = Callable[[str, float], None] Sleep = Callable[[float], None] PLATFORMS = ("youtube", "tiktok", "instagram") class PublishError(Exception): """Falha que o usuário precisa ler. `kind`: 'failed' (erro comum), 'needs_login' (entrar de novo) ou 'expired' (a autorização da API venceu: conectar de novo). A mensagem já sai em pt-BR, sem jargão.""" def __init__(self, message: str, kind: Literal["failed", "needs_login", "expired"] = "failed"): super().__init__(message) self.message = message self.kind = kind @dataclass class JobSpec: """O que o worker entrega ao uploader (vem do JobInput do contrato).""" job_id: str profile_id: str platform: str file: Path cover: Path | None title: str caption: str tags: list[str] = field(default_factory=list) privacy: str = "public" publish_at: str | None = None ai_generated: bool = False made_for_kids: bool = False tiktok_mode: str = "direct" @dataclass class PublishResult: remote_id: str | None url: str | None draft: bool = False # Texto final para a UI ("Publicado", "Enviado para a caixa de entrada do TikTok"…). step: str = "Publicado" @dataclass class Tokens: access_token: str access_expires_at: float | None # epoch (s) refresh_token: str | None = None refresh_expires_at: float | None = None # epoch (s); None = sem prazo conhecido extra: dict = field(default_factory=dict) def to_vault(self) -> dict: return {"accessToken": self.access_token, "accessExpiresAt": self.access_expires_at, "refreshToken": self.refresh_token, "refreshExpiresAt": self.refresh_expires_at, **self.extra} # ---------- PKCE (RFC 7636) def make_verifier() -> str: # 64 caracteres do alfabeto "unreserved" (A-Z a-z 0-9 - _): dentro dos 43–128 exigidos. return secrets.token_urlsafe(48)[:64] def challenge_s256_base64url(verifier: str) -> str: """Desafio padrão do RFC (Google): base64url sem `=` do SHA-256.""" digest = hashlib.sha256(verifier.encode("ascii")).digest() return base64.urlsafe_b64encode(digest).rstrip(b"=").decode("ascii") def challenge_s256_hex(verifier: str) -> str: """Desafio do TikTok (Login Kit desktop): o SHA-256 em HEXADECIMAL, não base64url. Diferente do RFC de propósito — é assim que a documentação do TikTok pede, e o desafio em base64url é recusado.""" return hashlib.sha256(verifier.encode("ascii")).hexdigest() # ---------- utilidades def iter_chunks(path: Path, sizes: list[int]): """Lê o arquivo em blocos de tamanhos dados (o último pode ser maior).""" with path.open("rb") as handle: offset = 0 for size in sizes: data = handle.read(size) yield offset, data offset += len(data) def file_size(path: Path) -> int: return os.path.getsize(path) def expires_in(seconds: object) -> float | None: try: return time.time() + float(seconds) # type: ignore[arg-type] except (TypeError, ValueError): return None def response_json(response: httpx.Response) -> dict: try: data = response.json() except ValueError: return {} return data if isinstance(data, dict) else {} def network_error(name: str, exc: Exception) -> PublishError: return PublishError(f"Não consegui falar com o {name} (internet caiu ou o site está fora do ar). " f"Tente de novo daqui a pouco. Detalhe: {type(exc).__name__}")