marqetive-lib 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

marqetive/platforms/tiktok/exceptions.py

@@ -0,0 +1,180 @@
+"""TikTok-specific exception handling and error code mapping.
+
+This module provides error handling for the TikTok API, including HTTP status
+code mapping, TikTok-specific error codes, and user-friendly messages.
+"""
+
+from typing import Any
+
+from src.marqetive.platforms.exceptions import (
+    MediaUploadError,
+    PlatformAuthError,
+    PlatformError,
+    PostNotFoundError,
+    RateLimitError,
+    ValidationError,
+)
+
+
+# TikTok API error codes (hypothetical, based on common API patterns)
+# Source: TikTok Developer documentation (assumed)
+class TikTokErrorCode:
+    """TikTok API error codes."""
+
+    # Authentication & Authorization
+    INVALID_ACCESS_TOKEN = 10001
+    ACCESS_TOKEN_EXPIRED = 10002
+    SCOPE_NOT_AUTHORIZED = 10003
+    AUTHENTICATION_FAILED = 10004
+    ACCOUNT_NOT_AUTHORIZED = 10005
+
+    # Rate Limiting
+    RATE_LIMIT_EXCEEDED = 20001
+    TOO_MANY_REQUESTS = 20002
+
+    # Resource Not Found
+    VIDEO_NOT_FOUND = 30001
+    USER_NOT_FOUND = 30002
+    COMMENT_NOT_FOUND = 30003
+
+    # Validation Errors
+    INVALID_PARAMETER = 40001
+    VIDEO_TOO_LARGE = 40002
+    VIDEO_DURATION_INVALID = 40003
+    DESCRIPTION_TOO_LONG = 40004
+    DUPLICATE_VIDEO = 40005
+    INVALID_VIDEO_FORMAT = 40006
+
+    # Media Upload & Processing
+    UPLOAD_FAILED = 50001
+    INIT_UPLOAD_FAILED = 50002
+    APPEND_CHUNK_FAILED = 50003
+    FINALIZE_UPLOAD_FAILED = 50004
+    MEDIA_PROCESSING_FAILED = 50005
+
+
+# Mapping of error codes to user-friendly messages
+ERROR_MESSAGES: dict[int, str] = {
+    # Authentication
+    10001: "Invalid access token. Please re-authenticate.",
+    10002: "Access token has expired. Please refresh the token.",
+    10003: "The application is not authorized for the requested scope.",
+    10004: "Authentication failed. Please check your credentials.",
+    10005: "The user has not authorized this action for their account.",
+    # Rate Limiting
+    20001: "Rate limit exceeded. Please wait before making more requests.",
+    20002: "Too many requests. You have hit a rate limit.",
+    # Resource Not Found
+    30001: "The requested video could not be found.",
+    30002: "The specified user does not exist.",
+    30003: "The specified comment could not be found.",
+    # Validation
+    40001: "Invalid parameter in request.",
+    40002: "Video file size is too large.",
+    40003: "Video duration is outside the allowed range.",
+    40004: "Video description is too long.",
+    40005: "This video appears to be a duplicate of a previous post.",
+    40006: "Invalid video format. Please use a supported format like MP4 or MOV.",
+    # Media
+    50001: "Media upload failed.",
+    50005: "Media processing failed after upload.",
+}
+
+
+def map_tiktok_error(
+    status_code: int | None,
+    error_code: int | None = None,
+    error_message: str | None = None,
+    response_data: dict[str, Any] | None = None,
+) -> PlatformError:
+    """Map TikTok API error to the appropriate exception class.
+
+    Args:
+        status_code: HTTP status code.
+        error_code: TikTok-specific error code from the response body.
+        error_message: Error message from the API.
+        response_data: Full response data from the API.
+
+    Returns:
+        An appropriate subclass of PlatformError.
+    """
+    if response_data and "error" in response_data:
+        error_data = response_data["error"]
+        if not error_code:
+            error_code = error_data.get("code")
+        if not error_message:
+            error_message = error_data.get("message")
+
+    friendly_message = ERROR_MESSAGES.get(
+        error_code or 0, error_message or "An unknown TikTok API error occurred"
+    )
+
+    # Map to exception types based on error code categories or status code
+    if error_code in (10001, 10002, 10003, 10004, 10005) or status_code in (401, 403):
+        return PlatformAuthError(
+            friendly_message,
+            platform="tiktok",
+            status_code=status_code,
+        )
+
+    if error_code in (20001, 20002) or status_code == 429:
+        retry_after = None
+        if response_data and response_data.get("extra"):
+            retry_after = response_data["extra"].get("log_id")  # Placeholder
+        return RateLimitError(
+            friendly_message,
+            platform="tiktok",
+            status_code=status_code or 429,
+            retry_after=retry_after,
+        )
+
+    if error_code in (30001,):
+        return PostNotFoundError(
+            post_id="",  # TikTok might use a different identifier
+            platform="tiktok",
+            status_code=status_code,
+            message=friendly_message,
+        )
+
+    if error_code in (40001, 40002, 40003, 40004, 40005, 40006):
+        return ValidationError(
+            friendly_message,
+            platform="tiktok",
+        )
+
+    if error_code in (50001, 50002, 50003, 50004, 50005):
+        return MediaUploadError(
+            friendly_message,
+            platform="tiktok",
+            status_code=status_code,
+        )
+
+    # Generic platform error for everything else
+    return PlatformError(
+        friendly_message,
+        platform="tiktok",
+        status_code=status_code,
+    )
+
+
+class TikTokAPIError(PlatformError):
+    """TikTok API specific error with detailed information."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        error_code: int | None = None,
+        response_data: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(message, platform="tiktok", status_code=status_code)
+        self.error_code = error_code
+        self.response_data = response_data
+
+    def __repr__(self) -> str:
+        return (
+            f"TikTokAPIError(message={self.message!r}, "
+            f"status_code={self.status_code}, "
+            f"error_code={self.error_code})"
+        )

marqetive/platforms/tiktok/factory.py

@@ -0,0 +1,188 @@
+"""TikTok account factory for managing credentials and client creation."""
+
+import logging
+import os
+from collections.abc import Callable
+from datetime import datetime, timedelta
+
+from src.marqetive.core.account_factory import BaseAccountFactory
+from src.marqetive.platforms.exceptions import PlatformAuthError
+from src.marqetive.platforms.models import AccountStatus, AuthCredentials
+from src.marqetive.platforms.tiktok.client import TikTokClient
+from src.marqetive.utils.oauth import fetch_tiktok_token, refresh_tiktok_token
+
+logger = logging.getLogger(__name__)
+
+
+class TikTokAccountFactory(BaseAccountFactory):
+    """Factory for creating and managing TikTok accounts and clients.
+
+    This factory handles the instantiation of TikTokClients, manages OAuth
+    credentials, and provides a mechanism for token refreshing.
+    """
+
+    def __init__(
+        self,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        on_status_update: Callable[[str, AccountStatus], None] | None = None,
+    ) -> None:
+        """Initialize TikTok account factory.
+
+        Args:
+            client_id: TikTok App client ID (uses TIKTOK_CLIENT_ID env if None).
+            client_secret: TikTok App client secret (uses TIKTOK_CLIENT_SECRET env if None).
+            on_status_update: Optional callback when account status changes.
+        """
+        super().__init__(on_status_update=on_status_update)
+        self.client_id = client_id or os.getenv("TIKTOK_CLIENT_ID")
+        self.client_secret = client_secret or os.getenv("TIKTOK_CLIENT_SECRET")
+
+        if not self.client_id or not self.client_secret:
+            logger.warning(
+                "TikTok client_id/client_secret not provided. "
+                "Token refresh may not work."
+            )
+
+    @property
+    def platform_name(self) -> str:
+        """Get the platform name."""
+        return "tiktok"
+
+    async def get_credentials_from_auth_code(
+        self,
+        auth_code: str,
+        redirect_uri: str,
+        code_verifier: str | None = None,
+    ) -> AuthCredentials:
+        """Get credentials from an authorization code.
+
+        This method exchanges an authorization code for an access token and
+        formats it into the standard AuthCredentials object.
+
+        Args:
+            auth_code: The authorization code received from TikTok.
+            redirect_uri: The redirect URI used in the initial auth request.
+            code_verifier: The PKCE code verifier, if used.
+
+        Returns:
+            An AuthCredentials object for the user.
+
+        Raises:
+            PlatformAuthError: If the token exchange fails.
+        """
+        if not self.client_id or not self.client_secret:
+            raise PlatformAuthError(
+                "TikTok client_id and client_secret are required.",
+                platform=self.platform_name,
+            )
+
+        token_data = await fetch_tiktok_token(
+            code=auth_code,
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            redirect_uri=redirect_uri,
+            code_verifier=code_verifier,
+        )
+
+        expires_at = None
+        if "expires_in" in token_data:
+            expires_at = datetime.now() + timedelta(seconds=token_data["expires_in"])
+
+        refresh_expires_at = None
+        if "refresh_expires_in" in token_data:
+            refresh_expires_at = datetime.now() + timedelta(
+                seconds=token_data["refresh_expires_in"]
+            )
+
+        credentials = AuthCredentials(
+            platform=self.platform_name,
+            access_token=token_data["access_token"],
+            refresh_token=token_data.get("refresh_token"),
+            expires_at=expires_at,
+            scope=token_data.get("scope", []),
+            additional_data={
+                "open_id": token_data["open_id"],
+                "token_type": token_data.get("token_type"),
+                "refresh_expires_at": refresh_expires_at,
+            },
+        )
+        return credentials
+
+    async def refresh_token(self, credentials: AuthCredentials) -> AuthCredentials:
+        """Refresh a TikTok OAuth2 access token.
+
+        Args:
+            credentials: The current credentials containing the refresh token.
+
+        Returns:
+            Updated credentials with a new access token.
+
+        Raises:
+            PlatformAuthError: If refresh fails or credentials are missing.
+        """
+        if not self.client_id or not self.client_secret:
+            raise PlatformAuthError(
+                "TikTok client_id and client_secret are required for token refresh.",
+                platform=self.platform_name,
+            )
+
+        if not credentials.refresh_token:
+            raise PlatformAuthError(
+                "No refresh token available for TikTok.", platform=self.platform_name
+            )
+
+        logger.info("Refreshing TikTok access token...")
+        # This function would call the actual TikTok token refresh endpoint
+        return await refresh_tiktok_token(
+            credentials, self.client_id, self.client_secret
+        )
+
+    async def create_client(self, credentials: AuthCredentials) -> TikTokClient:
+        """Create a TikTok API client.
+
+        Args:
+            credentials: Valid TikTok authentication credentials.
+
+        Returns:
+            An instance of TikTokClient.
+
+        Raises:
+            PlatformAuthError: If credentials are incomplete or invalid.
+        """
+        if not credentials.access_token:
+            raise PlatformAuthError(
+                "Access token is required for TikTok.", platform=self.platform_name
+            )
+        if (
+            not credentials.additional_data
+            or "open_id" not in credentials.additional_data
+        ):
+            raise PlatformAuthError(
+                "'open_id' must be provided in additional_data for TikTok.",
+                platform=self.platform_name,
+            )
+
+        return TikTokClient(credentials=credentials)
+
+    async def validate_credentials(self, credentials: AuthCredentials) -> bool:
+        """Validate TikTok credentials by making a test API call.
+
+        Args:
+            credentials: The credentials to validate.
+
+        Returns:
+            True if the credentials are valid, False otherwise.
+        """
+        try:
+            client = await self.create_client(credentials)
+            async with client:
+                return await client.is_authenticated()
+        except PlatformAuthError as e:
+            logger.warning(f"TikTok credential validation failed: {e}")
+            return False
+        except Exception as e:
+            logger.error(
+                f"An unexpected error occurred during TikTok credential validation: {e}"
+            )
+            return False

marqetive/platforms/tiktok/manager.py

@@ -0,0 +1,115 @@
+"""TikTok post manager for handling video post operations."""
+
+import logging
+from typing import Any
+
+from src.marqetive.core.base_manager import BasePostManager
+from src.marqetive.platforms.models import AuthCredentials, Post, PostCreateRequest
+from src.marqetive.platforms.tiktok.client import TikTokClient
+from src.marqetive.platforms.tiktok.factory import TikTokAccountFactory
+
+logger = logging.getLogger(__name__)
+
+
+class TikTokPostManager(BasePostManager):
+    """Manager for TikTok video post operations.
+
+    This manager coordinates the multi-step process of posting a video to
+    TikTok, including media upload, processing, and the final publishing step.
+    It provides progress tracking throughout the operation.
+    """
+
+    def __init__(
+        self,
+        account_factory: TikTokAccountFactory | None = None,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+    ) -> None:
+        """Initialize the TikTok post manager.
+
+        Args:
+            account_factory: An instance of TikTokAccountFactory. If not provided,
+                             a default one will be created.
+            client_id: TikTok App client ID (for the default factory).
+            client_secret: TikTok App client secret (for the default factory).
+        """
+        if account_factory is None:
+            account_factory = TikTokAccountFactory(
+                client_id=client_id,
+                client_secret=client_secret,
+            )
+        super().__init__(account_factory=account_factory)
+
+    @property
+    def platform_name(self) -> str:
+        """Get the platform name."""
+        return "tiktok"
+
+    async def _execute_post_impl(
+        self,
+        client: Any,
+        request: PostCreateRequest,
+        credentials: AuthCredentials,
+    ) -> Post:
+        """Execute the TikTok video post creation process.
+
+        Args:
+            client: An authenticated TikTokClient instance.
+            request: The post creation request.
+            credentials: The credentials used for authentication.
+
+        Returns:
+            The created Post object representing the TikTok video.
+
+        Raises:
+            TypeError: If the provided client is not a TikTokClient.
+            InterruptedError: If the operation is cancelled.
+        """
+        if not isinstance(client, TikTokClient):
+            raise TypeError(f"Expected TikTokClient, got {type(client)}")
+
+        # The TikTok posting process is primarily about the video upload.
+        # The client's create_post method handles the upload and publish steps.
+        # We can wrap it here to provide progress updates.
+
+        self._progress_tracker.emit_start(
+            "execute_post", total=100, message="Starting TikTok post..."
+        )
+
+        if self.is_cancelled():
+            raise InterruptedError("Post creation was cancelled before start.")
+
+        # Media upload progress can be tracked inside the client, but for simplicity,
+        # we'll emit high-level progress here.
+        self._progress_tracker.emit_progress(
+            "execute_post",
+            progress=10,
+            total=100,
+            message="Uploading video to TikTok...",
+        )
+
+        # The `create_post` method in the client will handle the full flow:
+        # 1. Upload media
+        # 2. Publish post
+        # 3. Fetch final post data
+        # A more advanced implementation might involve callbacks from the client
+        # to the manager for more granular progress updates.
+        post = await client.create_post(request)
+
+        if self.is_cancelled():
+            # If cancellation happened during the client call, we might need cleanup.
+            # For now, we just raise.
+            raise InterruptedError("Post creation was cancelled during execution.")
+
+        self._progress_tracker.emit_progress(
+            "execute_post",
+            progress=90,
+            total=100,
+            message="Finalizing post...",
+        )
+
+        self._progress_tracker.emit_complete(
+            "execute_post", message="TikTok post published successfully!"
+        )
+
+        return post