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

marqetive/core/registry.py

@@ -1,257 +0,0 @@
-"""Platform registry for managing platform manager instances.
-
-This module provides a singleton registry pattern for registering and accessing
-platform managers across the application.
-"""
-
-import threading
-from typing import Any, TypeVar
-
-from src.marqetive.platforms.models import AuthCredentials
-
-# Type variable for manager classes
-ManagerType = TypeVar("ManagerType")
-
-
-class PlatformRegistry:
-    """Singleton registry for platform managers.
-
-    The registry maintains a mapping of platform names to their manager classes
-    and provides caching of manager instances to avoid unnecessary recreation.
-
-    Thread-safe implementation using threading.Lock.
-
-    Example:
-        >>> from marqetive_lib.platforms.twitter.manager import TwitterPostManager
-        >>> registry = PlatformRegistry()
-        >>> registry.register_platform("twitter", TwitterPostManager)
-        >>> manager = registry.get_manager("twitter", credentials=creds)
-    """
-
-    _instance: "PlatformRegistry | None" = None
-    _lock: threading.Lock = threading.Lock()
-
-    def __new__(cls) -> "PlatformRegistry":
-        """Ensure only one instance exists (singleton pattern)."""
-        if cls._instance is None:
-            with cls._lock:
-                # Double-check locking pattern
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-                    cls._instance._initialized = False
-        return cls._instance
-
-    def __init__(self) -> None:
-        """Initialize the registry."""
-        # Only initialize once
-        if self._initialized:
-            return
-
-        self._platforms: dict[str, type] = {}
-        self._manager_cache: dict[str, Any] = {}
-        self._cache_lock = threading.Lock()
-        self._initialized = True
-
-    def register_platform(self, platform_name: str, manager_class: type) -> None:
-        """Register a platform manager class.
-
-        Args:
-            platform_name: Name of the platform (e.g., "twitter", "linkedin").
-            manager_class: The manager class to register.
-
-        Raises:
-            ValueError: If platform is already registered.
-
-        Example:
-            >>> registry.register_platform("twitter", TwitterPostManager)
-        """
-        if platform_name in self._platforms:
-            raise ValueError(f"Platform '{platform_name}' is already registered")
-
-        self._platforms[platform_name] = manager_class
-
-    def unregister_platform(self, platform_name: str) -> None:
-        """Unregister a platform and clear its cached instances.
-
-        Args:
-            platform_name: Name of the platform to unregister.
-
-        Example:
-            >>> registry.unregister_platform("twitter")
-        """
-        with self._cache_lock:
-            self._platforms.pop(platform_name, None)
-            # Clear cached instances for this platform
-            keys_to_remove = [
-                k for k in self._manager_cache if k.startswith(f"{platform_name}:")
-            ]
-            for key in keys_to_remove:
-                self._manager_cache.pop(key)
-
-    def get_manager(
-        self,
-        platform_name: str,
-        use_cache: bool = True,
-        **kwargs: Any,
-    ) -> Any:
-        """Get or create a manager instance for the specified platform.
-
-        Args:
-            platform_name: Name of the platform (e.g., "twitter", "linkedin").
-            use_cache: Whether to use cached instance (default: True).
-            **kwargs: Arguments to pass to the manager constructor.
-
-        Returns:
-            Manager instance for the platform.
-
-        Raises:
-            ValueError: If platform is not registered.
-
-        Example:
-            >>> manager = registry.get_manager("twitter", credentials=creds)
-            >>> post = await manager.execute_post(...)
-        """
-        if platform_name not in self._platforms:
-            available = ", ".join(self.get_available_platforms())
-            raise ValueError(
-                f"Platform '{platform_name}' is not registered. "
-                f"Available platforms: {available}"
-            )
-
-        # Generate cache key from platform name and kwargs
-        cache_key = self._generate_cache_key(platform_name, **kwargs)
-
-        if use_cache:
-            with self._cache_lock:
-                if cache_key in self._manager_cache:
-                    return self._manager_cache[cache_key]
-
-        # Create new manager instance
-        manager_class = self._platforms[platform_name]
-        manager = manager_class(**kwargs)
-
-        if use_cache:
-            with self._cache_lock:
-                self._manager_cache[cache_key] = manager
-
-        return manager
-
-    def get_available_platforms(self) -> list[str]:
-        """Get list of all registered platform names.
-
-        Returns:
-            List of platform names.
-
-        Example:
-            >>> platforms = registry.get_available_platforms()
-            >>> print(platforms)
-            ['twitter', 'linkedin', 'instagram', 'tiktok']
-        """
-        return list(self._platforms.keys())
-
-    def clear_cache(self) -> None:
-        """Clear all cached manager instances.
-
-        Example:
-            >>> registry.clear_cache()
-        """
-        with self._cache_lock:
-            self._manager_cache.clear()
-
-    def _generate_cache_key(self, platform_name: str, **kwargs: Any) -> str:
-        """Generate a cache key for manager instance.
-
-        Args:
-            platform_name: Name of the platform.
-            **kwargs: Manager constructor arguments.
-
-        Returns:
-            Cache key string.
-        """
-        # For credentials, use account_id if available
-        if "credentials" in kwargs:
-            creds = kwargs["credentials"]
-            if isinstance(creds, AuthCredentials) and creds.user_id:
-                return f"{platform_name}:user_id:{creds.user_id}"
-
-        # Default to platform name only
-        return platform_name
-
-
-# Global registry instance
-_global_registry: PlatformRegistry | None = None
-_global_lock = threading.Lock()
-
-
-def get_registry() -> PlatformRegistry:
-    """Get the global platform registry instance.
-
-    Returns:
-        Global PlatformRegistry instance.
-
-    Example:
-        >>> registry = get_registry()
-        >>> manager = registry.get_manager("twitter", credentials=creds)
-    """
-    global _global_registry
-
-    if _global_registry is None:
-        with _global_lock:
-            if _global_registry is None:
-                _global_registry = PlatformRegistry()
-
-    return _global_registry
-
-
-def register_platform(platform_name: str, manager_class: type) -> None:
-    """Register a platform in the global registry.
-
-    Convenience function that uses the global registry.
-
-    Args:
-        platform_name: Name of the platform.
-        manager_class: The manager class to register.
-
-    Example:
-        >>> from marqetive_lib.platforms.twitter.manager import TwitterPostManager
-        >>> register_platform("twitter", TwitterPostManager)
-    """
-    registry = get_registry()
-    registry.register_platform(platform_name, manager_class)
-
-
-def get_manager_for_platform(platform_name: str, **kwargs: Any) -> Any:
-    """Get a manager instance for the specified platform.
-
-    Convenience function that uses the global registry.
-
-    Args:
-        platform_name: Name of the platform.
-        **kwargs: Arguments to pass to the manager constructor.
-
-    Returns:
-        Manager instance for the platform.
-
-    Example:
-        >>> manager = get_manager_for_platform("twitter", credentials=creds)
-        >>> post = await manager.execute_post(...)
-    """
-    registry = get_registry()
-    return registry.get_manager(platform_name, **kwargs)
-
-
-def get_available_platforms() -> list[str]:
-    """Get list of all registered platforms.
-
-    Convenience function that uses the global registry.
-
-    Returns:
-        List of platform names.
-
-    Example:
-        >>> platforms = get_available_platforms()
-        >>> print(platforms)
-        ['twitter', 'linkedin', 'instagram']
-    """
-    registry = get_registry()
-    return registry.get_available_platforms()

marqetive/platforms/instagram/factory.py

@@ -1,106 +0,0 @@
-"""Instagram account factory for managing credentials and client creation."""
-
-import logging
-from collections.abc import Callable
-
-from src.marqetive.core.account_factory import BaseAccountFactory
-from src.marqetive.platforms.exceptions import PlatformAuthError
-from src.marqetive.platforms.instagram.client import InstagramClient
-from src.marqetive.platforms.models import AccountStatus, AuthCredentials
-from src.marqetive.utils.oauth import refresh_instagram_token
-
-logger = logging.getLogger(__name__)
-
-
-class InstagramAccountFactory(BaseAccountFactory):
-    """Factory for creating and managing Instagram accounts and clients.
-
-    Example:
-        >>> factory = InstagramAccountFactory()
-        >>> credentials = AuthCredentials(
-        ...     platform="instagram",
-        ...     access_token="token"
-        ... )
-        >>> client = await factory.create_authenticated_client(credentials)
-        >>> async with client:
-        ...     post = await client.create_post(request)
-    """
-
-    def __init__(
-        self,
-        on_status_update: Callable[[str, AccountStatus], None] | None = None,
-    ) -> None:
-        """Initialize Instagram account factory.
-
-        Args:
-            on_status_update: Optional callback when account status changes.
-        """
-        super().__init__(on_status_update=on_status_update)
-
-    @property
-    def platform_name(self) -> str:
-        """Get platform name."""
-        return "instagram"
-
-    async def refresh_token(self, credentials: AuthCredentials) -> AuthCredentials:
-        """Refresh Instagram long-lived access token.
-
-        Args:
-            credentials: Current credentials.
-
-        Returns:
-            Updated credentials with refreshed token.
-
-        Raises:
-            PlatformAuthError: If refresh fails.
-        """
-        logger.info("Refreshing Instagram access token...")
-        return await refresh_instagram_token(credentials)
-
-    async def create_client(self, credentials: AuthCredentials) -> InstagramClient:
-        """Create Instagram API client.
-
-        Args:
-            credentials: Valid Instagram credentials.
-
-        Returns:
-            InstagramClient instance.
-
-        Raises:
-            PlatformAuthError: If credentials are invalid.
-        """
-        if not credentials.access_token:
-            raise PlatformAuthError(
-                "Access token is required",
-                platform=self.platform_name,
-            )
-
-        # Instagram needs instagram_business_account_id in additional_data
-        instagram_business_account_id = credentials.additional_data.get(
-            "instagram_business_account_id"
-        )
-        if not instagram_business_account_id:
-            raise PlatformAuthError(
-                "instagram_business_account_id is required in additional_data",
-                platform=self.platform_name,
-            )
-
-        return InstagramClient(credentials=credentials)
-
-    async def validate_credentials(self, credentials: AuthCredentials) -> bool:
-        """Validate Instagram 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
-                return await client.is_authenticated()
-        except Exception as e:
-            logger.error(f"Error validating Instagram credentials: {e}")
-            return False

marqetive/platforms/instagram/manager.py

@@ -1,112 +0,0 @@
-"""Instagram post manager for handling post operations."""
-
-import logging
-from typing import Any
-
-from src.marqetive.core.base_manager import BasePostManager
-from src.marqetive.platforms.instagram.client import InstagramClient
-from src.marqetive.platforms.instagram.factory import InstagramAccountFactory
-from src.marqetive.platforms.models import AuthCredentials, Post, PostCreateRequest
-
-logger = logging.getLogger(__name__)
-
-
-class InstagramPostManager(BasePostManager):
-    """Manager for Instagram post operations.
-
-    Coordinates post creation, media uploads, and progress tracking for Instagram.
-
-    Example:
-        >>> manager = InstagramPostManager()
-        >>> credentials = AuthCredentials(
-        ...     platform="instagram",
-        ...     access_token="token",
-        ...     additional_data={"instagram_business_account_id": "123"}
-        ... )
-        >>> request = PostCreateRequest(content="Hello Instagram!")
-        >>> post = await manager.execute_post(credentials, request)
-        >>> print(f"Media ID: {post.post_id}")
-    """
-
-    def __init__(
-        self,
-        account_factory: InstagramAccountFactory | None = None,
-    ) -> None:
-        """Initialize Instagram post manager.
-
-        Args:
-            account_factory: Instagram account factory (creates default if None).
-        """
-        if account_factory is None:
-            account_factory = InstagramAccountFactory()
-
-        super().__init__(account_factory=account_factory)
-
-    @property
-    def platform_name(self) -> str:
-        """Get platform name."""
-        return "instagram"
-
-    async def _execute_post_impl(
-        self,
-        client: Any,
-        request: PostCreateRequest,
-        credentials: AuthCredentials,  # noqa: ARG002
-    ) -> Post:
-        """Execute Instagram post creation.
-
-        Args:
-            client: InstagramClient instance.
-            request: Post creation request.
-            credentials: Instagram credentials.
-
-        Returns:
-            Created Post object.
-        """
-        if not isinstance(client, InstagramClient):
-            raise TypeError(f"Expected InstagramClient, 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 Instagram post...",
-        )
-
-        # Use the client to create the post
-        post = await client.create_post(request)
-
-        return post

marqetive/platforms/linkedin/factory.py

@@ -1,130 +0,0 @@
-"""LinkedIn 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.linkedin.client import LinkedInClient
-from src.marqetive.platforms.models import AccountStatus, AuthCredentials
-from src.marqetive.utils.oauth import refresh_linkedin_token
-
-logger = logging.getLogger(__name__)
-
-
-class LinkedInAccountFactory(BaseAccountFactory):
-    """Factory for creating and managing LinkedIn accounts and clients.
-
-    Example:
-        >>> factory = LinkedInAccountFactory(
-        ...     client_id="your_client_id",
-        ...     client_secret="your_client_secret"
-        ... )
-        >>> credentials = AuthCredentials(
-        ...     platform="linkedin",
-        ...     access_token="token",
-        ...     refresh_token="refresh"
-        ... )
-        >>> client = await factory.create_authenticated_client(credentials)
-        >>> async with client:
-        ...     post = 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 LinkedIn account factory.
-
-        Args:
-            client_id: LinkedIn OAuth client ID (uses LINKEDIN_CLIENT_ID env if None).
-            client_secret: LinkedIn OAuth client secret (uses LINKEDIN_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("LINKEDIN_CLIENT_ID")
-        self.client_secret = client_secret or os.getenv("LINKEDIN_CLIENT_SECRET")
-
-        if not self.client_id or not self.client_secret:
-            logger.warning(
-                "LinkedIn client_id/client_secret not provided. "
-                "Token refresh will not work."
-            )
-
-    @property
-    def platform_name(self) -> str:
-        """Get platform name."""
-        return "linkedin"
-
-    async def refresh_token(self, credentials: AuthCredentials) -> AuthCredentials:
-        """Refresh LinkedIn 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(
-                "LinkedIn 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 LinkedIn access token...")
-        return await refresh_linkedin_token(
-            credentials,
-            self.client_id,
-            self.client_secret,
-        )
-
-    async def create_client(self, credentials: AuthCredentials) -> LinkedInClient:
-        """Create LinkedIn API client.
-
-        Args:
-            credentials: Valid LinkedIn credentials.
-
-        Returns:
-            LinkedInClient instance.
-
-        Raises:
-            PlatformAuthError: If credentials are invalid.
-        """
-        if not credentials.access_token:
-            raise PlatformAuthError(
-                "Access token is required",
-                platform=self.platform_name,
-            )
-
-        return LinkedInClient(credentials=credentials)
-
-    async def validate_credentials(self, credentials: AuthCredentials) -> bool:
-        """Validate LinkedIn 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 would need to be implemented in the client
-                return await client.is_authenticated()
-        except Exception as e:
-            logger.error(f"Error validating LinkedIn credentials: {e}")
-            return False