marqetive-lib 0.1.17__py3-none-any.whl → 0.1.18__py3-none-any.whl

marqetive/platforms/linkedin/client.py

@@ -46,6 +46,24 @@ from marqetive.platforms.linkedin.models import (
     SocialMetadata,
 )
 
+# Valid CTA (Call-To-Action) labels per LinkedIn API documentation
+# Note: BUY_NOW and SHOP_NOW require API version 202504 or later
+VALID_CTA_LABELS = frozenset({
+    "APPLY",
+    "DOWNLOAD",
+    "VIEW_QUOTE",
+    "LEARN_MORE",
+    "SIGN_UP",
+    "SUBSCRIBE",
+    "REGISTER",
+    "JOIN",
+    "ATTEND",
+    "REQUEST_DEMO",
+    "SEE_MORE",
+    "BUY_NOW",  # Requires API version 202504+
+    "SHOP_NOW",  # Requires API version 202504+
+})
+
 
 class LinkedInClient(SocialMediaPlatform):
     """LinkedIn API client using the Community Management API.
@@ -307,29 +325,111 @@ class LinkedInClient(SocialMediaPlatform):
         """Create and publish a LinkedIn post.
 
         Uses the Community Management API to create posts on personal profiles
-        or organization pages.
+        or organization pages. Supports text, images, videos, documents,
+        multi-image posts, articles, and Direct Sponsored Content (dark posts).
 
         Args:
-            request: Post creation request. Use additional_data for LinkedIn-specific
-                options like visibility, distribution, and call-to-action.
+            request: Post creation request with the following fields:
+                - content: Post text (max 3000 chars). Supports mentions and hashtags.
+                - link: URL for article posts.
+                - media_ids: List of media URNs (images, videos, documents).
+                - additional_data: LinkedIn-specific options (see below).
+
+        Additional Data Options:
+            Basic options:
+                - visibility: "PUBLIC" (default), "CONNECTIONS", "LOGGED_IN"
+                - feed_distribution: "MAIN_FEED" (default), "NONE" (for dark posts)
+                - disable_reshare: bool (default False)
+
+            Call-to-action:
+                - call_to_action: CTA label (APPLY, DOWNLOAD, VIEW_QUOTE, LEARN_MORE,
+                    SIGN_UP, SUBSCRIBE, REGISTER, JOIN, ATTEND, REQUEST_DEMO,
+                    SEE_MORE, BUY_NOW, SHOP_NOW)
+                - landing_page: URL for CTA button
+
+            Media options:
+                - media_title: Title for single media
+                - media_alt_text: Alt text for single media
+                - media_alt_texts: List of alt texts for multi-image posts
+
+            Article options:
+                - article_title: Title for link preview
+                - article_description: Description for link preview
+                - article_thumbnail: Image URN for article thumbnail
+
+            Targeting (for targeted posts):
+                - target_entities: List of targeting criteria
+
+            Direct Sponsored Content (dark posts):
+                - ad_context: Dict with DSC configuration:
+                    - is_dsc: True for dark posts
+                    - dsc_ad_type: VIDEO, STANDARD, CAROUSEL, JOB_POSTING,
+                        NATIVE_DOCUMENT, EVENT
+                    - dsc_status: ACTIVE, ARCHIVED
+                    - dsc_ad_account: Sponsored account URN
+                    - dsc_name: Display name for the DSC
+
+        Mentions and Hashtags:
+            Use these formats in the content field:
+            - Organization mention: @[Display Name](urn:li:organization:12345)
+            - Person mention: @[Jane Smith](urn:li:person:abc123)
+            - Hashtag: #coding (plain text, auto-formatted by LinkedIn)
+
+            Note: Organization names in mentions must match exactly (case-sensitive).
 
         Returns:
             Created Post object.
 
         Raises:
-            ValidationError: If request is invalid.
+            ValidationError: If request is invalid or CTA label is invalid.
             MediaUploadError: If media upload fails.
 
         Example:
+            >>> # Text post with link and CTA
             >>> request = PostCreateRequest(
             ...     content="Check out our new product!",
             ...     link="https://example.com/product",
             ...     additional_data={
             ...         "visibility": "PUBLIC",
-            ...         "call_to_action": "LEARN_MORE"
+            ...         "call_to_action": "LEARN_MORE",
+            ...         "landing_page": "https://example.com/signup"
+            ...     }
+            ... )
+            >>> post = await client.create_post(request)
+            >>>
+            >>> # Multi-image post
+            >>> img1 = await client.upload_image("photo1.jpg")
+            >>> img2 = await client.upload_image("photo2.jpg")
+            >>> request = PostCreateRequest(
+            ...     content="Check out these photos!",
+            ...     media_ids=[img1.asset_id, img2.asset_id],
+            ...     additional_data={
+            ...         "media_alt_texts": ["First photo", "Second photo"]
+            ...     }
+            ... )
+            >>> post = await client.create_post(request)
+            >>>
+            >>> # Dark post (Direct Sponsored Content)
+            >>> request = PostCreateRequest(
+            ...     content="Sponsored content",
+            ...     media_ids=[video_asset.asset_id],
+            ...     additional_data={
+            ...         "ad_context": {
+            ...             "is_dsc": True,
+            ...             "dsc_ad_type": "VIDEO",
+            ...             "dsc_status": "ACTIVE",
+            ...             "dsc_ad_account": "urn:li:sponsoredAccount:123"
+            ...         }
             ...     }
             ... )
             >>> post = await client.create_post(request)
+            >>>
+            >>> # Post with mentions and hashtags
+            >>> request = PostCreateRequest(
+            ...     content="Excited to announce our partnership with "
+            ...             "@[LinkedIn](urn:li:organization:1337)! #exciting #partnership"
+            ... )
+            >>> post = await client.create_post(request)
         """
         if not self.api_client:
             raise RuntimeError("Client must be used as async context manager")
@@ -370,23 +470,37 @@ class LinkedInClient(SocialMediaPlatform):
                 ),
             }
 
-            # Add media content if provided
+            # Add media content if provided (images, videos, or documents)
             if request.media_ids:
-                # Determine media type from URN prefix
-                media_id = request.media_ids[0]
-                post_payload["content"] = {
-                    "media": {
-                        "id": media_id,
-                        "title": request.additional_data.get("media_title"),
-                        "altText": request.additional_data.get("media_alt_text"),
+                if len(request.media_ids) > 1:
+                    # Multi-image post (organic only, not for sponsored content)
+                    # Per docs: use "multiImage" content type with array of images
+                    images = []
+                    for media_id in request.media_ids:
+                        image_entry: dict[str, Any] = {"id": media_id}
+                        # Alt text can be provided per image via additional_data
+                        alt_texts = request.additional_data.get("media_alt_texts", [])
+                        if alt_texts and len(alt_texts) > len(images):
+                            image_entry["altText"] = alt_texts[len(images)]
+                        images.append(image_entry)
+
+                    post_payload["content"] = {"multiImage": {"images": images}}
+                else:
+                    # Single media (image, video, or document)
+                    media_id = request.media_ids[0]
+                    post_payload["content"] = {
+                        "media": {
+                            "id": media_id,
+                            "title": request.additional_data.get("media_title"),
+                            "altText": request.additional_data.get("media_alt_text"),
+                        }
+                    }
+                    # Remove None values
+                    post_payload["content"]["media"] = {
+                        k: v
+                        for k, v in post_payload["content"]["media"].items()
+                        if v is not None
                     }
-                }
-                # Remove None values
-                post_payload["content"]["media"] = {
-                    k: v
-                    for k, v in post_payload["content"]["media"].items()
-                    if v is not None
-                }
 
             # Add article/link if provided (and no media)
             elif request.link:
@@ -411,10 +525,40 @@ class LinkedInClient(SocialMediaPlatform):
 
             # Add call-to-action if provided
             if cta := request.additional_data.get("call_to_action"):
-                post_payload["contentCallToActionLabel"] = cta
+                cta_upper = cta.upper()
+                if cta_upper not in VALID_CTA_LABELS:
+                    raise ValidationError(
+                        f"Invalid call_to_action: '{cta}'. "
+                        f"Valid values: {', '.join(sorted(VALID_CTA_LABELS))}",
+                        platform=self.platform_name,
+                        field="call_to_action",
+                    )
+                post_payload["contentCallToActionLabel"] = cta_upper
             if landing_page := request.additional_data.get("landing_page"):
                 post_payload["contentLandingPage"] = landing_page
 
+            # Add adContext for Direct Sponsored Content (DSC) / dark posts
+            # Dark posts don't appear on company page but can be used in ad campaigns
+            if ad_context := request.additional_data.get("ad_context"):
+                post_payload["adContext"] = {}
+                if ad_context.get("is_dsc"):
+                    post_payload["adContext"]["isDsc"] = True
+                if dsc_ad_type := ad_context.get("dsc_ad_type"):
+                    # Valid types: VIDEO, STANDARD, CAROUSEL, JOB_POSTING,
+                    # NATIVE_DOCUMENT, EVENT
+                    post_payload["adContext"]["dscAdType"] = dsc_ad_type
+                if dsc_status := ad_context.get("dsc_status"):
+                    # Valid values: ACTIVE, ARCHIVED
+                    post_payload["adContext"]["dscStatus"] = dsc_status
+                if dsc_ad_account := ad_context.get("dsc_ad_account"):
+                    post_payload["adContext"]["dscAdAccount"] = dsc_ad_account
+                if dsc_name := ad_context.get("dsc_name"):
+                    post_payload["adContext"]["dscName"] = dsc_name
+
+                # For dark posts, set feedDistribution to NONE
+                if ad_context.get("is_dsc"):
+                    post_payload["distribution"]["feedDistribution"] = "NONE"
+
             # Create the post
             response = await self.api_client.post("/posts", data=post_payload)
 
@@ -534,7 +678,15 @@ class LinkedInClient(SocialMediaPlatform):
             # Handle additional LinkedIn-specific fields
             additional = getattr(request, "additional_data", {}) or {}
             if cta := additional.get("call_to_action"):
-                patch_payload["patch"]["$set"]["contentCallToActionLabel"] = cta
+                cta_upper = cta.upper()
+                if cta_upper not in VALID_CTA_LABELS:
+                    raise ValidationError(
+                        f"Invalid call_to_action: '{cta}'. "
+                        f"Valid values: {', '.join(sorted(VALID_CTA_LABELS))}",
+                        platform=self.platform_name,
+                        field="call_to_action",
+                    )
+                patch_payload["patch"]["$set"]["contentCallToActionLabel"] = cta_upper
             if landing_page := additional.get("landing_page"):
                 patch_payload["patch"]["$set"]["contentLandingPage"] = landing_page
             if lifecycle := additional.get("lifecycle_state"):
@@ -597,9 +749,13 @@ class LinkedInClient(SocialMediaPlatform):
                 raise RuntimeError("API client not initialized")
 
             encoded_post_id = quote(post_id, safe="")
+            headers = {
+                **self._build_auth_headers(),
+                "X-RestLi-Method": "DELETE",
+            }
             await self.api_client._client.delete(
                 f"{self.base_url}/posts/{encoded_post_id}",
-                headers=self._build_auth_headers(),
+                headers=headers,
             )
             return True
 
@@ -693,6 +849,204 @@ class LinkedInClient(SocialMediaPlatform):
                 platform=self.platform_name,
             ) from e
 
+    async def create_reshare(
+        self,
+        parent_post_urn: str,
+        commentary: str | None = None,
+        visibility: str = "PUBLIC",
+    ) -> Post:
+        """Create a reshare (repost) of an existing LinkedIn post.
+
+        Args:
+            parent_post_urn: URN of the post to reshare (urn:li:share:xxx or urn:li:ugcPost:xxx).
+            commentary: Optional commentary to add to the reshare.
+            visibility: Post visibility (PUBLIC, CONNECTIONS, LOGGED_IN).
+
+        Returns:
+            Created Post object.
+
+        Raises:
+            ValidationError: If parent_post_urn is invalid.
+
+        Example:
+            >>> reshare = await client.create_reshare(
+            ...     "urn:li:share:6957408550713184256",
+            ...     commentary="Great insights!"
+            ... )
+        """
+        if not self.api_client:
+            raise RuntimeError("Client must be used as async context manager")
+
+        try:
+            post_payload: dict[str, Any] = {
+                "author": self.author_urn,
+                "visibility": visibility,
+                "distribution": {
+                    "feedDistribution": "MAIN_FEED",
+                    "targetEntities": [],
+                    "thirdPartyDistributionChannels": [],
+                },
+                "lifecycleState": "PUBLISHED",
+                "reshareContext": {
+                    "parent": parent_post_urn,
+                },
+            }
+
+            if commentary:
+                post_payload["commentary"] = commentary
+
+            response = await self.api_client.post("/posts", data=post_payload)
+
+            post_id = response.data.get("id") or response.headers.get("x-restli-id")
+            if not post_id:
+                raise PlatformError(
+                    "Failed to get post ID from response",
+                    platform=self.platform_name,
+                )
+
+            return Post(
+                post_id=post_id,
+                platform=self.platform_name,
+                content=commentary or "",
+                status=PostStatus.PUBLISHED,
+                created_at=datetime.now(),
+                author_id=self.author_urn,
+                raw_data=response.data,
+            )
+
+        except httpx.HTTPError as e:
+            raise PlatformError(
+                f"Failed to create reshare: {e}",
+                platform=self.platform_name,
+            ) from e
+
+    async def batch_get_posts(self, post_ids: list[str]) -> list[Post]:
+        """Retrieve multiple posts by their URNs in a single request.
+
+        Uses the BATCH_GET method for efficient retrieval of multiple posts.
+
+        Args:
+            post_ids: List of post URNs (urn:li:share:xxx or urn:li:ugcPost:xxx).
+
+        Returns:
+            List of Post objects (in the same order as input if available).
+
+        Example:
+            >>> posts = await client.batch_get_posts([
+            ...     "urn:li:share:123",
+            ...     "urn:li:ugcPost:456"
+            ... ])
+        """
+        if not self.api_client:
+            raise RuntimeError("Client must be used as async context manager")
+
+        if not self.api_client._client:
+            raise RuntimeError("API client not initialized")
+
+        if not post_ids:
+            return []
+
+        try:
+            # URL encode each post ID
+            encoded_ids = [quote(pid, safe="") for pid in post_ids]
+            ids_param = f"List({','.join(encoded_ids)})"
+
+            headers = {
+                **self._build_auth_headers(),
+                "X-RestLi-Method": "BATCH_GET",
+            }
+
+            response = await self.api_client._client.get(
+                f"{self.base_url}/posts",
+                params={"ids": ids_param},
+                headers=headers,
+            )
+
+            data = response.json()
+            results = data.get("results", {})
+
+            # Parse posts, maintaining order where possible
+            posts = []
+            for post_id in post_ids:
+                if post_id in results:
+                    posts.append(self._parse_post(results[post_id]))
+
+            return posts
+
+        except httpx.HTTPError as e:
+            raise PlatformError(
+                f"Failed to batch get posts: {e}",
+                platform=self.platform_name,
+            ) from e
+
+    async def list_dsc_posts(
+        self,
+        dsc_ad_account: str,
+        dsc_ad_types: list[str] | None = None,
+        limit: int = 10,
+        offset: int = 0,
+    ) -> list[Post]:
+        """List Direct Sponsored Content (DSC) posts by ad account.
+
+        Args:
+            dsc_ad_account: Sponsored account URN (urn:li:sponsoredAccount:xxx).
+            dsc_ad_types: Optional filter by DSC types (VIDEO, STANDARD, CAROUSEL,
+                JOB_POSTING, NATIVE_DOCUMENT, EVENT).
+            limit: Maximum number of posts to retrieve (max 100).
+            offset: Number of posts to skip for pagination.
+
+        Returns:
+            List of Post objects.
+
+        Example:
+            >>> dsc_posts = await client.list_dsc_posts(
+            ...     "urn:li:sponsoredAccount:520866471",
+            ...     dsc_ad_types=["VIDEO", "STANDARD"]
+            ... )
+        """
+        if not self.api_client:
+            raise RuntimeError("Client must be used as async context manager")
+
+        if not self.api_client._client:
+            raise RuntimeError("API client not initialized")
+
+        try:
+            encoded_account = quote(dsc_ad_account, safe="")
+
+            params: dict[str, Any] = {
+                "dscAdAccount": encoded_account,
+                "q": "dscAdAccount",
+                "count": min(limit, 100),
+                "start": offset,
+            }
+
+            if dsc_ad_types:
+                params["dscAdTypes"] = f"List({','.join(dsc_ad_types)})"
+
+            headers = {
+                **self._build_auth_headers(),
+                "X-RestLi-Method": "FINDER",
+            }
+
+            response = await self.api_client._client.get(
+                f"{self.base_url}/posts",
+                params=params,
+                headers=headers,
+            )
+
+            posts = []
+            data = response.json()
+            for post_data in data.get("elements", []):
+                posts.append(self._parse_post(post_data))
+
+            return posts
+
+        except httpx.HTTPError as e:
+            raise PlatformError(
+                f"Failed to list DSC posts: {e}",
+                platform=self.platform_name,
+            ) from e
+
     # ==================== Comment Methods ====================
 
     async def get_comments(
@@ -1098,20 +1452,25 @@ class LinkedInClient(SocialMediaPlatform):
         *,
         title: str | None = None,
     ) -> MediaAsset:
-        """Upload a document/PDF to LinkedIn.
+        """Upload a document to LinkedIn using the Documents API.
 
-        Convenience method for document uploads.
+        Convenience method for document uploads. Supports PDF, PPT, PPTX, DOC, DOCX.
 
         Args:
-            file_path: Path to PDF file or URL.
-            title: Document title.
+            file_path: Path to document file or URL.
+            title: Document title (reserved for future use).
 
         Returns:
-            MediaAsset with asset ID.
+            MediaAsset with document URN (urn:li:document:xxx).
 
         Example:
             >>> async with LinkedInClient(credentials) as client:
             ...     asset = await client.upload_document("report.pdf")
+            ...     request = PostCreateRequest(
+            ...         content="Check out our report!",
+            ...         media_ids=[asset.asset_id]
+            ...     )
+            ...     post = await client.create_post(request)
         """
         if not self._media_manager:
             raise RuntimeError("Client must be used as async context manager")

marqetive/platforms/linkedin/media.py

@@ -1,13 +1,19 @@
 """LinkedIn media upload manager with support for images, videos, and documents.
 
-LinkedIn uses a multi-step upload process:
-1. Register upload (get upload URL)
-2. Upload file to the URL
-3. Complete upload (finalize)
+LinkedIn uses the REST API for media uploads (Community Management API):
+- Images API: POST /rest/images?action=initializeUpload
+- Videos API: POST /rest/videos?action=initializeUpload + finalizeUpload
+- Documents API: POST /rest/documents?action=initializeUpload
+
+Upload process:
+1. Initialize upload (get upload URL and asset URN)
+2. Upload file to the URL (PUT)
+3. For videos: Finalize upload with ETags from each chunk
+4. For videos: Wait for processing to complete
 
 This module supports:
 - Image uploads (single and multiple)
-- Video uploads with processing monitoring
+- Video uploads with chunked upload and processing monitoring
 - Document/PDF uploads
 """
 
@@ -37,23 +43,44 @@ type ProgressCallback = SyncProgressCallback | AsyncProgressCallback
 
 logger = logging.getLogger(__name__)
 
-# LinkedIn limits
+# LinkedIn limits (per REST API documentation)
 MAX_IMAGE_SIZE = 10 * 1024 * 1024  # 10MB
-MAX_VIDEO_SIZE = 200 * 1024 * 1024  # 200MB
-MAX_DOCUMENT_SIZE = 10 * 1024 * 1024  # 10MB
-MAX_VIDEO_DURATION = 600  # 10 minutes
+MAX_VIDEO_SIZE = 5 * 1024 * 1024 * 1024  # 5GB (for multi-part uploads)
+MAX_VIDEO_SIZE_SINGLE = 200 * 1024 * 1024  # 200MB (practical limit for single upload)
+MAX_DOCUMENT_SIZE = 100 * 1024 * 1024  # 100MB (per LinkedIn docs)
+MAX_VIDEO_DURATION = 1800  # 30 minutes (per docs: 3 seconds to 30 minutes)
+MAX_DOCUMENT_PAGES = 300  # Maximum pages for documents
+
+# Video chunk size for multi-part uploads (per LinkedIn docs: 4MB per part)
+VIDEO_CHUNK_SIZE = 4 * 1024 * 1024  # 4MB (4,194,304 bytes)
+
+# Supported document MIME types
+SUPPORTED_DOCUMENT_TYPES = {
+    "application/pdf",
+    "application/vnd.ms-powerpoint",  # PPT
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",  # PPTX
+    "application/msword",  # DOC
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",  # DOCX
+}
 
 # Processing timeouts
 VIDEO_PROCESSING_TIMEOUT = 600  # 10 minutes
 
 
 class VideoProcessingState(str, Enum):
-    """LinkedIn video processing states."""
+    """LinkedIn video processing states (per REST Videos API).
+
+    Status values:
+        PROCESSING: Asset processing to generate missing artifacts
+        PROCESSING_FAILED: Processing failed (file size, format, internal error)
+        AVAILABLE: Ready for use; all required artifacts available
+        WAITING_UPLOAD: Waiting for source file upload completion
+    """
 
     PROCESSING = "PROCESSING"
-    READY = "READY"
-    FAILED = "FAILED"
+    PROCESSING_FAILED = "PROCESSING_FAILED"
     AVAILABLE = "AVAILABLE"
+    WAITING_UPLOAD = "WAITING_UPLOAD"
 
 
 @dataclass
@@ -134,9 +161,8 @@ class LinkedInMediaManager:
         self.timeout = timeout
         self.progress_callback = progress_callback
 
-        # Use v2 API for media uploads (still uses assets endpoint)
-        # Note: Media registration still uses v2 API, not REST API
-        self.base_url = "https://api.linkedin.com/v2"
+        # Use REST API for media uploads (Community Management API)
+        self.base_url = "https://api.linkedin.com/rest"
         self.client = httpx.AsyncClient(
             timeout=httpx.Timeout(timeout),
             headers={
@@ -199,22 +225,28 @@ class LinkedInMediaManager:
         *,
         alt_text: str | None = None,  # noqa: ARG002
     ) -> MediaAsset:
-        """Upload an image to LinkedIn.
+        """Upload an image to LinkedIn using the REST Images API.
+
+        Uses the REST API endpoint: POST /rest/images?action=initializeUpload
+        https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/images-api
 
         Args:
             file_path: Path to image file or URL.
-            alt_text: Alternative text for accessibility.
+            alt_text: Alternative text for accessibility (stored for reference).
 
         Returns:
-            MediaAsset with asset ID.
+            MediaAsset with image URN (urn:li:image:xxx).
 
         Raises:
             MediaUploadError: If upload fails.
             ValidationError: If file is invalid.
 
+        Supported formats:
+            JPG, GIF, PNG (GIF up to 250 frames)
+
         Example:
             >>> asset = await manager.upload_image("photo.jpg")
-            >>> print(f"Asset ID: {asset.asset_id}")
+            >>> print(f"Image URN: {asset.asset_id}")
         """
         # Download if URL
         if file_path.startswith(("http://", "https://")):
@@ -238,52 +270,76 @@ class LinkedInMediaManager:
                 platform="linkedin",
             )
 
-        # Register upload
-        register_data = {
-            "registerUploadRequest": {
-                "recipes": ["urn:li:digitalmediaRecipe:feedshare-image"],
-                "owner": self.person_urn,
-                "serviceRelationships": [
-                    {
-                        "relationshipType": "OWNER",
-                        "identifier": "urn:li:userGeneratedContent",
-                    }
-                ],
-            }
-        }
+        # Step 1: Initialize upload using REST Images API
+        init_payload = {"initializeUploadRequest": {"owner": self.person_urn}}
 
-        asset_id = await self._register_upload(register_data)
+        try:
+            response = await self.client.post(
+                f"{self.base_url}/images?action=initializeUpload",
+                json=init_payload,
+            )
+            response.raise_for_status()
+            init_result = response.json()
+        except httpx.HTTPError as e:
+            raise MediaUploadError(
+                f"Failed to initialize image upload: {e}",
+                platform="linkedin",
+                media_type="image",
+            ) from e
+
+        # Extract upload URL and image URN from response
+        upload_url = init_result["value"]["uploadUrl"]
+        image_urn = init_result["value"]["image"]
 
         # Notify start
         await self._emit_progress(
             status=ProgressStatus.INITIALIZING,
             progress=0,
             total=100,
-            message="Registering upload",
-            entity_id=asset_id,
+            message="Registering image upload",
+            entity_id=image_urn,
             bytes_uploaded=0,
             total_bytes=file_size,
         )
 
-        # Get upload URL
-        upload_url = await self._get_upload_url(asset_id)
+        # Step 2: Upload image binary via PUT
+        await self._emit_progress(
+            status=ProgressStatus.UPLOADING,
+            progress=0,
+            total=100,
+            message="Uploading image",
+            entity_id=image_urn,
+            bytes_uploaded=0,
+            total_bytes=file_size,
+        )
 
-        # Upload file
-        await self._upload_to_url(upload_url, file_bytes, file_size, asset_id)
+        try:
+            upload_response = await self.client.put(
+                upload_url,
+                content=file_bytes,
+                headers={"Content-Type": "application/octet-stream"},
+            )
+            upload_response.raise_for_status()
+        except httpx.HTTPError as e:
+            raise MediaUploadError(
+                f"Failed to upload image binary: {e}",
+                platform="linkedin",
+                media_type="image",
+            ) from e
 
         # Notify completion
         await self._emit_progress(
             status=ProgressStatus.COMPLETED,
             progress=100,
             total=100,
-            message="Upload completed",
-            entity_id=asset_id,
+            message="Image upload completed",
+            entity_id=image_urn,
             bytes_uploaded=file_size,
             total_bytes=file_size,
         )
 
-        logger.info(f"Image uploaded successfully: {asset_id}")
-        return MediaAsset(asset_id=asset_id, status="READY")
+        logger.info(f"Image uploaded successfully: {image_urn}")
+        return MediaAsset(asset_id=image_urn, status="AVAILABLE")
 
     async def upload_video(
         self,
@@ -292,26 +348,39 @@ class LinkedInMediaManager:
         title: str | None = None,  # noqa: ARG002
         wait_for_processing: bool = True,
     ) -> MediaAsset:
-        """Upload a video to LinkedIn.
+        """Upload a video to LinkedIn using the REST Videos API.
+
+        Uses the REST API endpoints:
+        - POST /rest/videos?action=initializeUpload
+        - PUT {uploadUrl} (for each chunk)
+        - POST /rest/videos?action=finalizeUpload
+
+        https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/videos-api
 
         Args:
             file_path: Path to video file or URL.
-            title: Video title.
+            title: Video title (reserved for future use).
             wait_for_processing: Wait for video processing to complete.
 
         Returns:
-            MediaAsset with asset ID.
+            MediaAsset with video URN (urn:li:video:xxx).
 
         Raises:
             MediaUploadError: If upload or processing fails.
             ValidationError: If file is invalid.
 
+        Specifications:
+            - Length: 3 seconds to 30 minutes
+            - File size: 75 KB to 5 GB
+            - Format: MP4
+            - Chunk size: 4 MB per part (for multi-part uploads)
+
         Example:
             >>> asset = await manager.upload_video(
             ...     "video.mp4",
-            ...     title="My Video",
             ...     wait_for_processing=True
             ... )
+            >>> print(f"Video URN: {asset.asset_id}")
         """
         # Download if URL
         if file_path.startswith(("http://", "https://")):
@@ -335,21 +404,34 @@ class LinkedInMediaManager:
                 platform="linkedin",
             )
 
-        # Register upload
-        register_data = {
-            "registerUploadRequest": {
-                "recipes": ["urn:li:digitalmediaRecipe:feedshare-video"],
+        # Step 1: Initialize upload using REST Videos API
+        init_payload = {
+            "initializeUploadRequest": {
                 "owner": self.person_urn,
-                "serviceRelationships": [
-                    {
-                        "relationshipType": "OWNER",
-                        "identifier": "urn:li:userGeneratedContent",
-                    }
-                ],
+                "fileSizeBytes": file_size,
+                "uploadCaptions": False,
+                "uploadThumbnail": False,
             }
         }
 
-        asset_id = await self._register_upload(register_data)
+        try:
+            response = await self.client.post(
+                f"{self.base_url}/videos?action=initializeUpload",
+                json=init_payload,
+            )
+            response.raise_for_status()
+            init_result = response.json()
+        except httpx.HTTPError as e:
+            raise MediaUploadError(
+                f"Failed to initialize video upload: {e}",
+                platform="linkedin",
+                media_type="video",
+            ) from e
+
+        # Extract video URN and upload instructions
+        video_urn = init_result["value"]["video"]
+        upload_instructions = init_result["value"]["uploadInstructions"]
+        upload_token = init_result["value"].get("uploadToken", "")
 
         # Notify start
         await self._emit_progress(
@@ -357,20 +439,94 @@ class LinkedInMediaManager:
             progress=0,
             total=100,
             message="Registering video upload",
-            entity_id=asset_id,
+            entity_id=video_urn,
             bytes_uploaded=0,
             total_bytes=file_size,
         )
 
-        # Get upload URL
-        upload_url = await self._get_upload_url(asset_id)
+        # Step 2: Upload video in chunks and collect ETags
+        uploaded_part_ids: list[str] = []
+        total_chunks = len(upload_instructions)
+        bytes_uploaded = 0
+
+        for i, instruction in enumerate(upload_instructions):
+            upload_url = instruction["uploadUrl"]
+            first_byte = instruction["firstByte"]
+            last_byte = instruction["lastByte"]
 
-        # Upload file
-        await self._upload_to_url(upload_url, file_bytes, file_size, asset_id)
+            # Extract chunk from file bytes
+            chunk = file_bytes[first_byte : last_byte + 1]
+            chunk_size = len(chunk)
 
-        # Wait for processing if requested
+            # Notify progress
+            progress_pct = int((i / total_chunks) * 80)  # 80% for upload
+            await self._emit_progress(
+                status=ProgressStatus.UPLOADING,
+                progress=progress_pct,
+                total=100,
+                message=f"Uploading chunk {i + 1}/{total_chunks}",
+                entity_id=video_urn,
+                bytes_uploaded=bytes_uploaded,
+                total_bytes=file_size,
+            )
+
+            try:
+                upload_response = await self.client.put(
+                    upload_url,
+                    content=chunk,
+                    headers={"Content-Type": "application/octet-stream"},
+                )
+                upload_response.raise_for_status()
+
+                # Get ETag from response headers (required for finalization)
+                etag = upload_response.headers.get("etag")
+                if etag:
+                    uploaded_part_ids.append(etag)
+
+                bytes_uploaded += chunk_size
+
+            except httpx.HTTPError as e:
+                raise MediaUploadError(
+                    f"Failed to upload video chunk {i + 1}: {e}",
+                    platform="linkedin",
+                    media_type="video",
+                ) from e
+
+        # Step 3: Finalize upload
+        await self._emit_progress(
+            status=ProgressStatus.UPLOADING,
+            progress=85,
+            total=100,
+            message="Finalizing video upload",
+            entity_id=video_urn,
+            bytes_uploaded=file_size,
+            total_bytes=file_size,
+        )
+
+        finalize_payload = {
+            "finalizeUploadRequest": {
+                "video": video_urn,
+                "uploadToken": upload_token,
+                "uploadedPartIds": uploaded_part_ids,
+            }
+        }
+
+        try:
+            finalize_response = await self.client.post(
+                f"{self.base_url}/videos?action=finalizeUpload",
+                json=finalize_payload,
+            )
+            finalize_response.raise_for_status()
+        except httpx.HTTPError as e:
+            raise MediaUploadError(
+                f"Failed to finalize video upload: {e}",
+                platform="linkedin",
+                media_type="video",
+            ) from e
+
+        # Step 4: Wait for processing if requested
         if wait_for_processing:
-            await self._wait_for_video_processing(asset_id)
+            await self._wait_for_video_processing(video_urn)
 
         # Notify completion
         final_status = (
@@ -385,14 +541,15 @@ class LinkedInMediaManager:
             message=(
                 "Video upload completed" if wait_for_processing else "Video processing"
             ),
-            entity_id=asset_id,
+            entity_id=video_urn,
             bytes_uploaded=file_size,
             total_bytes=file_size,
         )
 
-        logger.info(f"Video uploaded successfully: {asset_id}")
+        logger.info(f"Video uploaded successfully: {video_urn}")
         return MediaAsset(
-            asset_id=asset_id, status="READY" if wait_for_processing else "PROCESSING"
+            asset_id=video_urn,
+            status="AVAILABLE" if wait_for_processing else "PROCESSING",
         )
 
     async def upload_document(
@@ -401,19 +558,25 @@ class LinkedInMediaManager:
         *,
         title: str | None = None,  # noqa: ARG002
     ) -> MediaAsset:
-        """Upload a document/PDF to LinkedIn.
+        """Upload a document to LinkedIn using the Documents API.
+
+        Uses the REST API endpoint /rest/documents as per LinkedIn documentation:
+        https://learn.microsoft.com/en-us/linkedin/marketing/community-management/shares/documents-api
 
         Args:
             file_path: Path to document file or URL.
-            title: Document title.
+            title: Document title (currently unused, reserved for future use).
 
         Returns:
-            MediaAsset with asset ID.
+            MediaAsset with document URN (urn:li:document:xxx).
 
         Raises:
             MediaUploadError: If upload fails.
             ValidationError: If file is invalid.
 
+        Supported formats:
+            PDF, PPT, PPTX, DOC, DOCX (max 100MB, 300 pages)
+
         Example:
             >>> asset = await manager.upload_document(
             ...     "presentation.pdf",
@@ -424,11 +587,12 @@ class LinkedInMediaManager:
         if file_path.startswith(("http://", "https://")):
             file_path = await download_file(file_path)
 
-        # Validate
+        # Validate MIME type
         mime_type = detect_mime_type(file_path)
-        if mime_type != "application/pdf":
+        if mime_type not in SUPPORTED_DOCUMENT_TYPES:
             raise ValidationError(
-                f"Only PDF documents are supported. Got: {mime_type}",
+                f"Unsupported document type: {mime_type}. "
+                f"Supported: PDF, PPT, PPTX, DOC, DOCX",
                 platform="linkedin",
             )
 
@@ -442,21 +606,27 @@ class LinkedInMediaManager:
                 platform="linkedin",
             )
 
-        # Register upload
-        register_data = {
-            "registerUploadRequest": {
-                "recipes": ["urn:li:digitalmediaRecipe:feedshare-document"],
-                "owner": self.person_urn,
-                "serviceRelationships": [
-                    {
-                        "relationshipType": "OWNER",
-                        "identifier": "urn:li:userGeneratedContent",
-                    }
-                ],
-            }
-        }
+        # Step 1: Initialize upload using REST documents API
+        # Per docs: POST /rest/documents?action=initializeUpload
+        init_payload = {"initializeUploadRequest": {"owner": self.person_urn}}
 
-        asset_id = await self._register_upload(register_data)
+        try:
+            response = await self.client.post(
+                f"{self.base_url}/documents?action=initializeUpload",
+                json=init_payload,
+            )
+            response.raise_for_status()
+            init_result = response.json()
+        except httpx.HTTPError as e:
+            raise MediaUploadError(
+                f"Failed to initialize document upload: {e}",
+                platform="linkedin",
+                media_type="document",
+            ) from e
+
+        # Extract upload URL and document URN from response
+        upload_url = init_result["value"]["uploadUrl"]
+        document_urn = init_result["value"]["document"]
 
         # Notify start
         await self._emit_progress(
@@ -464,16 +634,35 @@ class LinkedInMediaManager:
             progress=0,
             total=100,
             message="Registering document upload",
-            entity_id=asset_id,
+            entity_id=document_urn,
             bytes_uploaded=0,
             total_bytes=file_size,
         )
 
-        # Get upload URL
-        upload_url = await self._get_upload_url(asset_id)
+        # Step 2: Upload document binary via PUT
+        await self._emit_progress(
+            status=ProgressStatus.UPLOADING,
+            progress=0,
+            total=100,
+            message="Uploading document",
+            entity_id=document_urn,
+            bytes_uploaded=0,
+            total_bytes=file_size,
+        )
 
-        # Upload file
-        await self._upload_to_url(upload_url, file_bytes, file_size, asset_id)
+        try:
+            upload_response = await self.client.put(
+                upload_url,
+                content=file_bytes,
+                headers={"Content-Type": "application/octet-stream"},
+            )
+            upload_response.raise_for_status()
+        except httpx.HTTPError as e:
+            raise MediaUploadError(
+                f"Failed to upload document binary: {e}",
+                platform="linkedin",
+                media_type="document",
+            ) from e
 
         # Notify completion
         await self._emit_progress(
@@ -481,171 +670,91 @@ class LinkedInMediaManager:
             progress=100,
             total=100,
             message="Document upload completed",
-            entity_id=asset_id,
+            entity_id=document_urn,
             bytes_uploaded=file_size,
             total_bytes=file_size,
         )
 
-        logger.info(f"Document uploaded successfully: {asset_id}")
-        return MediaAsset(asset_id=asset_id, status="READY")
+        logger.info(f"Document uploaded successfully: {document_urn}")
+        return MediaAsset(asset_id=document_urn, status="AVAILABLE")
+
+    async def get_video_status(self, video_urn: str) -> dict[str, Any]:
+        """Get processing status of a video using the REST Videos API.
 
-    async def get_video_status(self, asset_id: str) -> dict[str, Any]:
-        """Get processing status of a video asset.
+        Uses the REST API endpoint: GET /rest/videos/{videoUrn}
 
         Args:
-            asset_id: LinkedIn asset URN.
+            video_urn: LinkedIn video URN (urn:li:video:xxx).
 
         Returns:
-            Dictionary with video status information.
+            Dictionary with video status information including:
+            - status: PROCESSING, PROCESSING_FAILED, AVAILABLE, WAITING_UPLOAD
+            - downloadUrl: URL to download/view the video (when AVAILABLE)
+            - duration: Video length in milliseconds
+            - aspectRatioWidth/Height: Video dimensions
 
         Example:
-            >>> status = await manager.get_video_status(asset_id)
+            >>> status = await manager.get_video_status("urn:li:video:C5505AQH...")
             >>> print(f"Status: {status['status']}")
         """
+        from urllib.parse import quote
+
+        encoded_urn = quote(video_urn, safe="")
 
         @retry_async(config=STANDARD_BACKOFF)
         async def _get_status() -> dict[str, Any]:
             response = await self.client.get(
-                f"{self.base_url}/assets/{asset_id}",
+                f"{self.base_url}/videos/{encoded_urn}",
             )
             response.raise_for_status()
             return response.json()
 
         return await _get_status()
 
-    async def _register_upload(self, register_data: dict[str, Any]) -> str:
-        """Register an upload and get asset ID."""
-
-        @retry_async(config=STANDARD_BACKOFF)
-        async def _register() -> str:
-            response = await self.client.post(
-                f"{self.base_url}/assets?action=registerUpload",
-                json=register_data,
-            )
-            response.raise_for_status()
-            result = response.json()
-            return result["value"]["asset"]
-
-        try:
-            return await _register()
-        except httpx.HTTPError as e:
-            raise MediaUploadError(
-                f"Failed to register upload: {e}",
-                platform="linkedin",
-            ) from e
-
-    async def _get_upload_url(self, asset_id: str) -> str:
-        """Get upload URL for an asset."""
-
-        @retry_async(config=STANDARD_BACKOFF)
-        async def _get_url() -> str:
-            response = await self.client.get(
-                f"{self.base_url}/assets/{asset_id}",
-            )
-            response.raise_for_status()
-            result = response.json()
-            return result["uploadMechanism"][
-                "com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest"
-            ]["uploadUrl"]
-
-        try:
-            return await _get_url()
-        except httpx.HTTPError as e:
-            raise MediaUploadError(
-                f"Failed to get upload URL: {e}",
-                platform="linkedin",
-            ) from e
-
-    async def _upload_to_url(
-        self,
-        upload_url: str,
-        file_bytes: bytes,
-        file_size: int,
-        asset_id: str,
-    ) -> None:
-        """Upload file bytes to the upload URL."""
-
-        @retry_async(config=STANDARD_BACKOFF)
-        async def _upload() -> None:
-            # LinkedIn requires specific headers for upload
-            headers = {
-                "Content-Type": "application/octet-stream",
-            }
-
-            # Notify upload start
-            await self._emit_progress(
-                status=ProgressStatus.UPLOADING,
-                progress=0,
-                total=100,
-                message="Uploading file",
-                entity_id=asset_id,
-                bytes_uploaded=0,
-                total_bytes=file_size,
-            )
-
-            response = await self.client.put(
-                upload_url,
-                content=file_bytes,
-                headers=headers,
-            )
-            response.raise_for_status()
-
-            # Notify upload complete
-            await self._emit_progress(
-                status=ProgressStatus.UPLOADING,
-                progress=100,
-                total=100,
-                message="File uploaded",
-                entity_id=asset_id,
-                bytes_uploaded=file_size,
-                total_bytes=file_size,
-            )
-
-        try:
-            await _upload()
-        except httpx.HTTPError as e:
-            raise MediaUploadError(
-                f"Failed to upload file: {e}",
-                platform="linkedin",
-            ) from e
-
     async def _wait_for_video_processing(
         self,
-        asset_id: str,
+        video_urn: str,
         *,
         timeout: int = VIDEO_PROCESSING_TIMEOUT,
         check_interval: int = 5,
     ) -> None:
-        """Wait for video processing to complete."""
+        """Wait for video processing to complete using the REST Videos API.
+
+        Args:
+            video_urn: LinkedIn video URN (urn:li:video:xxx).
+            timeout: Maximum time to wait in seconds.
+            check_interval: Time between status checks in seconds.
+
+        Raises:
+            MediaUploadError: If processing fails or times out.
+        """
         elapsed = 0
-        logger.info(f"Waiting for video {asset_id} to process...")
+        logger.info(f"Waiting for video {video_urn} to process...")
 
         while elapsed < timeout:
-            status_data = await self.get_video_status(asset_id)
+            status_data = await self.get_video_status(video_urn)
             status = status_data.get("status")
 
-            if status in (
-                VideoProcessingState.READY.value,
-                VideoProcessingState.AVAILABLE.value,
-            ):
-                logger.info(f"Video {asset_id} processing complete")
+            if status == VideoProcessingState.AVAILABLE.value:
+                logger.info(f"Video {video_urn} processing complete")
                 return
 
-            if status == VideoProcessingState.FAILED.value:
+            if status == VideoProcessingState.PROCESSING_FAILED.value:
+                failure_reason = status_data.get("processingFailureReason", "Unknown")
                 raise MediaUploadError(
-                    f"Video processing failed for {asset_id}",
+                    f"Video processing failed for {video_urn}: {failure_reason}",
                     platform="linkedin",
                     media_type="video",
                 )
 
             # Notify progress
-            progress_pct = min(int((elapsed / timeout) * 90), 90)
+            progress_pct = min(int((elapsed / timeout) * 90) + 85, 99)
             await self._emit_progress(
                 status=ProgressStatus.PROCESSING,
                 progress=progress_pct,
                 total=100,
                 message=f"Processing video ({status})",
-                entity_id=asset_id,
+                entity_id=video_urn,
             )
 
             await asyncio.sleep(check_interval)

{marqetive_lib-0.1.17.dist-info → marqetive_lib-0.1.18.dist-info}/METADATA

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

{marqetive_lib-0.1.17.dist-info → marqetive_lib-0.1.18.dist-info}/RECORD

@@ -12,9 +12,9 @@ marqetive/platforms/instagram/exceptions.py,sha256=TcD_pX4eSx_k4yW8DgfA6SGPiAz3V
 marqetive/platforms/instagram/media.py,sha256=0ZbUbpwJ025_hccL9X8qced_-LJGoL_-NdS84Op97VE,23228
 marqetive/platforms/instagram/models.py,sha256=20v3m1037y3b_WlsKF8zAOgV23nFu63tfmmUN1CefOI,2769
 marqetive/platforms/linkedin/__init__.py,sha256=_FrdZpqcXjcUW6C-25zGV7poGih9yzs6y1AFnuizTUQ,1384
-marqetive/platforms/linkedin/client.py,sha256=8M34VJXFe_34QQZzhR7SVK8ee3iE6UOGsSVTv5Hf31U,58712
+marqetive/platforms/linkedin/client.py,sha256=NHVjMfZb9Mp6zloCXORBEHOxOGPK5DHLctOzCiseQbs,73092
 marqetive/platforms/linkedin/exceptions.py,sha256=i5fARUkZik46bS3htZBwUInVzetsZx1APpKEXLrCKf0,9762
-marqetive/platforms/linkedin/media.py,sha256=iWXUfqDYGsrTqeM6CGZ7a8xjpbdJ5qESolQL8Fv2PIg,20341
+marqetive/platforms/linkedin/media.py,sha256=-kpkL5brYhx8cZlFS5ueDgY4eSZWqHoB6xp8jZU2cyI,25931
 marqetive/platforms/linkedin/models.py,sha256=n7DqwVxYSbGYBmeEJ1woCZ6XhUIHcLx8Gpm8uCBACzI,12620
 marqetive/platforms/tiktok/__init__.py,sha256=BqjkXTZDyBlcY3lvREy13yP9h3RcDga8E6Rl6f5KPp8,238
 marqetive/platforms/tiktok/client.py,sha256=c-XYV3XsLU04jv61mBEYivP-oO-aZhuEq6g7J55OEY8,17387
@@ -33,6 +33,6 @@ marqetive/utils/helpers.py,sha256=Sh5HZD6AOJig_6T84n6JsKLosIkKIkpkiYTl69rnOOw,13
 marqetive/utils/media.py,sha256=reVousdueG-h5jeI6uLGqVCfjYxlsMiWhx6XZwg-iHY,14664
 marqetive/utils/oauth.py,sha256=x30XAW5VlND6TAPBsw9kZShko_Jsmn_NE-KOZjnBxGo,14359
 marqetive/utils/retry.py,sha256=UcgrmVBVG5zd30_11mZnRnTaSFrbUYXBO1DrXPR0f8E,7627
-marqetive_lib-0.1.17.dist-info/METADATA,sha256=mXa8m82FUduoiT9f6hCpeoNe-ygPA8TCqI7EOon__a8,7876
-marqetive_lib-0.1.17.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-marqetive_lib-0.1.17.dist-info/RECORD,,
+marqetive_lib-0.1.18.dist-info/METADATA,sha256=NxSKJr6IOZzVngZLGwmTgDE97Wu8uyewyVK_fH-MZpI,7876
+marqetive_lib-0.1.18.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+marqetive_lib-0.1.18.dist-info/RECORD,,