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

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/__init__.py

@@ -1,7 +1,7 @@
 """Twitter/X platform integration."""
 
-from marqetive.platforms.twitter.client import TwitterClient
-from marqetive.platforms.twitter.factory import TwitterAccountFactory
-from marqetive.platforms.twitter.manager import TwitterPostManager
+from src.marqetive.platforms.twitter.client import TwitterClient
+from src.marqetive.platforms.twitter.factory import TwitterAccountFactory
+from src.marqetive.platforms.twitter.manager import TwitterPostManager
 
 __all__ = ["TwitterClient", "TwitterAccountFactory", "TwitterPostManager"]

marqetive/platforms/twitter/client.py

@@ -13,8 +13,8 @@ import httpx
 import tweepy
 from pydantic import HttpUrl
 
-from marqetive.platforms.base import SocialMediaPlatform
-from marqetive.platforms.exceptions import (
+from src.marqetive.platforms.base import SocialMediaPlatform
+from src.marqetive.platforms.exceptions import (
     MediaUploadError,
     PlatformAuthError,
     PlatformError,
@@ -22,7 +22,7 @@ from marqetive.platforms.exceptions import (
     RateLimitError,
     ValidationError,
 )
-from marqetive.platforms.models import (
+from src.marqetive.platforms.models import (
     AuthCredentials,
     Comment,
     CommentStatus,
@@ -33,8 +33,8 @@ from marqetive.platforms.models import (
     PostStatus,
     PostUpdateRequest,
 )
-from marqetive.platforms.twitter.media import TwitterMediaManager
-from marqetive.platforms.twitter.threads import (
+from src.marqetive.platforms.twitter.media import TwitterMediaManager
+from src.marqetive.platforms.twitter.threads import (
     ThreadResult,
     TweetData,
     TwitterThreadManager,
@@ -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/platforms/twitter/exceptions.py

@@ -9,7 +9,7 @@ This module provides comprehensive error handling for Twitter API errors includi
 
 from typing import Any
 
-from marqetive.platforms.exceptions import (
+from src.marqetive.platforms.exceptions import (
     MediaUploadError,
     PlatformAuthError,
     PlatformError,

marqetive/platforms/twitter/factory.py

@@ -4,11 +4,11 @@ import logging
 import os
 from collections.abc import Callable
 
-from marqetive.core.account_factory import BaseAccountFactory
-from marqetive.platforms.exceptions import PlatformAuthError
-from marqetive.platforms.models import AccountStatus, AuthCredentials
-from marqetive.platforms.twitter.client import TwitterClient
-from marqetive.utils.oauth import refresh_twitter_token
+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.twitter.client import TwitterClient
+from src.marqetive.utils.oauth import refresh_twitter_token
 
 logger = logging.getLogger(__name__)
 

marqetive/platforms/twitter/manager.py

@@ -3,10 +3,10 @@
 import logging
 from typing import Any
 
-from marqetive.core.base_manager import BasePostManager
-from marqetive.platforms.models import AuthCredentials, Post, PostCreateRequest
-from marqetive.platforms.twitter.client import TwitterClient
-from marqetive.platforms.twitter.factory import TwitterAccountFactory
+from src.marqetive.core.base_manager import BasePostManager
+from src.marqetive.platforms.models import AuthCredentials, Post, PostCreateRequest
+from src.marqetive.platforms.twitter.client import TwitterClient
+from src.marqetive.platforms.twitter.factory import TwitterAccountFactory
 
 logger = logging.getLogger(__name__)
 

marqetive/platforms/twitter/media.py

@@ -18,17 +18,17 @@ from typing import Any, Literal
 
 import httpx
 
-from marqetive.platforms.exceptions import (
+from src.marqetive.platforms.exceptions import (
     InvalidFileTypeError,
     MediaUploadError,
 )
-from marqetive.utils.file_handlers import download_file
-from marqetive.utils.media import (
+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 marqetive.utils.retry import STANDARD_BACKOFF, retry_async
+from src.marqetive.utils.retry import STANDARD_BACKOFF, retry_async
 
 logger = logging.getLogger(__name__)
 

marqetive/platforms/twitter/threads.py

@@ -9,8 +9,8 @@ from typing import Any
 
 import tweepy
 
-from marqetive.platforms.exceptions import PlatformError, ValidationError
-from marqetive.platforms.models import Post, PostStatus
+from src.marqetive.platforms.exceptions import PlatformError, ValidationError
+from src.marqetive.platforms.models import Post, PostStatus
 
 
 @dataclass

marqetive/registry_init.py

@@ -6,10 +6,10 @@ platform managers with the global registry.
 
 import logging
 
-from marqetive.core.registry import register_platform
-from marqetive.platforms.instagram.manager import InstagramPostManager
-from marqetive.platforms.linkedin.manager import LinkedInPostManager
-from marqetive.platforms.twitter.manager import TwitterPostManager
+from src.marqetive.core.registry import register_platform
+from src.marqetive.platforms.instagram.manager import InstagramPostManager
+from src.marqetive.platforms.linkedin.manager import LinkedInPostManager
+from src.marqetive.platforms.twitter.manager import TwitterPostManager
 
 logger = logging.getLogger(__name__)
 

marqetive/utils/__init__.py

@@ -1,6 +1,6 @@
 """Utility functions for MarqetiveLib."""
 
-from marqetive.utils.file_handlers import (
+from src.marqetive.utils.file_handlers import (
     TempFileManager,
     download_file,
     download_to_memory,
@@ -9,8 +9,8 @@ from marqetive.utils.file_handlers import (
     stream_file_upload,
     write_file_bytes,
 )
-from marqetive.utils.helpers import format_response, parse_query_params
-from marqetive.utils.media import (
+from src.marqetive.utils.helpers import format_response, parse_query_params
+from src.marqetive.utils.media import (
     MediaValidator,
     chunk_file,
     detect_mime_type,

marqetive/utils/file_handlers.py

@@ -17,7 +17,7 @@ from typing import Any
 import aiofiles
 import httpx
 
-from marqetive.utils.media import detect_mime_type, format_file_size
+from src.marqetive.utils.media import detect_mime_type, format_file_size
 
 
 class DownloadProgress:

marqetive/utils/oauth.py

@@ -10,8 +10,8 @@ from typing import Any
 
 import httpx
 
-from marqetive.platforms.exceptions import PlatformAuthError
-from marqetive.platforms.models import AuthCredentials
+from src.marqetive.platforms.exceptions import PlatformAuthError
+from src.marqetive.platforms.models import AuthCredentials
 
 logger = logging.getLogger(__name__)
 
@@ -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/utils/token_validator.py

@@ -8,7 +8,7 @@ import re
 from datetime import datetime, timedelta
 from typing import Any
 
-from marqetive.platforms.models import AuthCredentials
+from src.marqetive.platforms.models import AuthCredentials
 
 
 def is_token_expired(

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

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: marqetive-lib
-Version: 0.1.0
+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