marqetive-lib 0.1.1__tar.gz → 0.1.2__tar.gz

{marqetive_lib-0.1.1 → marqetive_lib-0.1.2}/PKG-INFO

@@ -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 → marqetive_lib-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "marqetive-lib"
-version = "0.1.1"
+version = "0.1.2"
 description = "Modern Python utilities for web APIs"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -12,7 +12,6 @@ keywords = ["api", "utilities", "web", "http", "marqetive"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",

{marqetive_lib-0.1.1 → marqetive_lib-0.1.2}/src/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_lib-0.1.1 → marqetive_lib-0.1.2}/src/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_lib-0.1.1 → marqetive_lib-0.1.2}/src/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_lib-0.1.2/src/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_lib-0.1.2/src/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_lib-0.1.2/src/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})"
+        )