marqetive-lib 0.1.8__tar.gz → 0.1.9__tar.gz

{marqetive_lib-0.1.8 → marqetive_lib-0.1.9}/PKG-INFO

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

{marqetive_lib-0.1.8 → marqetive_lib-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "marqetive-lib"
-version = "0.1.8"
+version = "0.1.9"
 description = "Modern Python utilities for web APIs"
 readme = "README.md"
 requires-python = ">=3.12"

{marqetive_lib-0.1.8 → marqetive_lib-0.1.9}/src/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_lib-0.1.8 → marqetive_lib-0.1.9}/src/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: