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

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)