marqetive-lib 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

marqetive/platforms/tiktok/__init__.py

@@ -1,7 +1,5 @@
 """TikTok platform integration."""
 
 from marqetive.platforms.tiktok.client import TikTokClient
-from marqetive.platforms.tiktok.factory import TikTokAccountFactory
-from marqetive.platforms.tiktok.manager import TikTokPostManager
 
-__all__ = ["TikTokClient", "TikTokAccountFactory", "TikTokPostManager"]
+__all__ = ["TikTokClient"]

marqetive/platforms/tiktok/client.py

@@ -11,7 +11,7 @@ from typing import Any
 
 from pydantic import HttpUrl
 
-from marqetive.platforms.base import SocialMediaPlatform
+from marqetive.platforms.base import ProgressCallback, SocialMediaPlatform
 from marqetive.platforms.exceptions import (
     PlatformAuthError,
     PlatformError,
@@ -71,18 +71,22 @@ class TikTokClient(SocialMediaPlatform):
         self,
         credentials: AuthCredentials,
         timeout: float = 300.0,
+        progress_callback: ProgressCallback | None = None,
     ) -> None:
         """Initialize TikTok client.
 
         Args:
             credentials: OAuth credentials with access_token and open_id in additional_data.
             timeout: Request timeout in seconds (default 300s for video processing).
+            progress_callback: Optional callback for progress updates during
+                long-running operations like video uploads.
         """
         super().__init__(
             platform_name="tiktok",
             credentials=credentials,
             base_url=TIKTOK_API_BASE,
             timeout=timeout,
+            progress_callback=progress_callback,
         )
         self._media_manager: TikTokMediaManager | None = None
         self._creator_info: CreatorInfo | None = None
@@ -96,9 +100,7 @@ class TikTokClient(SocialMediaPlatform):
             not self.credentials.additional_data
             or "open_id" not in self.credentials.additional_data
         ):
-            raise PlatformAuthError(
-                "open_id is required in additional_data", "tiktok"
-            )
+            raise PlatformAuthError("open_id is required in additional_data", "tiktok")
 
         self._media_manager = TikTokMediaManager(
             access_token=self.credentials.access_token,
@@ -357,7 +359,10 @@ class TikTokClient(SocialMediaPlatform):
         )
 
     async def upload_media(
-        self, media_url: str, media_type: str, alt_text: str | None = None  # noqa: ARG002
+        self,
+        media_url: str,
+        media_type: str,
+        alt_text: str | None = None,  # noqa: ARG002
     ) -> MediaAttachment:
         """Upload a video to TikTok.
 

marqetive/platforms/tiktok/media.py

@@ -664,9 +664,7 @@ class TikTokMediaManager:
                 media_type=mime_type,
             )
 
-    def _check_response_error(
-        self, status_code: int, data: dict[str, Any]
-    ) -> None:
+    def _check_response_error(self, status_code: int, data: dict[str, Any]) -> None:
         """Check API response for errors and raise appropriate exception.
 
         Args:

marqetive/platforms/twitter/__init__.py

@@ -1,7 +1,5 @@
 """Twitter/X platform integration."""
 
 from marqetive.platforms.twitter.client import TwitterClient
-from marqetive.platforms.twitter.factory import TwitterAccountFactory
-from marqetive.platforms.twitter.manager import TwitterPostManager
 
-__all__ = ["TwitterClient", "TwitterAccountFactory", "TwitterPostManager"]
+__all__ = ["TwitterClient"]

marqetive/platforms/twitter/client.py

@@ -13,7 +13,7 @@ import httpx
 import tweepy
 from pydantic import HttpUrl
 
-from marqetive.platforms.base import SocialMediaPlatform
+from marqetive.platforms.base import ProgressCallback, SocialMediaPlatform
 from marqetive.platforms.exceptions import (
     MediaUploadError,
     PlatformAuthError,
@@ -67,12 +67,15 @@ class TwitterClient(SocialMediaPlatform):
         self,
         credentials: AuthCredentials,
         timeout: float = 30.0,
+        progress_callback: ProgressCallback | None = None,
     ) -> None:
         """Initialize Twitter client.
 
         Args:
             credentials: Twitter authentication credentials
             timeout: Request timeout in seconds
+            progress_callback: Optional callback for progress updates during
+                long-running operations like media uploads.
 
         Raises:
             PlatformAuthError: If credentials are invalid
@@ -83,6 +86,7 @@ class TwitterClient(SocialMediaPlatform):
             credentials=credentials,
             base_url=base_url,
             timeout=timeout,
+            progress_callback=progress_callback,
         )
 
         # Initialize tweepy client

{marqetive_lib-0.1.3.dist-info → marqetive_lib-0.1.4.dist-info}/METADATA

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

marqetive_lib-0.1.4.dist-info/RECORD

@@ -0,0 +1,35 @@
+marqetive/__init__.py,sha256=LaGrC2HSkbpJBj9mKWuVOflTSN1upTzHowZm6Aw0nOY,2923
+marqetive/core/__init__.py,sha256=qOC6JhGjWOpj9_7umtc6VGH16ZJZE6iNDhA6iDZm8kg,113
+marqetive/core/client.py,sha256=2_FoNpqaRglsWg10i5RTbyDg_kRQKhgWjYs6iDdFxLg,3210
+marqetive/factory.py,sha256=W-8O7eowx_M5ykmL9ZEnjZVoMqNKq8rsDWpyU6X7mxg,14107
+marqetive/platforms/__init__.py,sha256=jMzSg8fI5nCO20aTNaoF6cQ6RIZoxzVhEDvq3ZpAbXc,1327
+marqetive/platforms/base.py,sha256=o0bY9tcV350uGYOHpo3SbSYI61gvx6Ll9KyHaSYFXko,13258
+marqetive/platforms/exceptions.py,sha256=Xyj0bzNiZm5VTErmzXgVW8T6IQnOpF92-HJiKPKjIio,7076
+marqetive/platforms/instagram/__init__.py,sha256=7ClfTovAcCHac2DzKS7z1MFuZpy9lcwet7YP5d6MPeY,135
+marqetive/platforms/instagram/client.py,sha256=Y7jnIDoIRnzwP3QtubwKd8aRi89zrxr5ZLgCqS43xwI,25202
+marqetive/platforms/instagram/exceptions.py,sha256=zwTc90VbG8uz_6O5bKw68Pp53SoevLQUqPiXj4ZgThU,8983
+marqetive/platforms/instagram/media.py,sha256=JDRFB66UlhSjAf0PFR3raGqYxtNTSd5yIZ_2xTGmZRk,21166
+marqetive/platforms/linkedin/__init__.py,sha256=zCnokoPYs56iA1sBSYIlaZW2J50L3CbnQpJSaOLrzP8,131
+marqetive/platforms/linkedin/client.py,sha256=GSWUq66KkerS4H9Vh8j3F6KrMzrlz1DYokbERNyrrCc,23821
+marqetive/platforms/linkedin/exceptions.py,sha256=WHjMZ-XJnKgT6uzzi7LXqFt4lD7nSCjzMzaqtOQA3hM,9767
+marqetive/platforms/linkedin/media.py,sha256=360OT1sdBuJRjuL3wJ-T1irAX5gHmcf4AwAU__cvwwA,16901
+marqetive/platforms/models.py,sha256=W_yOuRWItWSn82n8vXRNN_ScdNkzY1De2qqXaVN2RGU,10974
+marqetive/platforms/tiktok/__init__.py,sha256=BQtxdECd2bW9_vV9W-MY4A1rdXi_xurGWWmzTjTUpMM,123
+marqetive/platforms/tiktok/client.py,sha256=UkljwzrSybIgm4opT5ItT_EXdGx3OGbV4ig8yPoaCbM,17041
+marqetive/platforms/tiktok/exceptions.py,sha256=yOjkZgHyo_t9Chrhws_2n-2sbiDDkCUBv5fdW2nfiHI,10129
+marqetive/platforms/tiktok/media.py,sha256=pAT9AVZX7ZnAnhgoameFLszKDyX16nY43we_CHc5z9s,23771
+marqetive/platforms/twitter/__init__.py,sha256=AA5BELRvZyl2WE_7-puSEWArxZjaXcTJ_i8NGOWrv6k,129
+marqetive/platforms/twitter/client.py,sha256=vZ9wvFPaTOuBD-L48RD1UH6MCPZoF2EHRvFWe0m_cfc,19642
+marqetive/platforms/twitter/exceptions.py,sha256=aKrjUZL07KWQ8hatj5-U7UfnSTl-n8DnTgGGigYCrIY,8931
+marqetive/platforms/twitter/media.py,sha256=16atvKwSukvK_YC_gIm2qsl3pmidWEBAwIfJBPG9HQo,24968
+marqetive/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+marqetive/utils/__init__.py,sha256=bSrNajbxYBSKQayrPviLz8JeGjplnyK8y_NGDtgb7yQ,977
+marqetive/utils/file_handlers.py,sha256=4TP5kmWofNTSZmlS683CM1UYP83WvRd_NubMbqtXv-g,12568
+marqetive/utils/helpers.py,sha256=8-ljhL47SremKcQO2GF8DIHOPODEv1rSioVNuSPCbec,2634
+marqetive/utils/media.py,sha256=Rvxw9XKU65n-z4G1bEihG3wXZBmjSDZUqClfjGFrg6k,12013
+marqetive/utils/oauth.py,sha256=NjHh3o5iKlXMJmzSFJHq-pn5yn82DvmpB7DMTJT0ht8,12105
+marqetive/utils/retry.py,sha256=lAniJLMNWp9XsHrvU0XBNifpNEjfde4MGfd5hlFTPfA,7636
+marqetive/utils/token_validator.py,sha256=pNimFr_FNJLcYGV5oADhoBjflKfEbLQ3Epwnwg_nTbg,6703
+marqetive_lib-0.1.4.dist-info/METADATA,sha256=KawBEFdT6w-WUGCF5ulti5nfi6cWer0oOqP-DFXDDaM,7798
+marqetive_lib-0.1.4.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+marqetive_lib-0.1.4.dist-info/RECORD,,

marqetive/core/account_factory.py

@@ -1,212 +0,0 @@
-"""Base account factory for managing platform credentials and client creation.
-
-This module provides an abstract base class for platform-specific account
-factories that handle credential management, token refresh, and client creation.
-"""
-
-import logging
-from abc import ABC, abstractmethod
-from collections.abc import Callable
-from typing import Any
-
-from marqetive.platforms.exceptions import PlatformAuthError
-from marqetive.platforms.models import AccountStatus, AuthCredentials
-
-logger = logging.getLogger(__name__)
-
-
-class BaseAccountFactory(ABC):
-    """Abstract base class for platform account factories.
-
-    Account factories manage the lifecycle of platform credentials including:
-    - Token expiry checking and automatic refresh
-    - Account status management
-    - Platform-specific client creation
-
-    Subclasses must implement:
-    - refresh_token(): Platform-specific token refresh logic
-    - create_client(): Create platform-specific API client
-    - validate_credentials(): Check if credentials are valid
-
-    Example:
-        >>> class TwitterAccountFactory(BaseAccountFactory):
-        ...     async def refresh_token(self, credentials):
-        ...         # Implement Twitter OAuth token refresh
-        ...         pass
-        ...
-        ...     async def create_client(self, credentials):
-        ...         return TwitterClient(credentials=credentials)
-        ...
-        ...     async def validate_credentials(self, credentials):
-        ...         # Check if credentials work
-        ...         pass
-    """
-
-    def __init__(
-        self,
-        on_status_update: Callable[[str, AccountStatus], None] | None = None,
-    ) -> None:
-        """Initialize the account factory.
-
-        Args:
-            on_status_update: Optional callback when account status changes.
-                            Called with (user_id, new_status).
-        """
-        self.on_status_update = on_status_update
-
-    @property
-    @abstractmethod
-    def platform_name(self) -> str:
-        """Get the name of the platform this factory manages.
-
-        Returns:
-            Platform name (e.g., "twitter", "linkedin").
-        """
-        pass
-
-    @abstractmethod
-    async def refresh_token(self, credentials: AuthCredentials) -> AuthCredentials:
-        """Refresh the OAuth access token.
-
-        Args:
-            credentials: Current credentials with expired token.
-
-        Returns:
-            Updated credentials with new token.
-
-        Raises:
-            PlatformAuthError: If token refresh fails.
-        """
-        pass
-
-    @abstractmethod
-    async def create_client(self, credentials: AuthCredentials) -> Any:
-        """Create a platform-specific API client.
-
-        Args:
-            credentials: Valid credentials for the platform.
-
-        Returns:
-            Platform-specific API client instance.
-
-        Raises:
-            PlatformAuthError: If credentials are invalid.
-        """
-        pass
-
-    @abstractmethod
-    async def validate_credentials(self, credentials: AuthCredentials) -> bool:
-        """Validate that credentials are working.
-
-        Args:
-            credentials: Credentials to validate.
-
-        Returns:
-            True if credentials are valid, False otherwise.
-        """
-        pass
-
-    async def get_credentials(
-        self,
-        credentials: AuthCredentials,
-        auto_refresh: bool = True,
-    ) -> AuthCredentials:
-        """Get credentials, refreshing if necessary.
-
-        This method checks if credentials are expired and automatically
-        refreshes them if auto_refresh is True.
-
-        Args:
-            credentials: Current credentials.
-            auto_refresh: Whether to automatically refresh expired tokens.
-
-        Returns:
-            Valid credentials (refreshed if necessary).
-
-        Raises:
-            PlatformAuthError: If refresh fails or credentials are invalid.
-        """
-        # Check if token needs refresh
-        if credentials.needs_refresh():
-            if not auto_refresh:
-                logger.warning(
-                    f"Credentials for {credentials.platform} are expired "
-                    "but auto_refresh is disabled"
-                )
-                return credentials
-
-            logger.info(
-                f"Token expired for {credentials.platform}, attempting refresh..."
-            )
-            try:
-                refreshed_creds = await self.refresh_token(credentials)
-                refreshed_creds.mark_valid()
-
-                # Notify status update
-                if self.on_status_update and refreshed_creds.user_id:
-                    self.on_status_update(refreshed_creds.user_id, AccountStatus.VALID)
-
-                logger.info(f"Successfully refreshed token for {credentials.platform}")
-                return refreshed_creds
-
-            except PlatformAuthError as e:
-                # Determine if this is an OAuth error requiring reconnection
-                if "oauth" in str(e).lower() or "authorization" in str(e).lower():
-                    credentials.mark_reconnection_required()
-                    if self.on_status_update and credentials.user_id:
-                        self.on_status_update(
-                            credentials.user_id, AccountStatus.RECONNECTION_REQUIRED
-                        )
-                    logger.error(
-                        f"OAuth error refreshing token for {credentials.platform}: {e}"
-                    )
-                else:
-                    credentials.mark_error()
-                    if self.on_status_update and credentials.user_id:
-                        self.on_status_update(credentials.user_id, AccountStatus.ERROR)
-                    logger.error(
-                        f"Error refreshing token for {credentials.platform}: {e}"
-                    )
-                raise
-
-        return credentials
-
-    async def create_authenticated_client(
-        self,
-        credentials: AuthCredentials,
-        auto_refresh: bool = True,
-    ) -> Any:
-        """Create an authenticated client, refreshing credentials if needed.
-
-        This is the main method to use for getting a ready-to-use client.
-
-        Args:
-            credentials: Platform credentials.
-            auto_refresh: Whether to automatically refresh expired tokens.
-
-        Returns:
-            Authenticated platform client.
-
-        Raises:
-            PlatformAuthError: If authentication fails.
-        """
-        # Get valid credentials (refresh if needed)
-        valid_creds = await self.get_credentials(credentials, auto_refresh=auto_refresh)
-
-        # Create client
-        client = await self.create_client(valid_creds)
-
-        return client
-
-    def _update_status(self, user_id: str | None, status: AccountStatus) -> None:
-        """Internal method to update account status.
-
-        Args:
-            user_id: User ID for the account.
-            status: New status.
-        """
-        if self.on_status_update and user_id:
-            try:
-                self.on_status_update(user_id, status)
-            except Exception as e:
-                logger.error(f"Error calling status update callback: {e}")

marqetive/core/base_manager.py

@@ -1,303 +0,0 @@
-"""Base manager for platform post operations.
-
-This module provides an abstract base class for managing post operations
-across different social media platforms with consistent patterns for
-progress tracking, error handling, and state management.
-"""
-
-import asyncio
-import logging
-from abc import ABC, abstractmethod
-from typing import Any
-
-from marqetive.core.account_factory import BaseAccountFactory
-from marqetive.core.progress import ProgressCallback, ProgressTracker
-from marqetive.platforms.exceptions import PlatformError
-from marqetive.platforms.models import AuthCredentials, Post, PostCreateRequest
-
-logger = logging.getLogger(__name__)
-
-
-class BasePostManager(ABC):
-    """Abstract base class for platform post managers.
-
-    Managers coordinate the posting process including:
-    - Creating authenticated clients via account factories
-    - Tracking operation progress
-    - Handling errors consistently
-    - Supporting cancellation
-
-    Subclasses must implement:
-    - _execute_post_impl(): Platform-specific posting logic
-    - platform_name: Property returning the platform name
-
-    Example:
-        >>> class TwitterPostManager(BasePostManager):
-        ...     @property
-        ...     def platform_name(self) -> str:
-        ...         return "twitter"
-        ...
-        ...     async def _execute_post_impl(self, client, request):
-        ...         return await client.create_post(request)
-    """
-
-    def __init__(
-        self,
-        account_factory: BaseAccountFactory | None = None,
-    ) -> None:
-        """Initialize the post manager.
-
-        Args:
-            account_factory: Account factory for creating clients.
-                            If None, subclass must provide default.
-        """
-        self._account_factory = account_factory
-        self._progress_tracker = ProgressTracker()
-        self._cancel_event = asyncio.Event()
-
-    @property
-    @abstractmethod
-    def platform_name(self) -> str:
-        """Get the name of the platform this manager handles.
-
-        Returns:
-            Platform name (e.g., "twitter", "linkedin").
-        """
-        pass
-
-    @property
-    def account_factory(self) -> BaseAccountFactory:
-        """Get the account factory.
-
-        Returns:
-            Account factory instance.
-
-        Raises:
-            RuntimeError: If account factory not set.
-        """
-        if self._account_factory is None:
-            raise RuntimeError(
-                f"{self.__class__.__name__} requires an account_factory. "
-                "Either pass it to __init__ or override this property."
-            )
-        return self._account_factory
-
-    def add_progress_callback(self, callback: ProgressCallback) -> None:
-        """Add a callback to receive progress updates.
-
-        Args:
-            callback: Function that receives ProgressEvent objects.
-
-        Example:
-            >>> def my_callback(event):
-            ...     print(f"{event.operation}: {event.percentage}%")
-            >>>
-            >>> manager.add_progress_callback(my_callback)
-        """
-        self._progress_tracker.add_callback(callback)
-
-    def remove_progress_callback(self, callback: ProgressCallback) -> None:
-        """Remove a progress callback.
-
-        Args:
-            callback: Callback to remove.
-        """
-        self._progress_tracker.remove_callback(callback)
-
-    def clear_progress_callbacks(self) -> None:
-        """Remove all progress callbacks."""
-        self._progress_tracker.clear_callbacks()
-
-    async def execute_post(
-        self,
-        credentials: AuthCredentials,
-        request: PostCreateRequest,
-    ) -> Post:
-        """Execute post creation with progress tracking and error handling.
-
-        This is the main entry point for creating posts. It handles:
-        - Client creation via account factory
-        - Progress tracking
-        - Cancellation support
-        - Consistent error handling
-
-        Args:
-            credentials: Platform credentials.
-            request: Post creation request.
-
-        Returns:
-            Created Post object.
-
-        Raises:
-            PlatformError: If post creation fails.
-            asyncio.CancelledError: If operation is cancelled.
-
-        Example:
-            >>> credentials = AuthCredentials(platform="twitter", ...)
-            >>> request = PostCreateRequest(content="Hello world!")
-            >>> post = await manager.execute_post(credentials, request)
-            >>> print(f"Posted: {post.post_id}")
-        """
-        # Reset cancel event
-        self._cancel_event.clear()
-
-        try:
-            # Emit start event
-            self._progress_tracker.emit_start(
-                "execute_post",
-                message=f"Starting post to {self.platform_name}",
-                platform=self.platform_name,
-            )
-
-            # Check for cancellation
-            if self._cancel_event.is_set():
-                self._progress_tracker.emit_cancelled("execute_post")
-                raise asyncio.CancelledError("Post execution was cancelled")
-
-            # Create authenticated client
-            logger.info(f"Creating {self.platform_name} client...")
-            client = await self.account_factory.create_authenticated_client(credentials)
-
-            # Check for cancellation
-            if self._cancel_event.is_set():
-                self._progress_tracker.emit_cancelled("execute_post")
-                raise asyncio.CancelledError("Post execution was cancelled")
-
-            # Execute platform-specific posting logic
-            logger.info(f"Creating post on {self.platform_name}...")
-            post = await self._execute_post_impl(client, request, credentials)
-
-            # Emit completion event
-            self._progress_tracker.emit_complete(
-                "execute_post",
-                message=f"Post created successfully on {self.platform_name}",
-                post_id=post.post_id,
-                platform=self.platform_name,
-            )
-
-            logger.info(
-                f"Successfully created post {post.post_id} on {self.platform_name}"
-            )
-            return post
-
-        except asyncio.CancelledError:
-            self._progress_tracker.emit_cancelled(
-                "execute_post",
-                message=f"Post creation cancelled on {self.platform_name}",
-            )
-            raise
-
-        except Exception as e:
-            error_msg = f"Failed to create post on {self.platform_name}: {str(e)}"
-            logger.error(error_msg)
-            self._progress_tracker.emit_failed("execute_post", e)
-
-            # Wrap in PlatformError if not already
-            if not isinstance(e, PlatformError):
-                raise PlatformError(error_msg, platform=self.platform_name) from e
-            raise
-
-    @abstractmethod
-    async def _execute_post_impl(
-        self,
-        client: Any,
-        request: PostCreateRequest,
-        credentials: AuthCredentials,
-    ) -> Post:
-        """Platform-specific post creation implementation.
-
-        Subclasses must implement this to handle the actual post creation
-        logic for their specific platform.
-
-        Args:
-            client: Platform-specific authenticated client.
-            request: Post creation request.
-            credentials: Platform credentials (for context).
-
-        Returns:
-            Created Post object.
-
-        Raises:
-            PlatformError: If post creation fails.
-        """
-        pass
-
-    def cancel_post(self) -> None:
-        """Cancel the current post operation.
-
-        Sets a cancellation flag that is checked at key points during
-        post execution. The operation may not stop immediately.
-
-        Example:
-            >>> task = asyncio.create_task(manager.execute_post(...))
-            >>> # Later...
-            >>> manager.cancel_post()
-            >>> try:
-            ...     await task
-            ... except asyncio.CancelledError:
-            ...     print("Operation was cancelled")
-        """
-        self._cancel_event.set()
-        logger.info(f"Cancellation requested for {self.platform_name} post")
-
-    def is_cancelled(self) -> bool:
-        """Check if cancellation has been requested.
-
-        Returns:
-            True if cancel_post() was called, False otherwise.
-        """
-        return self._cancel_event.is_set()
-
-    async def get_post_status(
-        self,
-        credentials: AuthCredentials,
-        post_id: str,
-    ) -> Post:
-        """Get the current status of a post.
-
-        Args:
-            credentials: Platform credentials.
-            post_id: Platform-specific post ID.
-
-        Returns:
-            Post object with current status.
-
-        Raises:
-            PlatformError: If fetching post fails.
-        """
-        try:
-            client = await self.account_factory.create_authenticated_client(credentials)
-            return await client.get_post(post_id)
-        except Exception as e:
-            error_msg = f"Failed to get post status from {self.platform_name}: {str(e)}"
-            logger.error(error_msg)
-            if not isinstance(e, PlatformError):
-                raise PlatformError(error_msg, platform=self.platform_name) from e
-            raise
-
-    async def delete_post(
-        self,
-        credentials: AuthCredentials,
-        post_id: str,
-    ) -> bool:
-        """Delete a post.
-
-        Args:
-            credentials: Platform credentials.
-            post_id: Platform-specific post ID.
-
-        Returns:
-            True if deletion was successful.
-
-        Raises:
-            PlatformError: If deletion fails.
-        """
-        try:
-            client = await self.account_factory.create_authenticated_client(credentials)
-            return await client.delete_post(post_id)
-        except Exception as e:
-            error_msg = f"Failed to delete post from {self.platform_name}: {str(e)}"
-            logger.error(error_msg)
-            if not isinstance(e, PlatformError):
-                raise PlatformError(error_msg, platform=self.platform_name) from e
-            raise