marqetive-lib 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

marqetive/platforms/instagram/client.py

@@ -216,12 +216,19 @@ class InstagramClient(SocialMediaPlatform):
     async def create_post(self, request: PostCreateRequest) -> Post:
         """Create and publish an Instagram post.
 
-        Instagram requires a two-step process:
-        1. Create a media container
-        2. Publish the container
+        Automatically routes to the appropriate handler based on content type:
+        - IMAGE: Single image feed post
+        - CAROUSEL: Multiple images (2-10)
+        - REEL/VIDEO: Video content as Reel
+        - STORY: Story (image or video)
+
+        Content type can be specified via:
+        1. InstagramPostRequest.media_type field
+        2. PostCreateRequest.additional_data["media_type"]
+        3. Auto-detected from media_urls count (1 = single, 2+ = carousel)
 
         Args:
-            request: Post creation request.
+            request: Post creation request (PostCreateRequest or InstagramPostRequest).
 
         Returns:
             Created Post object.
@@ -229,6 +236,22 @@ class InstagramClient(SocialMediaPlatform):
         Raises:
             ValidationError: If request is invalid.
             MediaUploadError: If media upload fails.
+
+        Example:
+            >>> # Single image post
+            >>> request = PostCreateRequest(
+            ...     content="Hello Instagram!",
+            ...     media_urls=["https://example.com/image.jpg"]
+            ... )
+            >>> post = await client.create_post(request)
+
+            >>> # Reel via additional_data
+            >>> request = PostCreateRequest(
+            ...     content="Check out this video!",
+            ...     media_urls=["https://example.com/video.mp4"],
+            ...     additional_data={"media_type": "reel"}
+            ... )
+            >>> post = await client.create_post(request)
         """
         if not self.api_client:
             raise RuntimeError("Client must be used as async context manager")
@@ -240,47 +263,185 @@ class InstagramClient(SocialMediaPlatform):
                 field="media",
             )
 
-        # Step 1: Create media container
-        container_params: dict[str, Any] = {
-            "access_token": self.credentials.access_token,
-        }
+        # Determine content type from request
+        media_type = self._get_media_type(request)
 
-        if request.media_urls:
-            # Validate URL to prevent SSRF attacks
-            validated_url = validate_media_url(
-                request.media_urls[0], platform=self.platform_name
-            )
-            container_params["image_url"] = validated_url
+        # Route to appropriate handler based on content type
+        if media_type == MediaType.STORY:
+            return await self._create_story_post(request)
+        elif media_type in (MediaType.REEL, MediaType.VIDEO):
+            return await self._create_reel_post(request)
+        elif media_type == MediaType.CAROUSEL or len(request.media_urls) > 1:
+            return await self._create_carousel_post(request)
+        else:
+            return await self._create_single_image_post(request)
 
-        if request.content:
-            container_params["caption"] = request.content
+    def _get_media_type(self, request: PostCreateRequest) -> MediaType:
+        """Extract media type from request.
 
-        try:
-            # Create container
-            container_response = await self.api_client.post(
-                f"/{self.instagram_account_id}/media",
-                data=container_params,
+        Checks in order:
+        1. InstagramPostRequest.media_type (if using platform-specific model)
+        2. PostCreateRequest.additional_data["media_type"]
+        3. Auto-detect from media count
+
+        Args:
+            request: Post creation request.
+
+        Returns:
+            MediaType enum value.
+        """
+        # Check if it's an InstagramPostRequest with media_type
+        # Use getattr to avoid type checker issues with duck typing
+        media_type_attr = getattr(request, "media_type", None)
+        if media_type_attr is not None and isinstance(media_type_attr, MediaType):
+            return media_type_attr
+
+        # Check additional_data for media_type
+        if request.additional_data:
+            media_type_str = request.additional_data.get("media_type")
+            if media_type_str:
+                # Normalize and convert to enum
+                media_type_str = media_type_str.lower()
+                type_map = {
+                    "image": MediaType.IMAGE,
+                    "video": MediaType.VIDEO,
+                    "reel": MediaType.REEL,
+                    "reels": MediaType.REEL,
+                    "story": MediaType.STORY,
+                    "stories": MediaType.STORY,
+                    "carousel": MediaType.CAROUSEL,
+                }
+                if media_type_str in type_map:
+                    return type_map[media_type_str]
+
+        # Auto-detect: multiple URLs = carousel, single = image
+        if len(request.media_urls) > 1:
+            return MediaType.CAROUSEL
+
+        return MediaType.IMAGE
+
+    async def _create_single_image_post(self, request: PostCreateRequest) -> Post:
+        """Create a single image feed post.
+
+        Args:
+            request: Post creation request.
+
+        Returns:
+            Created Post object.
+        """
+        if not self._media_manager:
+            raise RuntimeError("Client must be used as async context manager")
+
+        # Extract options from additional_data
+        location_id = request.additional_data.get("location_id") or request.location
+        share_to_feed = request.additional_data.get("share_to_feed", True)
+
+        # Validate URL
+        validated_url = validate_media_url(
+            request.media_urls[0], platform=self.platform_name
+        )
+
+        # Create media item
+        media_item = MediaItem(url=validated_url, type="image")
+
+        # Get alt_texts if provided
+        alt_texts = request.additional_data.get("alt_texts", [])
+        if alt_texts:
+            media_item = MediaItem(
+                url=validated_url, type="image", alt_text=alt_texts[0]
             )
-            container_id = container_response.data["id"]
 
-            # Step 2: Publish container
-            publish_response = await self.api_client.post(
-                f"/{self.instagram_account_id}/media_publish",
-                data={
-                    "creation_id": container_id,
-                    "access_token": self.credentials.access_token,
-                },
+        # Create container and publish
+        container_ids = await self._media_manager.create_feed_containers(
+            [media_item],
+            caption=request.content,
+            location_id=location_id,
+            share_to_feed=share_to_feed,
+        )
+
+        result = await self._media_manager.publish_container(container_ids[0])
+        return await self.get_post(result.media_id)
+
+    async def _create_carousel_post(self, request: PostCreateRequest) -> Post:
+        """Create a carousel post (2-10 images).
+
+        Args:
+            request: Post creation request.
+
+        Returns:
+            Created Post object.
+        """
+        # Extract options from additional_data
+        alt_texts = request.additional_data.get("alt_texts")
+        location_id = request.additional_data.get("location_id") or request.location
+
+        return await self.create_carousel(
+            media_urls=request.media_urls,
+            caption=request.content,
+            alt_texts=alt_texts,
+            location_id=location_id,
+        )
+
+    async def _create_reel_post(self, request: PostCreateRequest) -> Post:
+        """Create a Reel (video post).
+
+        Args:
+            request: Post creation request.
+
+        Returns:
+            Created Post object.
+        """
+        if not request.media_urls:
+            raise ValidationError(
+                "Reel requires a video URL",
+                platform=self.platform_name,
+                field="media_urls",
             )
-            post_id = publish_response.data["id"]
 
-            # Fetch full post details
-            return await self.get_post(post_id)
+        # Extract reel-specific options from additional_data
+        cover_url = request.additional_data.get("cover_url")
+        share_to_feed = request.additional_data.get("share_to_feed", True)
 
-        except httpx.HTTPError as e:
-            raise MediaUploadError(
-                f"Failed to create Instagram post: {e}",
+        return await self.create_reel(
+            video_url=request.media_urls[0],
+            caption=request.content,
+            cover_url=cover_url,
+            share_to_feed=share_to_feed,
+        )
+
+    async def _create_story_post(self, request: PostCreateRequest) -> Post:
+        """Create an Instagram Story.
+
+        Args:
+            request: Post creation request.
+
+        Returns:
+            Created Post object.
+        """
+        if not request.media_urls:
+            raise ValidationError(
+                "Story requires a media URL",
                 platform=self.platform_name,
-            ) from e
+                field="media_urls",
+            )
+
+        # Determine if it's image or video from additional_data or file extension
+        story_media_type: Literal["image", "video"] = "image"
+
+        # Check additional_data for explicit type
+        if request.additional_data.get("story_media_type"):
+            story_media_type = request.additional_data["story_media_type"]
+        else:
+            # Auto-detect from URL extension
+            url_lower = request.media_urls[0].lower()
+            video_extensions = (".mp4", ".mov", ".avi", ".webm")
+            if any(url_lower.endswith(ext) for ext in video_extensions):
+                story_media_type = "video"
+
+        return await self.create_story(
+            media_url=request.media_urls[0],
+            media_type=story_media_type,
+        )
 
     async def get_post(self, post_id: str) -> Post:
         """Retrieve an Instagram post by ID.

marqetive/platforms/tiktok/client.py

@@ -231,15 +231,26 @@ class TikTokClient(SocialMediaPlatform):
             wait_for_publish=True,
         )
 
-        if not upload_result.video_id:
-            raise PlatformError(
-                "Video upload succeeded but no video ID returned. "
-                "Video may still be processing.",
-                platform=self.platform_name,
-            )
+        # 4. Return post - either fetch full details or create minimal Post
+        if upload_result.video_id:
+            # Fetch the created post to return full Post object
+            return await self.get_post(upload_result.video_id)
 
-        # 4. Fetch the created post to return full Post object
-        return await self.get_post(upload_result.video_id)
+        # For private/SELF_ONLY posts, TikTok may not return video_id
+        # Return a minimal Post object with publish_id
+        return Post(
+            post_id=upload_result.publish_id,
+            platform=self.platform_name,
+            content=request.content,
+            status=PostStatus.PUBLISHED,
+            created_at=datetime.now(),
+            raw_data={
+                "publish_id": upload_result.publish_id,
+                "upload_status": upload_result.status,
+                "privacy_level": privacy_level.value,
+                "note": "Video published but video_id not returned (common for private posts)",
+            },
+        )
 
     async def get_post(self, post_id: str) -> Post:
         """Retrieve a TikTok video by its ID.

marqetive/platforms/tiktok/media.py

@@ -531,12 +531,22 @@ class TikTokMediaManager:
         result_data = data.get("data", {})
         status = result_data.get("status", PublishStatus.FAILED)
 
+        logger.debug(f"TikTok publish status response: {data}")
+
         video_id = None
         if status == PublishStatus.PUBLISH_COMPLETE:
-            # Video IDs are in publicaly_available_post_id array
+            # Video IDs are in publicaly_available_post_id array (note TikTok's typo)
+            # For private/SELF_ONLY posts, this may be empty
             video_ids = result_data.get("publicaly_available_post_id", [])
             if video_ids:
                 video_id = str(video_ids[0])
+            else:
+                # Try alternative field names that TikTok might use
+                video_id = result_data.get("video_id") or result_data.get("item_id")
+                logger.warning(
+                    f"No video ID in publicaly_available_post_id, "
+                    f"tried alternatives: video_id={video_id}"
+                )
 
         return MediaUploadResult(
             publish_id=publish_id,
@@ -713,6 +723,11 @@ class TikTokMediaManager:
     def _normalize_chunk_size(self, chunk_size: int, file_size: int) -> int:
         """Normalize chunk size to TikTok's requirements.
 
+        TikTok chunk requirements:
+        - Minimum chunk size: 5MB (except for files smaller than 5MB)
+        - Maximum chunk size: 64MB (final chunk can be up to 128MB)
+        - All non-final chunks must be at least MIN_CHUNK_SIZE
+
         Args:
             chunk_size: Requested chunk size.
             file_size: Total file size.
@@ -720,13 +735,27 @@ class TikTokMediaManager:
         Returns:
             Normalized chunk size within TikTok limits.
         """
-        # Files smaller than MIN_CHUNK_SIZE must be uploaded as single chunk
-        if file_size < MIN_CHUNK_SIZE:
+        # Files smaller than MAX_CHUNK_SIZE (64MB) should be uploaded as single chunk
+        # This avoids issues with the final chunk being smaller than MIN_CHUNK_SIZE
+        if file_size <= MAX_CHUNK_SIZE:
             return file_size
 
-        # Ensure within limits
+        # For larger files, ensure chunk size is within limits
         chunk_size = max(MIN_CHUNK_SIZE, min(chunk_size, MAX_CHUNK_SIZE))
 
+        # Ensure the last chunk won't be smaller than MIN_CHUNK_SIZE
+        # If it would be, increase chunk size to make fewer, larger chunks
+        total_chunks = math.ceil(file_size / chunk_size)
+        last_chunk_size = file_size - (chunk_size * (total_chunks - 1))
+
+        if last_chunk_size < MIN_CHUNK_SIZE and total_chunks > 1:
+            # Recalculate to have fewer chunks with larger size
+            # Use ceiling division to ensure last chunk is large enough
+            total_chunks = math.ceil(file_size / MAX_CHUNK_SIZE)
+            chunk_size = math.ceil(file_size / total_chunks)
+            # Ensure still within limits
+            chunk_size = max(MIN_CHUNK_SIZE, min(chunk_size, MAX_CHUNK_SIZE))
+
         return chunk_size
 
     def _validate_media(self, mime_type: str, file_size: int) -> None:

{marqetive_lib-0.1.8.dist-info → marqetive_lib-0.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: marqetive-lib
-Version: 0.1.8
+Version: 0.1.10
 Summary: Modern Python utilities for web APIs
 Keywords: api,utilities,web,http,marqetive
 Requires-Python: >=3.12

{marqetive_lib-0.1.8.dist-info → marqetive_lib-0.1.10.dist-info}/RECORD

@@ -7,7 +7,7 @@ marqetive/core/models.py,sha256=L2gA4FhW0feAXQFsz2ce1ttd0vScMRhatoTclhDGCU0,1472
 marqetive/factory.py,sha256=irZ5oN8a__kXZH70UN2uI7TzqTXu66d4QZ1FoxSoiK8,14092
 marqetive/platforms/__init__.py,sha256=RBxlQSGyELsulSnwf5uaE1ohxFc7jC61OO9CrKaZp48,1312
 marqetive/platforms/instagram/__init__.py,sha256=c1Gs0ozG6D7Z-Uz_UQ7S3joL0qUTT9eUZPWcePyESk8,229
-marqetive/platforms/instagram/client.py,sha256=vOx5HpgrxanBIFFC9VgmCNguH-njRGChnyp6Rr1r1Xc,26191
+marqetive/platforms/instagram/client.py,sha256=_ccxn3RUZDooR2w-vQocsxhctRB_MAhn3ZKQroJMv8c,32217
 marqetive/platforms/instagram/exceptions.py,sha256=TcD_pX4eSx_k4yW8DgfA6SGPiAz3VW7cMqM8DmiXIhg,8978
 marqetive/platforms/instagram/media.py,sha256=0ZbUbpwJ025_hccL9X8qced_-LJGoL_-NdS84Op97VE,23228
 marqetive/platforms/instagram/models.py,sha256=20v3m1037y3b_WlsKF8zAOgV23nFu63tfmmUN1CefOI,2769
@@ -17,9 +17,9 @@ marqetive/platforms/linkedin/exceptions.py,sha256=i5fARUkZik46bS3htZBwUInVzetsZx
 marqetive/platforms/linkedin/media.py,sha256=iWXUfqDYGsrTqeM6CGZ7a8xjpbdJ5qESolQL8Fv2PIg,20341
 marqetive/platforms/linkedin/models.py,sha256=n7DqwVxYSbGYBmeEJ1woCZ6XhUIHcLx8Gpm8uCBACzI,12620
 marqetive/platforms/tiktok/__init__.py,sha256=BqjkXTZDyBlcY3lvREy13yP9h3RcDga8E6Rl6f5KPp8,238
-marqetive/platforms/tiktok/client.py,sha256=wCCCFQ4mGiZrrGYjRUCUngz6_eqf4G6BUxYxw8szpig,17178
+marqetive/platforms/tiktok/client.py,sha256=ErhJOskyWVJP1nfLeJl09fGEyVh3QEhjYCgRlVLV-JY,17704
 marqetive/platforms/tiktok/exceptions.py,sha256=vxwyAKujMGZJh0LetG1QsLF95QfUs_kR6ujsWSHGqL0,10124
-marqetive/platforms/tiktok/media.py,sha256=bPQmyVL8egb4teXQDzxQvWLwg2EnBh4Ik6lz20ReFvg,27008
+marqetive/platforms/tiktok/media.py,sha256=aa47EDRA7woKGqKZkl_5XWu7kcRp2nT93Ol2skEQJpY,28592
 marqetive/platforms/tiktok/models.py,sha256=WWdjuFqhTIR8SnHkz-8UaNc5Mm2PrGomwQ3W7pJcQFg,2962
 marqetive/platforms/twitter/__init__.py,sha256=dvcgVT-v-JOtjSz-OUvxGrn_43OI6w_ep42Wx_nHTSM,217
 marqetive/platforms/twitter/client.py,sha256=08jV2hQVmGOpnG3C05u7bCqL7KapWn7bSsG0wbN_t5M,23270
@@ -34,6 +34,6 @@ marqetive/utils/media.py,sha256=O1rISYdaP3CuuPxso7kqvxWXNfe2jjioNkaBc4cpwkY,1466
 marqetive/utils/oauth.py,sha256=1SkYCE6dcyPvcDqbjRFSSBcKTwLJy8u3jAANPdftVmo,13108
 marqetive/utils/retry.py,sha256=lAniJLMNWp9XsHrvU0XBNifpNEjfde4MGfd5hlFTPfA,7636
 marqetive/utils/token_validator.py,sha256=dNvDeHs2Du5UyMMH2ZOW6ydR7OwOEKA4c9e-rG0f9-0,6698
-marqetive_lib-0.1.8.dist-info/METADATA,sha256=q99TsfInwfKVr_zoFnkvM3Wvb5cGZ7Nj6qQikle5EG4,7875
-marqetive_lib-0.1.8.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-marqetive_lib-0.1.8.dist-info/RECORD,,
+marqetive_lib-0.1.10.dist-info/METADATA,sha256=oFcLMxRxsYYnE1CQDOh2LZ0OCY3GY_n5FNgDFJ9h9_8,7876
+marqetive_lib-0.1.10.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+marqetive_lib-0.1.10.dist-info/RECORD,,