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

marqetive/core/client.py

@@ -73,7 +73,7 @@ class APIClient:
         if not self._client:
             raise RuntimeError("Client not initialized. Use async context manager.")
 
-        response: httpx.Response = await self._client.get(path, params=params)
+        response = await self._client.get(path, params=params)
         response.raise_for_status()
 
         return APIResponse(

marqetive/platforms/exceptions.py

@@ -115,9 +115,10 @@ class PostNotFoundError(PlatformError):
         post_id: str,
         platform: str | None = None,
         status_code: int | None = None,
+        message: str | None = None,
     ) -> None:
         self.post_id = post_id
-        message = f"Post not found: {post_id}"
+        message = message or f"Post not found: {post_id}"
         super().__init__(message, platform, status_code)
 
 

marqetive/platforms/models.py

@@ -305,6 +305,7 @@ class PostCreateRequest(BaseModel):
         link: URL to include in the post
         tags: List of hashtags or user tags
         location: Location/place tag for the post
+        additional_data: Platform-specific data
 
     Example:
         >>> request = PostCreateRequest(
@@ -321,6 +322,7 @@ class PostCreateRequest(BaseModel):
     link: str | None = None
     tags: list[str] = Field(default_factory=list)
     location: str | None = None
+    additional_data: dict[str, Any] = Field(default_factory=dict)
 
 
 class PostUpdateRequest(BaseModel):

marqetive/platforms/tiktok/__init__.py

@@ -0,0 +1,7 @@
+"""TikTok platform integration."""
+
+from src.marqetive.platforms.tiktok.client import TikTokClient
+from src.marqetive.platforms.tiktok.factory import TikTokAccountFactory
+from src.marqetive.platforms.tiktok.manager import TikTokPostManager
+
+__all__ = ["TikTokClient", "TikTokAccountFactory", "TikTokPostManager"]

marqetive/platforms/tiktok/client.py

@@ -0,0 +1,277 @@
+"""TikTok API client implementation.
+
+This module provides a concrete implementation of the SocialMediaPlatform
+ABC for TikTok, using the TikTok for Business API (hypothetical).
+
+API Documentation: https://developers.tiktok.com/doc/overview
+"""
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import HttpUrl
+
+from src.marqetive.platforms.base import SocialMediaPlatform
+from src.marqetive.platforms.exceptions import (
+    PlatformAuthError,
+    PlatformError,
+    PostNotFoundError,
+    ValidationError,
+)
+from src.marqetive.platforms.models import (
+    AuthCredentials,
+    Comment,
+    CommentStatus,
+    MediaAttachment,
+    MediaType,
+    Post,
+    PostCreateRequest,
+    PostStatus,
+    PostUpdateRequest,
+)
+from src.marqetive.platforms.tiktok.media import TikTokMediaManager
+
+
+class TikTokClient(SocialMediaPlatform):
+    """TikTok API client.
+
+    This client implements the SocialMediaPlatform interface for TikTok,
+    focusing on video uploads and management.
+    """
+
+    def __init__(
+        self,
+        credentials: AuthCredentials,
+        timeout: float = 300.0,
+    ) -> None:
+        """Initialize TikTok client."""
+        base_url = "https://open.tiktokapis.com/v2/"
+        super().__init__(
+            platform_name="tiktok",
+            credentials=credentials,
+            base_url=base_url,
+            timeout=timeout,
+        )
+        self._media_manager: TikTokMediaManager | None = None
+
+    async def _setup_managers(self) -> None:
+        """Setup media manager."""
+        if not self.credentials.access_token or not self.credentials.additional_data:
+            raise PlatformAuthError("Access token and open_id are required", "tiktok")
+
+        self._media_manager = TikTokMediaManager(
+            access_token=self.credentials.access_token,
+            open_id=self.credentials.additional_data["open_id"],
+            timeout=self.timeout,
+        )
+
+    async def _cleanup_managers(self) -> None:
+        """Cleanup media manager."""
+        if self._media_manager:
+            await self._media_manager.__aexit__(None, None, None)
+            self._media_manager = None
+
+    async def __aenter__(self) -> "TikTokClient":
+        await super().__aenter__()
+        await self._setup_managers()
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        await self._cleanup_managers()
+        await super().__aexit__(exc_type, exc_val, exc_tb)
+
+    async def authenticate(self) -> AuthCredentials:
+        """Perform TikTok authentication."""
+        if await self.is_authenticated():
+            return self.credentials
+        raise PlatformAuthError(
+            "Invalid or expired credentials. Please re-authenticate via TikTok OAuth.",
+            platform=self.platform_name,
+        )
+
+    async def refresh_token(self) -> AuthCredentials:
+        """Refresh TikTok access token."""
+        # The refresh logic should be handled by the AccountFactory
+        # For now, we assume it's done and we just return the creds
+        return self.credentials
+
+    async def is_authenticated(self) -> bool:
+        """Check if TikTok credentials are valid."""
+        if not self.api_client or not self.credentials.additional_data:
+            return False
+        try:
+            # Verify credentials by fetching authenticated user info
+            params = {
+                "fields": "open_id,union_id,avatar_url,display_name",
+                "open_id": self.credentials.additional_data["open_id"],
+            }
+            response = await self.api_client.get("user/info/", params=params)
+            return response.data.get("data", {}).get("user") is not None
+        except PlatformError:
+            return False
+
+    async def create_post(self, request: PostCreateRequest) -> Post:
+        """Create and publish a TikTok video.
+
+        Args:
+            request: The post creation request, must contain a video URL.
+
+        Returns:
+            The created Post object.
+
+        Raises:
+            ValidationError: If the request is invalid (e.g., no media).
+            MediaUploadError: If the video upload fails.
+        """
+        if not self._media_manager or not self.api_client:
+            raise RuntimeError("Client must be used as async context manager")
+
+        if not request.media_urls:
+            raise ValidationError(
+                "A video URL is required to create a TikTok post.",
+                platform=self.platform_name,
+            )
+
+        # 1. Upload the video
+        video_url = request.media_urls[0]
+        upload_result = await self._media_manager.upload_media(video_url)
+
+        if not upload_result.media_id:
+            raise PlatformError("Media upload succeeded but did not yield a media ID.")
+
+        # 2. Create the post with the uploaded video
+        payload = {
+            "post_info": {
+                "title": request.content or "",
+                "description": request.additional_data.get("description", ""),
+                "privacy_level": request.additional_data.get(
+                    "privacy_level", "PUBLIC_TO_EVERYONE"
+                ),
+            },
+            "source_info": {
+                "source": "FILE_UPLOAD",
+                "video_id": upload_result.media_id,
+            },
+        }
+        response = await self.api_client.post("video/publish/", data=payload)
+        post_id = response.data.get("data", {}).get("publish_id")
+
+        if not post_id:
+            raise PlatformError("Post creation succeeded but no publish_id returned.")
+
+        # 3. Fetch the created post to return a full Post object
+        return await self.get_post(post_id)
+
+    async def get_post(self, post_id: str) -> Post:
+        """Retrieve a TikTok video by its ID."""
+        if not self.api_client or not self.credentials.additional_data:
+            raise RuntimeError("Client must be used as async context manager")
+        try:
+            params = {
+                "open_id": self.credentials.additional_data["open_id"],
+                "video_ids": [post_id],
+            }
+            response = await self.api_client.post("video/query/", data=params)
+            video_data = response.data.get("data", {}).get("videos", [])
+            if not video_data:
+                raise PostNotFoundError(post_id, self.platform_name)
+            return self._parse_video_post(video_data[0])
+        except PlatformError as e:
+            raise PostNotFoundError(
+                post_id, self.platform_name, status_code=e.status_code
+            ) from e
+
+    async def update_post(self, post_id: str, request: PostUpdateRequest) -> Post:
+        """Update a TikTok video. This is not supported by TikTok API."""
+        raise PlatformError(
+            "TikTok API does not support updating videos.", self.platform_name
+        )
+
+    async def delete_post(self, post_id: str) -> bool:
+        """Delete a TikTok video. This is not supported by TikTok API."""
+        raise PlatformError(
+            "TikTok API does not support deleting videos.", self.platform_name
+        )
+
+    async def get_comments(
+        self, post_id: str, limit: int = 20, offset: int = 0
+    ) -> list[Comment]:
+        """Retrieve comments for a TikTok video."""
+        if not self.api_client or not self.credentials.additional_data:
+            raise RuntimeError("Client must be used as async context manager")
+        # This is a hypothetical endpoint
+        params = {
+            "open_id": self.credentials.additional_data["open_id"],
+            "video_id": post_id,
+            "count": limit,
+            "cursor": offset,
+        }
+        response = await self.api_client.get("video/comment/list/", params=params)
+        comments_data = response.data.get("data", {}).get("comments", [])
+        return [self._parse_comment(c, post_id) for c in comments_data]
+
+    async def create_comment(self, post_id: str, content: str) -> Comment:
+        """Create a comment on a TikTok video."""
+        raise PlatformError("Commenting via API is not supported.", self.platform_name)
+
+    async def delete_comment(self, comment_id: str) -> bool:
+        """Delete a comment on a TikTok video."""
+        raise PlatformError(
+            "Deleting comments via API is not supported.", self.platform_name
+        )
+
+    async def upload_media(
+        self, media_url: str, media_type: str, alt_text: str | None = None
+    ) -> MediaAttachment:
+        """Upload a video to TikTok."""
+        if not self._media_manager:
+            raise RuntimeError("Client not initialized. Use as async context manager.")
+        if media_type != "video":
+            raise ValidationError("Only video media type is supported for TikTok.")
+
+        result = await self._media_manager.upload_media(media_url)
+        return MediaAttachment(
+            media_id=result.media_id or result.upload_id,
+            media_type=MediaType.VIDEO,
+            url=HttpUrl(media_url),
+        )
+
+    def _parse_video_post(self, video_data: dict[str, Any]) -> Post:
+        """Parse a TikTok API video object into a Post model."""
+        return Post(
+            post_id=video_data["video_id"],
+            platform=self.platform_name,
+            content=video_data.get("title", ""),
+            media=[
+                MediaAttachment(
+                    media_id=video_data["video_id"],
+                    media_type=MediaType.VIDEO,
+                    url=HttpUrl(video_data.get("share_url", "")),
+                    width=video_data.get("width"),
+                    height=video_data.get("height"),
+                )
+            ],
+            status=PostStatus.PUBLISHED,
+            created_at=datetime.fromtimestamp(video_data.get("create_time", 0)),
+            author_id=str(video_data.get("open_id")),
+            likes_count=video_data.get("like_count", 0),
+            comments_count=video_data.get("comment_count", 0),
+            shares_count=video_data.get("share_count", 0),
+            views_count=video_data.get("view_count", 0),
+            raw_data=video_data,
+        )
+
+    def _parse_comment(self, comment_data: dict[str, Any], post_id: str) -> Comment:
+        """Parse a TikTok API comment object into a Comment model."""
+        return Comment(
+            comment_id=comment_data["comment_id"],
+            post_id=post_id,
+            platform=self.platform_name,
+            content=comment_data.get("text", ""),
+            author_id=comment_data.get("open_id", ""),
+            created_at=datetime.fromtimestamp(comment_data.get("create_time", 0)),
+            likes_count=comment_data.get("like_count", 0),
+            replies_count=0,
+            status=CommentStatus.VISIBLE,
+            raw_data=comment_data,
+        )

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

marqetive/platforms/tiktok/media.py

@@ -0,0 +1,305 @@
+"""TikTok media upload manager for handling video uploads.
+
+This module provides functionality for uploading videos to TikTok's API,
+focusing on a chunked upload process suitable for large video files.
+"""
+
+import asyncio
+import logging
+import os
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Literal
+
+import httpx
+
+from src.marqetive.platforms.exceptions import (
+    InvalidFileTypeError,
+    MediaUploadError,
+)
+from src.marqetive.utils.file_handlers import download_file
+from src.marqetive.utils.media import (
+    detect_mime_type,
+    format_file_size,
+    get_chunk_count,
+)
+from src.marqetive.utils.retry import STANDARD_BACKOFF, retry_async
+
+logger = logging.getLogger(__name__)
+
+# Constants for TikTok Media Upload
+DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024  # 5MB chunks
+MAX_VIDEO_SIZE = 10 * 1024 * 1024 * 1024  # 10GB, hypothetical
+MIN_VIDEO_DURATION_SECS = 3
+MAX_VIDEO_DURATION_SECS = 600  # 10 minutes
+DEFAULT_REQUEST_TIMEOUT = 300.0
+
+# Hypothetical TikTok API endpoints for media
+MEDIA_API_BASE_URL = "https://open.tiktokapis.com/v2/video"
+
+# Supported MIME types for TikTok
+SUPPORTED_VIDEO_TYPES = ["video/mp4", "video/quicktime"]  # MOV
+
+
+class ProcessingState(str, Enum):
+    """States for async media processing."""
+
+    PENDING = "pending"
+    PROCESSING = "processing"
+    READY = "ready"
+    FAILED = "failed"
+
+
+@dataclass
+class UploadProgress:
+    """Progress information for a media upload."""
+
+    upload_id: str | None
+    file_path: str
+    bytes_uploaded: int
+    total_bytes: int
+    status: Literal["init", "uploading", "processing", "completed", "failed"]
+
+    @property
+    def percentage(self) -> float:
+        if self.total_bytes == 0:
+            return 0.0
+        return (self.bytes_uploaded / self.total_bytes) * 100
+
+    def __str__(self) -> str:
+        return (
+            f"Upload Progress: {self.percentage:.1f}% "
+            f"({format_file_size(self.bytes_uploaded)} / "
+            f"{format_file_size(self.total_bytes)}) - {self.status}"
+        )
+
+
+@dataclass
+class MediaUploadResult:
+    """Result of a successful media upload."""
+
+    upload_id: str
+    media_id: str | None = None  # Available after processing
+    size: int | None = None
+    processing_info: dict[str, Any] | None = None
+
+
+class TikTokMediaManager:
+    """Manages video uploads to the TikTok API.
+
+    This class handles the complexities of chunked uploads for large video files
+    and monitors the processing status of the uploaded media.
+    """
+
+    def __init__(
+        self,
+        access_token: str,
+        open_id: str,
+        *,
+        progress_callback: Callable[[UploadProgress], None] | None = None,
+        timeout: float = DEFAULT_REQUEST_TIMEOUT,
+    ) -> None:
+        """Initialize the TikTok media manager."""
+        self.access_token = access_token
+        self.open_id = open_id
+        self.progress_callback = progress_callback
+        self.timeout = timeout
+        self.base_url = MEDIA_API_BASE_URL
+        self.client = httpx.AsyncClient(
+            timeout=httpx.Timeout(timeout),
+            headers={"Authorization": f"Bearer {access_token}"},
+        )
+
+    async def __aenter__(self) -> "TikTokMediaManager":
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.client.aclose()
+
+    async def upload_media(
+        self,
+        file_path: str,
+        *,
+        chunk_size: int = DEFAULT_CHUNK_SIZE,
+        wait_for_processing: bool = True,
+    ) -> MediaUploadResult:
+        """Upload a video file to TikTok.
+
+        Args:
+            file_path: The local path or URL of the video to upload.
+            chunk_size: The size of each chunk to upload in bytes.
+            wait_for_processing: If True, wait until the video is processed and ready.
+
+        Returns:
+            A MediaUploadResult containing the upload and media IDs.
+
+        Raises:
+            FileNotFoundError: If the local file does not exist.
+            InvalidFileTypeError: If the file is not a supported video format.
+            MediaUploadError: If the upload or processing fails.
+        """
+        if file_path.startswith(("http://", "https://")):
+            logger.info(f"Downloading media from URL: {file_path}")
+            file_path = await download_file(file_path)
+
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"Media file not found: {file_path}")
+
+        mime_type = detect_mime_type(file_path)
+        file_size = os.path.getsize(file_path)
+        self._validate_media(mime_type, file_size)
+
+        # TikTok uses a one-step chunked upload
+        result = await self.chunked_upload(
+            file_path,
+            chunk_size=chunk_size,
+        )
+
+        # Note: TikTok's real API might have a different flow for processing.
+        # This is a hypothetical implementation.
+        if wait_for_processing:
+            await self._wait_for_processing(result, file_path)
+
+        return result
+
+    async def chunked_upload(
+        self, file_path: str, *, chunk_size: int = DEFAULT_CHUNK_SIZE
+    ) -> MediaUploadResult:
+        """Upload a video using the chunked upload method.
+
+        This is a simplified model of how a chunked upload to TikTok might work.
+        The actual API may differ.
+
+        Args:
+            file_path: Path to the video file.
+            chunk_size: Size of each upload chunk.
+
+        Returns:
+            MediaUploadResult with upload ID.
+        """
+        file_size = os.path.getsize(file_path)
+        chunk_count = get_chunk_count(file_path, chunk_size)
+        upload_id = None  # Hypothetically obtained from an INIT step if needed
+
+        if self.progress_callback:
+            self.progress_callback(
+                UploadProgress(
+                    upload_id=upload_id,
+                    file_path=file_path,
+                    bytes_uploaded=0,
+                    total_bytes=file_size,
+                    status="init",
+                )
+            )
+
+        @retry_async(config=STANDARD_BACKOFF)
+        async def _do_upload() -> MediaUploadResult:
+            bytes_uploaded = 0
+
+            # Hypothetical: The real API may require separate INIT/APPEND/FINALIZE steps.
+            # This implementation models a single POST with all chunks.
+            async def file_iterator():
+                nonlocal bytes_uploaded
+                with open(file_path, "rb") as f:
+                    for i, chunk in enumerate(iter(lambda: f.read(chunk_size), b"")):
+                        bytes_uploaded += len(chunk)
+                        if self.progress_callback:
+                            self.progress_callback(
+                                UploadProgress(
+                                    upload_id=upload_id,
+                                    file_path=file_path,
+                                    bytes_uploaded=bytes_uploaded,
+                                    total_bytes=file_size,
+                                    status="uploading",
+                                )
+                            )
+                        logger.debug(f"Uploading chunk {i + 1}/{chunk_count}")
+                        yield chunk
+
+            # In a real scenario, you'd likely get an upload URL first.
+            upload_url = f"{self.base_url}/upload/"
+            response = await self.client.post(
+                upload_url,
+                params={"open_id": self.open_id},
+                content=file_iterator(),
+                headers={"Content-Type": "video/mp4"},
+            )
+            response.raise_for_status()
+            result_data = response.json()
+            upload_id = result_data.get("data", {}).get("video", {}).get("video_id")
+
+            if not upload_id:
+                raise MediaUploadError(
+                    "Upload succeeded but did not return a video ID.", platform="tiktok"
+                )
+
+            result = MediaUploadResult(
+                upload_id=upload_id,
+                media_id=upload_id,  # Assume upload_id is the media_id
+                size=file_size,
+            )
+
+            if self.progress_callback:
+                self.progress_callback(
+                    UploadProgress(
+                        upload_id=upload_id,
+                        file_path=file_path,
+                        bytes_uploaded=file_size,
+                        total_bytes=file_size,
+                        status="completed",
+                    )
+                )
+
+            logger.info(f"Chunked upload completed for TikTok: {upload_id}")
+            return result
+
+        try:
+            return await _do_upload()
+        except httpx.HTTPError as e:
+            raise MediaUploadError(
+                f"TikTok video upload failed: {e}",
+                platform="tiktok",
+                media_type=detect_mime_type(file_path),
+            ) from e
+
+    async def _wait_for_processing(
+        self, result: MediaUploadResult, file_path: str
+    ) -> None:
+        """Wait for async video processing to complete.
+
+        This is a hypothetical implementation.
+        """
+        logger.info(f"Waiting for TikTok video processing: {result.upload_id}")
+        # In a real implementation, you would poll a status endpoint.
+        # Here, we'll just simulate a delay.
+        await asyncio.sleep(5)  # Simulate processing time
+        if self.progress_callback:
+            self.progress_callback(
+                UploadProgress(
+                    upload_id=result.upload_id,
+                    file_path=file_path,
+                    bytes_uploaded=os.path.getsize(file_path),
+                    total_bytes=os.path.getsize(file_path),
+                    status="processing",
+                )
+            )
+        logger.info(f"TikTok video processing assumed complete: {result.upload_id}")
+
+    def _validate_media(self, mime_type: str, file_size: int) -> None:
+        """Validate media type and size against TikTok's requirements."""
+        if mime_type not in SUPPORTED_VIDEO_TYPES:
+            raise InvalidFileTypeError(
+                f"Unsupported video type for TikTok: {mime_type}. "
+                f"Supported types are: {', '.join(SUPPORTED_VIDEO_TYPES)}",
+                platform="tiktok",
+            )
+
+        if file_size > MAX_VIDEO_SIZE:
+            raise MediaUploadError(
+                f"Video file size ({format_file_size(file_size)}) exceeds the "
+                f"TikTok limit of {format_file_size(MAX_VIDEO_SIZE)}",
+                platform="tiktok",
+                media_type=mime_type,
+            )
+        # Add duration validation logic here if possible to check before upload

marqetive/platforms/twitter/client.py

@@ -345,7 +345,7 @@ class TwitterClient(SocialMediaPlatform):
 
     async def update_post(
         self,
-        post_id: str,
+        post_id: str,  # noqa: ARG002
         request: PostUpdateRequest,  # noqa: ARG002
     ) -> Post:
         """Update a tweet.

marqetive/utils/oauth.py

@@ -263,3 +263,138 @@ async def refresh_instagram_token(
             f"Network error refreshing Instagram token: {e}",
             platform="instagram",
         ) from e
+
+
+async def refresh_tiktok_token(
+    credentials: AuthCredentials,
+    client_id: str,
+    client_secret: str,
+) -> AuthCredentials:
+    """Refresh TikTok OAuth2 access token.
+
+    Args:
+        credentials: Current credentials with refresh token.
+        client_id: TikTok OAuth client ID (client_key).
+        client_secret: TikTok OAuth client secret.
+
+    Returns:
+        Updated credentials with new access token.
+
+    Raises:
+        PlatformAuthError: If refresh fails.
+    """
+    if not credentials.refresh_token:
+        raise PlatformAuthError(
+            "No refresh token available",
+            platform="tiktok",
+        )
+
+    token_url = "https://open.tiktokapis.com/v2/oauth/token/"
+
+    params = {
+        "client_key": client_id,
+        "client_secret": client_secret,
+        "grant_type": "refresh_token",
+        "refresh_token": credentials.refresh_token,
+    }
+
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                token_url,
+                data=params,
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+                timeout=30.0,
+            )
+            response.raise_for_status()
+            token_data = response.json()
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error refreshing tiktok token: {e.response.status_code}")
+        raise PlatformAuthError(
+            f"Failed to refresh token: {e.response.text}",
+            platform="tiktok",
+            status_code=e.response.status_code,
+        ) from e
+
+    except httpx.HTTPError as e:
+        logger.error(f"Network error refreshing tiktok token: {e}")
+        raise PlatformAuthError(
+            f"Network error refreshing token: {e}",
+            platform="tiktok",
+        ) from e
+
+    # Update credentials
+    credentials.access_token = token_data["access_token"]
+
+    # TikTok might provide new refresh token
+    if "refresh_token" in token_data:
+        credentials.refresh_token = token_data["refresh_token"]
+
+    # Calculate expiry
+    if "expires_in" in token_data:
+        expires_in = int(token_data["expires_in"])
+        credentials.expires_at = datetime.now() + timedelta(seconds=expires_in)
+
+    return credentials
+
+
+async def fetch_tiktok_token(
+    code: str,
+    client_id: str,
+    client_secret: str,
+    redirect_uri: str,
+    code_verifier: str | None = None,
+) -> dict[str, Any]:
+    """Fetch a TikTok OAuth2 access token using an authorization code.
+
+    Args:
+        code: The authorization code from the callback.
+        client_id: TikTok OAuth client ID (client_key).
+        client_secret: TikTok OAuth client secret.
+        redirect_uri: The redirect URI used for the authorization request.
+        code_verifier: PKCE code verifier for mobile/desktop apps.
+
+    Returns:
+        Token response dictionary with access_token, refresh_token, etc.
+
+    Raises:
+        PlatformAuthError: If token fetch fails.
+    """
+    token_url = "https://open.tiktokapis.com/v2/oauth/token/"
+
+    params = {
+        "client_key": client_id,
+        "client_secret": client_secret,
+        "code": code,
+        "grant_type": "authorization_code",
+        "redirect_uri": redirect_uri,
+    }
+    if code_verifier:
+        params["code_verifier"] = code_verifier
+
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                token_url,
+                data=params,
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+                timeout=30.0,
+            )
+            response.raise_for_status()
+            return response.json()
+
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error fetching tiktok token: {e.response.status_code}")
+        raise PlatformAuthError(
+            f"Failed to fetch token: {e.response.text}",
+            platform="tiktok",
+            status_code=e.response.status_code,
+        ) from e
+
+    except httpx.HTTPError as e:
+        logger.error(f"Network error fetching tiktok token: {e}")
+        raise PlatformAuthError(
+            f"Network error fetching token: {e}",
+            platform="tiktok",
+        ) from e

{marqetive_lib-0.1.1.dist-info → marqetive_lib-0.1.2.dist-info}/METADATA

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: marqetive-lib
-Version: 0.1.1
+Version: 0.1.2
 Summary: Modern Python utilities for web APIs
 Keywords: api,utilities,web,http,marqetive
 Requires-Python: >=3.12
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{marqetive_lib-0.1.1.dist-info → marqetive_lib-0.1.2.dist-info}/RECORD

@@ -2,12 +2,12 @@ marqetive/__init__.py,sha256=XVnYmB817AILAnJYg1WVNnmrd1MvJns3QpPbfdjmwRE,3142
 marqetive/core/__init__.py,sha256=5Wgcby-EQkTxrPVD4so69nBmZ66Ng9JGqBov4RQMT4A,117
 marqetive/core/account_factory.py,sha256=9fsP6fzLYp3UGU59fkxwURgzn7eBxr8-WJt3aP-Z65U,7153
 marqetive/core/base_manager.py,sha256=z28bV4p1FC7s9g_YkXIKW_qkv8bjF4tMoF-cGGksJuA,10047
-marqetive/core/client.py,sha256=GBgWzkgdMRMyoCy5dXdEFFzPne6Usp_9i0UxaG7Xd-Y,3226
+marqetive/core/client.py,sha256=2_FoNpqaRglsWg10i5RTbyDg_kRQKhgWjYs6iDdFxLg,3210
 marqetive/core/progress.py,sha256=5Vyksf8YfQUVRudwDEuegcxoc0js5qbHM2SFZ6VLxHM,8593
 marqetive/core/registry.py,sha256=D6qlafpvemYfE9GouWcWZyltK0aNcFLSi_2M-WdTIdE,8084
 marqetive/platforms/__init__.py,sha256=6QjetNWodf32pgGQsmLKs7W-v-pG2kKckb5JEPqIPNI,1351
 marqetive/platforms/base.py,sha256=zmCda00Szq_LswRdsWPI5V88TysLH3FIZ0mKwH6b8dE,11957
-marqetive/platforms/exceptions.py,sha256=C8H0vsICM6amtQTz1iwXjc3duFGq-M71N7QqsLElt1M,7029
+marqetive/platforms/exceptions.py,sha256=Xyj0bzNiZm5VTErmzXgVW8T6IQnOpF92-HJiKPKjIio,7076
 marqetive/platforms/instagram/__init__.py,sha256=9V0GPVm9HSTtDdV0bQEfuND8r7PEF2smOL3lb5BZevg,343
 marqetive/platforms/instagram/client.py,sha256=PxVsHUW8SSpPe2Kdd5zGezD7LUvJj5tdyNj8In_ChxI,24955
 marqetive/platforms/instagram/exceptions.py,sha256=zFG_CkstlZWG47zsFdnObOZviTDIx3Z8yVG9-x7GMVY,8987
@@ -20,10 +20,15 @@ marqetive/platforms/linkedin/exceptions.py,sha256=64J02_99cUcUW5i5xHE_sa0_6V4ibW
 marqetive/platforms/linkedin/factory.py,sha256=8JNxAMC-lJcU1trnd0PFge0LQWQMiIVzZORJHwcBhmM,4536
 marqetive/platforms/linkedin/manager.py,sha256=XB6HB6-MWsDz2Arij5GuyRH_j5xWkYb8sHCTlKFWzMg,4000
 marqetive/platforms/linkedin/media.py,sha256=busrlTA3CisY43qDy9dmiAmbFVz8De4nDsA4CV9PeWk,16917
-marqetive/platforms/models.py,sha256=8NSIh-fT5gFHCvs6A5dnnsfhsklpSfNgD_ovDPVv1aY,10860
-marqetive/platforms/tiktok/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+marqetive/platforms/models.py,sha256=W_yOuRWItWSn82n8vXRNN_ScdNkzY1De2qqXaVN2RGU,10974
+marqetive/platforms/tiktok/__init__.py,sha256=_lfPj-5VfNaL4cE39Uiv8QOI1DtRnKiP5feKdPQ53zI,313
+marqetive/platforms/tiktok/client.py,sha256=p0uhPCyjykMj8mx0y3oCEOTNwEM_obr1CW8iLz-8AMw,10715
+marqetive/platforms/tiktok/exceptions.py,sha256=SKzmAEIfBf9qeYPXdOFKL2ARx7MK_h57fyohbg_86vY,5780
+marqetive/platforms/tiktok/factory.py,sha256=aqzyWe42i0R3Tvr2ml2xEYeW2e3USqIkz5-o8O5ae64,6764
+marqetive/platforms/tiktok/manager.py,sha256=0bIL26NCppN5PFk0DKPaH2zyrm4wwA-Mfm8KQwq97UY,4113
+marqetive/platforms/tiktok/media.py,sha256=B3QoE05xlQ0OSZ_1y_MiNX8bJFwbyM4jDvM4w7A-HHA,10652
 marqetive/platforms/twitter/__init__.py,sha256=TRVOejA-wa_tw50_YUwTYnhGyGuOK2IFpZWvVZP94HQ,325
-marqetive/platforms/twitter/client.py,sha256=881gM9twIPo81ShTpLXbQMpOzeWad1D4Nu6H0BzCSlY,20840
+marqetive/platforms/twitter/client.py,sha256=s5nLUc3wOSEBCNuFCqxoLqUypBI6eDK6fRC1iP5OnZU,20856
 marqetive/platforms/twitter/exceptions.py,sha256=yRLLcodSouaFV076iwbxcWZzXUuoswAOXuL_-iPvLOk,8935
 marqetive/platforms/twitter/factory.py,sha256=nBBl5aFcNCgIwf45PWywjpx_Qp0aOdbOHthvQX-BzI4,5286
 marqetive/platforms/twitter/manager.py,sha256=NEqFllDdQ6nlUQMV1M5koX8DMURuvNsa39gKiTpm5A0,4108
@@ -35,9 +40,9 @@ marqetive/utils/__init__.py,sha256=qBn_DN-L2YTfuB_G-n_bHJjtuVRiyH3ftl9JZ0JO93M,9
 marqetive/utils/file_handlers.py,sha256=IUdRZxr_jxAuwxUypUkUgKqiGDcIHNr1LhCb2Ne2a98,12572
 marqetive/utils/helpers.py,sha256=8-ljhL47SremKcQO2GF8DIHOPODEv1rSioVNuSPCbec,2634
 marqetive/utils/media.py,sha256=Rvxw9XKU65n-z4G1bEihG3wXZBmjSDZUqClfjGFrg6k,12013
-marqetive/utils/oauth.py,sha256=NOQidwZ6vAscUMPUm-Ho16L2G64vGHkopJHZVSNWv88,7921
+marqetive/utils/oauth.py,sha256=B8GbzliQKEV5XpPshrKCHNlFl_arEOfZ10KKIUDKfQg,12113
 marqetive/utils/retry.py,sha256=lAniJLMNWp9XsHrvU0XBNifpNEjfde4MGfd5hlFTPfA,7636
 marqetive/utils/token_validator.py,sha256=asLMiEgT-BtqEpn_HDX15vJoSBcH7CGW0abervFOXxM,6707
-marqetive_lib-0.1.1.dist-info/METADATA,sha256=o7T_GLuQ3UqFCIIGZEsg6gCDOz3sKPxWImBhlaO-XWc,7849
-marqetive_lib-0.1.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-marqetive_lib-0.1.1.dist-info/RECORD,,
+marqetive_lib-0.1.2.dist-info/METADATA,sha256=xk2oWdG9QJlzw1Mu49BWngovHJ4izI2N0pwZFKNzP-4,7798
+marqetive_lib-0.1.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+marqetive_lib-0.1.2.dist-info/RECORD,,