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

marqetive/core/progress.py

@@ -1,291 +0,0 @@
-"""Progress tracking system for long-running operations.
-
-This module provides models and utilities for tracking progress of operations
-like media uploads, post creation, and other long-running tasks.
-"""
-
-from collections.abc import Callable
-from datetime import datetime
-from enum import Enum
-from typing import Any
-
-from pydantic import BaseModel, Field
-
-
-class ProgressStatus(str, Enum):
-    """Status of a progress event."""
-
-    STARTED = "started"
-    IN_PROGRESS = "in_progress"
-    COMPLETED = "completed"
-    FAILED = "failed"
-    CANCELLED = "cancelled"
-
-
-class ProgressEvent(BaseModel):
-    """Represents a progress event for an operation.
-
-    Attributes:
-        operation: Name of the operation (e.g., "upload_media", "create_post").
-        progress: Current progress value (e.g., bytes uploaded).
-        total: Total expected value (e.g., total bytes).
-        status: Current status of the operation.
-        message: Optional human-readable message.
-        metadata: Additional operation-specific data.
-        timestamp: When this event occurred.
-
-    Example:
-        >>> event = ProgressEvent(
-        ...     operation="upload_media",
-        ...     progress=500,
-        ...     total=1000,
-        ...     status=ProgressStatus.IN_PROGRESS,
-        ...     message="Uploading image..."
-        ... )
-        >>> print(f"Progress: {event.percentage}%")
-        Progress: 50.0%
-    """
-
-    operation: str
-    progress: int | float
-    total: int | float | None = None
-    status: ProgressStatus
-    message: str | None = None
-    metadata: dict[str, Any] = Field(default_factory=dict)
-    timestamp: datetime = Field(default_factory=datetime.now)
-
-    @property
-    def percentage(self) -> float:
-        """Calculate progress as a percentage.
-
-        Returns:
-            Progress percentage (0-100), or 0 if total is None.
-        """
-        if self.total is None or self.total == 0:
-            return 0.0
-        return (self.progress / self.total) * 100
-
-    def is_complete(self) -> bool:
-        """Check if operation is complete.
-
-        Returns:
-            True if status is COMPLETED, False otherwise.
-        """
-        return self.status == ProgressStatus.COMPLETED
-
-    def is_failed(self) -> bool:
-        """Check if operation failed.
-
-        Returns:
-            True if status is FAILED, False otherwise.
-        """
-        return self.status == ProgressStatus.FAILED
-
-
-# Type alias for progress callback functions
-ProgressCallback = Callable[[ProgressEvent], None]
-
-
-class ProgressTracker:
-    """Tracks and emits progress events for operations.
-
-    Manages multiple progress callbacks and provides utilities for
-    emitting progress events with consistent formatting.
-
-    Example:
-        >>> tracker = ProgressTracker()
-        >>> tracker.add_callback(lambda e: print(f"{e.operation}: {e.percentage}%"))
-        >>>
-        >>> tracker.emit_start("upload_media")
-        >>> tracker.emit_progress("upload_media", 500, 1000, "Uploading...")
-        >>> tracker.emit_complete("upload_media", "Upload complete")
-    """
-
-    def __init__(self) -> None:
-        """Initialize progress tracker."""
-        self._callbacks: list[ProgressCallback] = []
-
-    def add_callback(self, callback: ProgressCallback) -> None:
-        """Add a progress callback.
-
-        Args:
-            callback: Function to call when progress events occur.
-
-        Example:
-            >>> def my_callback(event: ProgressEvent) -> None:
-            ...     print(f"{event.operation}: {event.percentage}%")
-            >>>
-            >>> tracker.add_callback(my_callback)
-        """
-        self._callbacks.append(callback)
-
-    def remove_callback(self, callback: ProgressCallback) -> None:
-        """Remove a progress callback.
-
-        Args:
-            callback: Callback to remove.
-        """
-        if callback in self._callbacks:
-            self._callbacks.remove(callback)
-
-    def clear_callbacks(self) -> None:
-        """Remove all callbacks."""
-        self._callbacks.clear()
-
-    def emit(self, event: ProgressEvent) -> None:
-        """Emit a progress event to all callbacks.
-
-        Args:
-            event: Progress event to emit.
-        """
-        import contextlib
-
-        for callback in self._callbacks:
-            with contextlib.suppress(Exception):
-                # Silently ignore callback errors to prevent disrupting operations
-                callback(event)
-
-    def emit_start(
-        self,
-        operation: str,
-        total: int | float | None = None,
-        message: str | None = None,
-        **metadata: Any,
-    ) -> None:
-        """Emit an operation start event.
-
-        Args:
-            operation: Name of the operation.
-            total: Total expected value (optional).
-            message: Optional message.
-            **metadata: Additional metadata.
-
-        Example:
-            >>> tracker.emit_start("upload_media", total=1024000,
-            ...                    message="Starting upload...")
-        """
-        event = ProgressEvent(
-            operation=operation,
-            progress=0,
-            total=total,
-            status=ProgressStatus.STARTED,
-            message=message or f"Starting {operation}",
-            metadata=metadata,
-        )
-        self.emit(event)
-
-    def emit_progress(
-        self,
-        operation: str,
-        progress: int | float,
-        total: int | float | None = None,
-        message: str | None = None,
-        **metadata: Any,
-    ) -> None:
-        """Emit a progress update event.
-
-        Args:
-            operation: Name of the operation.
-            progress: Current progress value.
-            total: Total expected value (optional).
-            message: Optional message.
-            **metadata: Additional metadata.
-
-        Example:
-            >>> tracker.emit_progress("upload_media", 512000, 1024000,
-            ...                       message="Uploading...")
-        """
-        event = ProgressEvent(
-            operation=operation,
-            progress=progress,
-            total=total,
-            status=ProgressStatus.IN_PROGRESS,
-            message=message,
-            metadata=metadata,
-        )
-        self.emit(event)
-
-    def emit_complete(
-        self,
-        operation: str,
-        message: str | None = None,
-        **metadata: Any,
-    ) -> None:
-        """Emit an operation complete event.
-
-        Args:
-            operation: Name of the operation.
-            message: Optional message.
-            **metadata: Additional metadata.
-
-        Example:
-            >>> tracker.emit_complete("upload_media",
-            ...                       message="Upload successful!")
-        """
-        event = ProgressEvent(
-            operation=operation,
-            progress=100,
-            total=100,
-            status=ProgressStatus.COMPLETED,
-            message=message or f"{operation} completed",
-            metadata=metadata,
-        )
-        self.emit(event)
-
-    def emit_failed(
-        self,
-        operation: str,
-        error: str | Exception,
-        **metadata: Any,
-    ) -> None:
-        """Emit an operation failed event.
-
-        Args:
-            operation: Name of the operation.
-            error: Error message or exception.
-            **metadata: Additional metadata.
-
-        Example:
-            >>> try:
-            ...     # Some operation
-            ...     pass
-            ... except Exception as e:
-            ...     tracker.emit_failed("upload_media", e)
-        """
-        message = str(error) if isinstance(error, Exception) else error
-        event = ProgressEvent(
-            operation=operation,
-            progress=0,
-            total=100,
-            status=ProgressStatus.FAILED,
-            message=message,
-            metadata=metadata,
-        )
-        self.emit(event)
-
-    def emit_cancelled(
-        self,
-        operation: str,
-        message: str | None = None,
-        **metadata: Any,
-    ) -> None:
-        """Emit an operation cancelled event.
-
-        Args:
-            operation: Name of the operation.
-            message: Optional message.
-            **metadata: Additional metadata.
-
-        Example:
-            >>> tracker.emit_cancelled("upload_media",
-            ...                        message="Upload cancelled by user")
-        """
-        event = ProgressEvent(
-            operation=operation,
-            progress=0,
-            total=100,
-            status=ProgressStatus.CANCELLED,
-            message=message or f"{operation} cancelled",
-            metadata=metadata,
-        )
-        self.emit(event)

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 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.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.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 marqetive.core.account_factory import BaseAccountFactory
-from marqetive.platforms.exceptions import PlatformAuthError
-from marqetive.platforms.instagram.client import InstagramClient
-from marqetive.platforms.models import AccountStatus, AuthCredentials
-from 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