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

marqetive/platforms/linkedin/manager.py

@@ -1,119 +0,0 @@
-"""LinkedIn post manager for handling post operations."""
-
-import logging
-from typing import Any
-
-from src.marqetive.core.base_manager import BasePostManager
-from src.marqetive.platforms.linkedin.client import LinkedInClient
-from src.marqetive.platforms.linkedin.factory import LinkedInAccountFactory
-from src.marqetive.platforms.models import AuthCredentials, Post, PostCreateRequest
-
-logger = logging.getLogger(__name__)
-
-
-class LinkedInPostManager(BasePostManager):
-    """Manager for LinkedIn post operations.
-
-    Coordinates post creation, media uploads, and progress tracking for LinkedIn.
-
-    Example:
-        >>> manager = LinkedInPostManager()
-        >>> credentials = AuthCredentials(
-        ...     platform="linkedin",
-        ...     access_token="token",
-        ...     refresh_token="refresh"
-        ... )
-        >>> request = PostCreateRequest(content="Hello LinkedIn!")
-        >>> post = await manager.execute_post(credentials, request)
-        >>> print(f"Post URN: {post.post_id}")
-    """
-
-    def __init__(
-        self,
-        account_factory: LinkedInAccountFactory | None = None,
-        client_id: str | None = None,
-        client_secret: str | None = None,
-    ) -> None:
-        """Initialize LinkedIn post manager.
-
-        Args:
-            account_factory: LinkedIn account factory (creates default if None).
-            client_id: LinkedIn OAuth client ID (for default factory).
-            client_secret: LinkedIn OAuth client secret (for default factory).
-        """
-        if account_factory is None:
-            account_factory = LinkedInAccountFactory(
-                client_id=client_id,
-                client_secret=client_secret,
-            )
-
-        super().__init__(account_factory=account_factory)
-
-    @property
-    def platform_name(self) -> str:
-        """Get platform name."""
-        return "linkedin"
-
-    async def _execute_post_impl(
-        self,
-        client: Any,
-        request: PostCreateRequest,
-        credentials: AuthCredentials,  # noqa: ARG002
-    ) -> Post:
-        """Execute LinkedIn post creation.
-
-        Args:
-            client: LinkedInClient instance.
-            request: Post creation request.
-            credentials: LinkedIn credentials.
-
-        Returns:
-            Created Post object.
-        """
-        if not isinstance(client, LinkedInClient):
-            raise TypeError(f"Expected LinkedInClient, got {type(client)}")
-
-        # Handle media uploads with progress tracking
-        media_ids: list[str] = []
-        if request.media_urls:
-            self._progress_tracker.emit_start(
-                "upload_media",
-                total=len(request.media_urls),
-                message=f"Uploading {len(request.media_urls)} media files...",
-            )
-
-            for idx, media_url in enumerate(request.media_urls):
-                if self.is_cancelled():
-                    raise InterruptedError("Post creation was cancelled")
-
-                self._progress_tracker.emit_progress(
-                    "upload_media",
-                    progress=idx,
-                    total=len(request.media_urls),
-                    message=f"Uploading media {idx + 1}/{len(request.media_urls)}...",
-                )
-
-                media_attachment = await client.upload_media(
-                    media_url=media_url,
-                    media_type="image",  # Default to image
-                    alt_text=None,
-                )
-                media_ids.append(media_attachment.media_id)
-
-            self._progress_tracker.emit_complete(
-                "upload_media",
-                message="All media uploaded successfully",
-            )
-
-        # Create post with progress tracking
-        self._progress_tracker.emit_progress(
-            "execute_post",
-            progress=50,
-            total=100,
-            message="Creating LinkedIn post...",
-        )
-
-        # Use the client to create the post
-        post = await client.create_post(request)
-
-        return post

marqetive/platforms/tiktok/factory.py

@@ -1,188 +0,0 @@
-"""TikTok account factory for managing credentials and client creation."""
-
-import logging
-import os
-from collections.abc import Callable
-from datetime import datetime, timedelta
-
-from src.marqetive.core.account_factory import BaseAccountFactory
-from src.marqetive.platforms.exceptions import PlatformAuthError
-from src.marqetive.platforms.models import AccountStatus, AuthCredentials
-from src.marqetive.platforms.tiktok.client import TikTokClient
-from src.marqetive.utils.oauth import fetch_tiktok_token, refresh_tiktok_token
-
-logger = logging.getLogger(__name__)
-
-
-class TikTokAccountFactory(BaseAccountFactory):
-    """Factory for creating and managing TikTok accounts and clients.
-
-    This factory handles the instantiation of TikTokClients, manages OAuth
-    credentials, and provides a mechanism for token refreshing.
-    """
-
-    def __init__(
-        self,
-        client_id: str | None = None,
-        client_secret: str | None = None,
-        on_status_update: Callable[[str, AccountStatus], None] | None = None,
-    ) -> None:
-        """Initialize TikTok account factory.
-
-        Args:
-            client_id: TikTok App client ID (uses TIKTOK_CLIENT_ID env if None).
-            client_secret: TikTok App client secret (uses TIKTOK_CLIENT_SECRET env if None).
-            on_status_update: Optional callback when account status changes.
-        """
-        super().__init__(on_status_update=on_status_update)
-        self.client_id = client_id or os.getenv("TIKTOK_CLIENT_ID")
-        self.client_secret = client_secret or os.getenv("TIKTOK_CLIENT_SECRET")
-
-        if not self.client_id or not self.client_secret:
-            logger.warning(
-                "TikTok client_id/client_secret not provided. "
-                "Token refresh may not work."
-            )
-
-    @property
-    def platform_name(self) -> str:
-        """Get the platform name."""
-        return "tiktok"
-
-    async def get_credentials_from_auth_code(
-        self,
-        auth_code: str,
-        redirect_uri: str,
-        code_verifier: str | None = None,
-    ) -> AuthCredentials:
-        """Get credentials from an authorization code.
-
-        This method exchanges an authorization code for an access token and
-        formats it into the standard AuthCredentials object.
-
-        Args:
-            auth_code: The authorization code received from TikTok.
-            redirect_uri: The redirect URI used in the initial auth request.
-            code_verifier: The PKCE code verifier, if used.
-
-        Returns:
-            An AuthCredentials object for the user.
-
-        Raises:
-            PlatformAuthError: If the token exchange fails.
-        """
-        if not self.client_id or not self.client_secret:
-            raise PlatformAuthError(
-                "TikTok client_id and client_secret are required.",
-                platform=self.platform_name,
-            )
-
-        token_data = await fetch_tiktok_token(
-            code=auth_code,
-            client_id=self.client_id,
-            client_secret=self.client_secret,
-            redirect_uri=redirect_uri,
-            code_verifier=code_verifier,
-        )
-
-        expires_at = None
-        if "expires_in" in token_data:
-            expires_at = datetime.now() + timedelta(seconds=token_data["expires_in"])
-
-        refresh_expires_at = None
-        if "refresh_expires_in" in token_data:
-            refresh_expires_at = datetime.now() + timedelta(
-                seconds=token_data["refresh_expires_in"]
-            )
-
-        credentials = AuthCredentials(
-            platform=self.platform_name,
-            access_token=token_data["access_token"],
-            refresh_token=token_data.get("refresh_token"),
-            expires_at=expires_at,
-            scope=token_data.get("scope", []),
-            additional_data={
-                "open_id": token_data["open_id"],
-                "token_type": token_data.get("token_type"),
-                "refresh_expires_at": refresh_expires_at,
-            },
-        )
-        return credentials
-
-    async def refresh_token(self, credentials: AuthCredentials) -> AuthCredentials:
-        """Refresh a TikTok OAuth2 access token.
-
-        Args:
-            credentials: The current credentials containing the refresh token.
-
-        Returns:
-            Updated credentials with a new access token.
-
-        Raises:
-            PlatformAuthError: If refresh fails or credentials are missing.
-        """
-        if not self.client_id or not self.client_secret:
-            raise PlatformAuthError(
-                "TikTok client_id and client_secret are required for token refresh.",
-                platform=self.platform_name,
-            )
-
-        if not credentials.refresh_token:
-            raise PlatformAuthError(
-                "No refresh token available for TikTok.", platform=self.platform_name
-            )
-
-        logger.info("Refreshing TikTok access token...")
-        # This function would call the actual TikTok token refresh endpoint
-        return await refresh_tiktok_token(
-            credentials, self.client_id, self.client_secret
-        )
-
-    async def create_client(self, credentials: AuthCredentials) -> TikTokClient:
-        """Create a TikTok API client.
-
-        Args:
-            credentials: Valid TikTok authentication credentials.
-
-        Returns:
-            An instance of TikTokClient.
-
-        Raises:
-            PlatformAuthError: If credentials are incomplete or invalid.
-        """
-        if not credentials.access_token:
-            raise PlatformAuthError(
-                "Access token is required for TikTok.", platform=self.platform_name
-            )
-        if (
-            not credentials.additional_data
-            or "open_id" not in credentials.additional_data
-        ):
-            raise PlatformAuthError(
-                "'open_id' must be provided in additional_data for TikTok.",
-                platform=self.platform_name,
-            )
-
-        return TikTokClient(credentials=credentials)
-
-    async def validate_credentials(self, credentials: AuthCredentials) -> bool:
-        """Validate TikTok credentials by making a test API call.
-
-        Args:
-            credentials: The credentials to validate.
-
-        Returns:
-            True if the credentials are valid, False otherwise.
-        """
-        try:
-            client = await self.create_client(credentials)
-            async with client:
-                return await client.is_authenticated()
-        except PlatformAuthError as e:
-            logger.warning(f"TikTok credential validation failed: {e}")
-            return False
-        except Exception as e:
-            logger.error(
-                f"An unexpected error occurred during TikTok credential validation: {e}"
-            )
-            return False

marqetive/platforms/tiktok/manager.py

@@ -1,115 +0,0 @@
-"""TikTok post manager for handling video post operations."""
-
-import logging
-from typing import Any
-
-from src.marqetive.core.base_manager import BasePostManager
-from src.marqetive.platforms.models import AuthCredentials, Post, PostCreateRequest
-from src.marqetive.platforms.tiktok.client import TikTokClient
-from src.marqetive.platforms.tiktok.factory import TikTokAccountFactory
-
-logger = logging.getLogger(__name__)
-
-
-class TikTokPostManager(BasePostManager):
-    """Manager for TikTok video post operations.
-
-    This manager coordinates the multi-step process of posting a video to
-    TikTok, including media upload, processing, and the final publishing step.
-    It provides progress tracking throughout the operation.
-    """
-
-    def __init__(
-        self,
-        account_factory: TikTokAccountFactory | None = None,
-        client_id: str | None = None,
-        client_secret: str | None = None,
-    ) -> None:
-        """Initialize the TikTok post manager.
-
-        Args:
-            account_factory: An instance of TikTokAccountFactory. If not provided,
-                             a default one will be created.
-            client_id: TikTok App client ID (for the default factory).
-            client_secret: TikTok App client secret (for the default factory).
-        """
-        if account_factory is None:
-            account_factory = TikTokAccountFactory(
-                client_id=client_id,
-                client_secret=client_secret,
-            )
-        super().__init__(account_factory=account_factory)
-
-    @property
-    def platform_name(self) -> str:
-        """Get the platform name."""
-        return "tiktok"
-
-    async def _execute_post_impl(
-        self,
-        client: Any,
-        request: PostCreateRequest,
-        credentials: AuthCredentials,
-    ) -> Post:
-        """Execute the TikTok video post creation process.
-
-        Args:
-            client: An authenticated TikTokClient instance.
-            request: The post creation request.
-            credentials: The credentials used for authentication.
-
-        Returns:
-            The created Post object representing the TikTok video.
-
-        Raises:
-            TypeError: If the provided client is not a TikTokClient.
-            InterruptedError: If the operation is cancelled.
-        """
-        if not isinstance(client, TikTokClient):
-            raise TypeError(f"Expected TikTokClient, got {type(client)}")
-
-        # The TikTok posting process is primarily about the video upload.
-        # The client's create_post method handles the upload and publish steps.
-        # We can wrap it here to provide progress updates.
-
-        self._progress_tracker.emit_start(
-            "execute_post", total=100, message="Starting TikTok post..."
-        )
-
-        if self.is_cancelled():
-            raise InterruptedError("Post creation was cancelled before start.")
-
-        # Media upload progress can be tracked inside the client, but for simplicity,
-        # we'll emit high-level progress here.
-        self._progress_tracker.emit_progress(
-            "execute_post",
-            progress=10,
-            total=100,
-            message="Uploading video to TikTok...",
-        )
-
-        # The `create_post` method in the client will handle the full flow:
-        # 1. Upload media
-        # 2. Publish post
-        # 3. Fetch final post data
-        # A more advanced implementation might involve callbacks from the client
-        # to the manager for more granular progress updates.
-        post = await client.create_post(request)
-
-        if self.is_cancelled():
-            # If cancellation happened during the client call, we might need cleanup.
-            # For now, we just raise.
-            raise InterruptedError("Post creation was cancelled during execution.")
-
-        self._progress_tracker.emit_progress(
-            "execute_post",
-            progress=90,
-            total=100,
-            message="Finalizing post...",
-        )
-
-        self._progress_tracker.emit_complete(
-            "execute_post", message="TikTok post published successfully!"
-        )
-
-        return post

marqetive/platforms/twitter/factory.py

@@ -1,151 +0,0 @@
-"""Twitter account factory for managing credentials and client creation."""
-
-import logging
-import os
-from collections.abc import Callable
-
-from src.marqetive.core.account_factory import BaseAccountFactory
-from src.marqetive.platforms.exceptions import PlatformAuthError
-from src.marqetive.platforms.models import AccountStatus, AuthCredentials
-from src.marqetive.platforms.twitter.client import TwitterClient
-from src.marqetive.utils.oauth import refresh_twitter_token
-
-logger = logging.getLogger(__name__)
-
-
-class TwitterAccountFactory(BaseAccountFactory):
-    """Factory for creating and managing Twitter/X accounts and clients.
-
-    Example:
-        >>> factory = TwitterAccountFactory(
-        ...     client_id="your_client_id",
-        ...     client_secret="your_client_secret"
-        ... )
-        >>> credentials = AuthCredentials(
-        ...     platform="twitter",
-        ...     access_token="token",
-        ...     refresh_token="refresh"
-        ... )
-        >>> client = await factory.create_authenticated_client(credentials)
-        >>> async with client:
-        ...     tweet = await client.create_post(request)
-    """
-
-    def __init__(
-        self,
-        client_id: str | None = None,
-        client_secret: str | None = None,
-        on_status_update: Callable[[str, AccountStatus], None] | None = None,
-    ) -> None:
-        """Initialize Twitter account factory.
-
-        Args:
-            client_id: Twitter OAuth client ID (uses TWITTER_CLIENT_ID env if None).
-            client_secret: Twitter OAuth client secret (uses TWITTER_CLIENT_SECRET env if None).
-            on_status_update: Optional callback when account status changes.
-        """
-        super().__init__(on_status_update=on_status_update)
-        self.client_id = client_id or os.getenv("TWITTER_CLIENT_ID")
-        self.client_secret = client_secret or os.getenv("TWITTER_CLIENT_SECRET")
-
-        if not self.client_id or not self.client_secret:
-            logger.warning(
-                "Twitter client_id/client_secret not provided. "
-                "Token refresh will not work."
-            )
-
-    @property
-    def platform_name(self) -> str:
-        """Get platform name."""
-        return "twitter"
-
-    async def refresh_token(self, credentials: AuthCredentials) -> AuthCredentials:
-        """Refresh Twitter OAuth2 access token.
-
-        Args:
-            credentials: Current credentials with refresh token.
-
-        Returns:
-            Updated credentials with new access token.
-
-        Raises:
-            PlatformAuthError: If refresh fails or credentials missing.
-        """
-        if not self.client_id or not self.client_secret:
-            raise PlatformAuthError(
-                "Twitter client_id and client_secret are required for token refresh",
-                platform=self.platform_name,
-            )
-
-        if not credentials.refresh_token:
-            raise PlatformAuthError(
-                "No refresh token available",
-                platform=self.platform_name,
-            )
-
-        logger.info("Refreshing Twitter access token...")
-        return await refresh_twitter_token(
-            credentials,
-            self.client_id,
-            self.client_secret,
-        )
-
-    async def create_client(self, credentials: AuthCredentials) -> TwitterClient:
-        """Create Twitter API client.
-
-        Args:
-            credentials: Valid Twitter credentials.
-
-        Returns:
-            TwitterClient instance.
-
-        Raises:
-            PlatformAuthError: If credentials are invalid.
-        """
-        if not credentials.access_token:
-            raise PlatformAuthError(
-                "Access token is required",
-                platform=self.platform_name,
-            )
-
-        # Get additional data for Twitter
-        additional_data = credentials.additional_data or {}
-
-        # Twitter needs API key/secret for some operations
-        api_key = additional_data.get("api_key") or os.getenv("TWITTER_API_KEY")
-        api_secret = additional_data.get("api_secret") or os.getenv(
-            "TWITTER_API_SECRET"
-        )
-        additional_data.get("access_secret")
-
-        # Update additional_data if we have env values
-        if api_key:
-            additional_data["api_key"] = api_key
-        if api_secret:
-            additional_data["api_secret"] = api_secret
-
-        credentials.additional_data = additional_data
-
-        return TwitterClient(credentials=credentials)
-
-    async def validate_credentials(self, credentials: AuthCredentials) -> bool:
-        """Validate Twitter credentials by making a test API call.
-
-        Args:
-            credentials: Credentials to validate.
-
-        Returns:
-            True if credentials are valid, False otherwise.
-        """
-        try:
-            client = await self.create_client(credentials)
-            async with client:
-                # Try to verify credentials by getting current user
-                # This is a lightweight call to test authentication
-                if client._tweepy_client:
-                    me = client._tweepy_client.get_me()
-                    return me is not None
-                return False
-        except Exception as e:
-            logger.error(f"Error validating Twitter credentials: {e}")
-            return False

marqetive/platforms/twitter/manager.py

@@ -1,121 +0,0 @@
-"""Twitter post manager for handling post operations."""
-
-import logging
-from typing import Any
-
-from src.marqetive.core.base_manager import BasePostManager
-from src.marqetive.platforms.models import AuthCredentials, Post, PostCreateRequest
-from src.marqetive.platforms.twitter.client import TwitterClient
-from src.marqetive.platforms.twitter.factory import TwitterAccountFactory
-
-logger = logging.getLogger(__name__)
-
-
-class TwitterPostManager(BasePostManager):
-    """Manager for Twitter/X post operations.
-
-    Coordinates post creation, media uploads, and progress tracking for Twitter.
-
-    Example:
-        >>> manager = TwitterPostManager()
-        >>> credentials = AuthCredentials(
-        ...     platform="twitter",
-        ...     access_token="token",
-        ...     refresh_token="refresh"
-        ... )
-        >>> request = PostCreateRequest(content="Hello Twitter!")
-        >>> post = await manager.execute_post(credentials, request)
-        >>> print(f"Tweet ID: {post.post_id}")
-    """
-
-    def __init__(
-        self,
-        account_factory: TwitterAccountFactory | None = None,
-        client_id: str | None = None,
-        client_secret: str | None = None,
-    ) -> None:
-        """Initialize Twitter post manager.
-
-        Args:
-            account_factory: Twitter account factory (creates default if None).
-            client_id: Twitter OAuth client ID (for default factory).
-            client_secret: Twitter OAuth client secret (for default factory).
-        """
-        if account_factory is None:
-            account_factory = TwitterAccountFactory(
-                client_id=client_id,
-                client_secret=client_secret,
-            )
-
-        super().__init__(account_factory=account_factory)
-
-    @property
-    def platform_name(self) -> str:
-        """Get platform name."""
-        return "twitter"
-
-    async def _execute_post_impl(
-        self,
-        client: Any,
-        request: PostCreateRequest,
-        credentials: AuthCredentials,  # noqa: ARG002
-    ) -> Post:
-        """Execute Twitter post creation.
-
-        Args:
-            client: TwitterClient instance.
-            request: Post creation request.
-            credentials: Twitter credentials.
-
-        Returns:
-            Created Post object.
-        """
-        if not isinstance(client, TwitterClient):
-            raise TypeError(f"Expected TwitterClient, got {type(client)}")
-
-        # Handle media uploads with progress tracking
-        media_ids: list[str] = []
-        if request.media_urls:
-            self._progress_tracker.emit_start(
-                "upload_media",
-                total=len(request.media_urls),
-                message=f"Uploading {len(request.media_urls)} media files...",
-            )
-
-            for idx, media_url in enumerate(request.media_urls):
-                if self.is_cancelled():
-                    raise InterruptedError("Post creation was cancelled")
-
-                self._progress_tracker.emit_progress(
-                    "upload_media",
-                    progress=idx,
-                    total=len(request.media_urls),
-                    message=f"Uploading media {idx + 1}/{len(request.media_urls)}...",
-                )
-
-                # Twitter media upload is simplified in the client
-                # In production, this would use tweepy's media upload
-                media_attachment = await client.upload_media(
-                    media_url=media_url,
-                    media_type="image",  # Default to image
-                    alt_text=None,
-                )
-                media_ids.append(media_attachment.media_id)
-
-            self._progress_tracker.emit_complete(
-                "upload_media",
-                message="All media uploaded successfully",
-            )
-
-        # Create post with progress tracking
-        self._progress_tracker.emit_progress(
-            "execute_post",
-            progress=50,
-            total=100,
-            message="Creating tweet...",
-        )
-
-        # Use the client to create the post
-        post = await client.create_post(request)
-
-        return post