marqetive-lib 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

marqetive/platforms/linkedin/media.py

@@ -12,8 +12,9 @@ This module supports:
 """
 
 import asyncio
+import inspect
 import logging
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Literal
@@ -24,10 +25,16 @@ from marqetive.core.exceptions import (
     MediaUploadError,
     ValidationError,
 )
+from marqetive.core.models import ProgressEvent, ProgressStatus
 from marqetive.utils.file_handlers import download_file, read_file_bytes
 from marqetive.utils.media import detect_mime_type, format_file_size
 from marqetive.utils.retry import STANDARD_BACKOFF, retry_async
 
+# Type aliases for progress callbacks
+type SyncProgressCallback = Callable[[ProgressEvent], None]
+type AsyncProgressCallback = Callable[[ProgressEvent], Awaitable[None]]
+type ProgressCallback = SyncProgressCallback | AsyncProgressCallback
+
 logger = logging.getLogger(__name__)
 
 # LinkedIn limits
@@ -51,7 +58,12 @@ class VideoProcessingState(str, Enum):
 
 @dataclass
 class UploadProgress:
-    """Progress information for media upload."""
+    """Progress information for media upload.
+
+    .. deprecated:: 0.2.0
+        Use :class:`marqetive.core.models.ProgressEvent` instead.
+        This class will be removed in a future version.
+    """
 
     asset_id: str
     bytes_uploaded: int
@@ -82,7 +94,7 @@ class MediaAsset:
 
 
 class LinkedInMediaManager:
-    """Manager for LinkedIn media uploads.
+    """Manager for LinkedIn media uploads using the Community Management API.
 
     Supports images, videos, and documents with progress tracking.
 
@@ -92,39 +104,87 @@ class LinkedInMediaManager:
         >>> print(f"Uploaded: {asset.asset_id}")
     """
 
+    # Default API version in YYYYMM format
+    DEFAULT_LINKEDIN_VERSION = "202511"
+
     def __init__(
         self,
         person_urn: str,
         access_token: str,
         *,
-        api_version: str = "v2",
+        linkedin_version: str | None = None,
         timeout: float = 60.0,
-        progress_callback: Callable[[UploadProgress], None] | None = None,
+        progress_callback: ProgressCallback | None = None,
     ) -> None:
         """Initialize LinkedIn media manager.
 
         Args:
-            person_urn: LinkedIn person URN (e.g., "urn:li:person:ABC123").
+            person_urn: LinkedIn person or organization URN
+                (e.g., "urn:li:person:ABC123" or "urn:li:organization:12345").
             access_token: LinkedIn OAuth access token.
-            api_version: LinkedIn API version.
+            linkedin_version: LinkedIn API version in YYYYMM format (e.g., "202511").
+                Defaults to the latest supported version.
             timeout: Request timeout in seconds.
             progress_callback: Optional callback for progress updates.
+                Accepts ProgressEvent and can be sync or async.
         """
         self.person_urn = person_urn
         self.access_token = access_token
-        self.api_version = api_version
+        self.linkedin_version = linkedin_version or self.DEFAULT_LINKEDIN_VERSION
         self.timeout = timeout
         self.progress_callback = progress_callback
 
-        self.base_url = f"https://api.linkedin.com/{api_version}"
+        # 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"
         self.client = httpx.AsyncClient(
             timeout=httpx.Timeout(timeout),
             headers={
                 "Authorization": f"Bearer {access_token}",
                 "X-Restli-Protocol-Version": "2.0.0",
+                "Linkedin-Version": self.linkedin_version,
+                "Content-Type": "application/json",
             },
         )
 
+    async def _emit_progress(
+        self,
+        status: ProgressStatus,
+        progress: int,
+        total: int,
+        message: str | None = None,
+        *,
+        entity_id: str | None = None,
+        file_path: str | None = None,
+        bytes_uploaded: int | None = None,
+        total_bytes: int | None = None,
+    ) -> None:
+        """Emit a progress update if a callback is registered.
+
+        Supports both sync and async callbacks.
+        """
+        if self.progress_callback is None:
+            return
+
+        event = ProgressEvent(
+            operation="upload_media",
+            platform="linkedin",
+            status=status,
+            progress=progress,
+            total=total,
+            message=message,
+            entity_id=entity_id,
+            file_path=file_path,
+            bytes_uploaded=bytes_uploaded,
+            total_bytes=total_bytes,
+        )
+
+        result = self.progress_callback(event)
+
+        # If callback returned a coroutine, await it
+        if inspect.iscoroutine(result):
+            await result
+
     async def __aenter__(self) -> "LinkedInMediaManager":
         """Enter async context."""
         return self
@@ -195,10 +255,15 @@ class LinkedInMediaManager:
         asset_id = await self._register_upload(register_data)
 
         # Notify start
-        if self.progress_callback:
-            self.progress_callback(
-                UploadProgress(asset_id, 0, file_size, "registering")
-            )
+        await self._emit_progress(
+            status=ProgressStatus.INITIALIZING,
+            progress=0,
+            total=100,
+            message="Registering upload",
+            entity_id=asset_id,
+            bytes_uploaded=0,
+            total_bytes=file_size,
+        )
 
         # Get upload URL
         upload_url = await self._get_upload_url(asset_id)
@@ -207,10 +272,15 @@ class LinkedInMediaManager:
         await self._upload_to_url(upload_url, file_bytes, file_size, asset_id)
 
         # Notify completion
-        if self.progress_callback:
-            self.progress_callback(
-                UploadProgress(asset_id, file_size, file_size, "completed")
-            )
+        await self._emit_progress(
+            status=ProgressStatus.COMPLETED,
+            progress=100,
+            total=100,
+            message="Upload completed",
+            entity_id=asset_id,
+            bytes_uploaded=file_size,
+            total_bytes=file_size,
+        )
 
         logger.info(f"Image uploaded successfully: {asset_id}")
         return MediaAsset(asset_id=asset_id, status="READY")
@@ -282,10 +352,15 @@ class LinkedInMediaManager:
         asset_id = await self._register_upload(register_data)
 
         # Notify start
-        if self.progress_callback:
-            self.progress_callback(
-                UploadProgress(asset_id, 0, file_size, "registering")
-            )
+        await self._emit_progress(
+            status=ProgressStatus.INITIALIZING,
+            progress=0,
+            total=100,
+            message="Registering video upload",
+            entity_id=asset_id,
+            bytes_uploaded=0,
+            total_bytes=file_size,
+        )
 
         # Get upload URL
         upload_url = await self._get_upload_url(asset_id)
@@ -298,11 +373,22 @@ class LinkedInMediaManager:
             await self._wait_for_video_processing(asset_id)
 
         # Notify completion
-        if self.progress_callback:
-            status = "completed" if wait_for_processing else "processing"
-            self.progress_callback(
-                UploadProgress(asset_id, file_size, file_size, status)
-            )
+        final_status = (
+            ProgressStatus.COMPLETED
+            if wait_for_processing
+            else ProgressStatus.PROCESSING
+        )
+        await self._emit_progress(
+            status=final_status,
+            progress=100,
+            total=100,
+            message=(
+                "Video upload completed" if wait_for_processing else "Video processing"
+            ),
+            entity_id=asset_id,
+            bytes_uploaded=file_size,
+            total_bytes=file_size,
+        )
 
         logger.info(f"Video uploaded successfully: {asset_id}")
         return MediaAsset(
@@ -373,10 +459,15 @@ class LinkedInMediaManager:
         asset_id = await self._register_upload(register_data)
 
         # Notify start
-        if self.progress_callback:
-            self.progress_callback(
-                UploadProgress(asset_id, 0, file_size, "registering")
-            )
+        await self._emit_progress(
+            status=ProgressStatus.INITIALIZING,
+            progress=0,
+            total=100,
+            message="Registering document upload",
+            entity_id=asset_id,
+            bytes_uploaded=0,
+            total_bytes=file_size,
+        )
 
         # Get upload URL
         upload_url = await self._get_upload_url(asset_id)
@@ -385,10 +476,15 @@ class LinkedInMediaManager:
         await self._upload_to_url(upload_url, file_bytes, file_size, asset_id)
 
         # Notify completion
-        if self.progress_callback:
-            self.progress_callback(
-                UploadProgress(asset_id, file_size, file_size, "completed")
-            )
+        await self._emit_progress(
+            status=ProgressStatus.COMPLETED,
+            progress=100,
+            total=100,
+            message="Document upload completed",
+            entity_id=asset_id,
+            bytes_uploaded=file_size,
+            total_bytes=file_size,
+        )
 
         logger.info(f"Document uploaded successfully: {asset_id}")
         return MediaAsset(asset_id=asset_id, status="READY")
@@ -477,10 +573,15 @@ class LinkedInMediaManager:
             }
 
             # Notify upload start
-            if self.progress_callback:
-                self.progress_callback(
-                    UploadProgress(asset_id, 0, file_size, "uploading")
-                )
+            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,
@@ -490,10 +591,15 @@ class LinkedInMediaManager:
             response.raise_for_status()
 
             # Notify upload complete
-            if self.progress_callback:
-                self.progress_callback(
-                    UploadProgress(asset_id, file_size, file_size, "uploading")
-                )
+            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()
@@ -533,11 +639,14 @@ class LinkedInMediaManager:
                 )
 
             # Notify progress
-            if self.progress_callback:
-                progress_pct = min(int((elapsed / timeout) * 90), 90)
-                self.progress_callback(
-                    UploadProgress(asset_id, progress_pct, 100, "processing")
-                )
+            progress_pct = min(int((elapsed / timeout) * 90), 90)
+            await self._emit_progress(
+                status=ProgressStatus.PROCESSING,
+                progress=progress_pct,
+                total=100,
+                message=f"Processing video ({status})",
+                entity_id=asset_id,
+            )
 
             await asyncio.sleep(check_interval)
             elapsed += check_interval