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

marqetive/platforms/twitter/threads.py

@@ -1,442 +0,0 @@
-"""Twitter thread creation and management.
-
-This module provides utilities for creating and managing Twitter threads
-(sequences of connected tweets).
-"""
-
-from dataclasses import dataclass
-from typing import Any
-
-import tweepy
-
-from src.marqetive.platforms.exceptions import PlatformError, ValidationError
-from src.marqetive.platforms.models import Post, PostStatus
-
-
-@dataclass
-class TweetData:
-    """Data for a single tweet in a thread.
-
-    Attributes:
-        content: Tweet text content (max 280 characters).
-        media_ids: List of Twitter media IDs to attach.
-        alt_texts: Optional alt texts for media (same order as media_ids).
-    """
-
-    content: str
-    media_ids: list[str] | None = None
-    alt_texts: list[str] | None = None
-
-    def __post_init__(self) -> None:
-        """Validate tweet data after initialization."""
-        # Validate content length
-        if not self.content:
-            raise ValidationError(
-                "Tweet content cannot be empty",
-                platform="twitter",
-                field="content",
-            )
-
-        if len(self.content) > 280:
-            raise ValidationError(
-                f"Tweet exceeds 280 characters ({len(self.content)} characters)",
-                platform="twitter",
-                field="content",
-            )
-
-        # Validate media count (Twitter allows max 4 images or 1 video per tweet)
-        if self.media_ids and len(self.media_ids) > 4:
-            raise ValidationError(
-                f"Too many media attachments ({len(self.media_ids)}). "
-                "Twitter allows maximum 4 images or 1 video per tweet.",
-                platform="twitter",
-                field="media_ids",
-            )
-
-        # Validate alt texts match media count
-        if self.alt_texts:
-            if not self.media_ids:
-                raise ValidationError(
-                    "Cannot provide alt_texts without media_ids",
-                    platform="twitter",
-                    field="alt_texts",
-                )
-            if len(self.alt_texts) != len(self.media_ids):
-                raise ValidationError(
-                    f"Number of alt_texts ({len(self.alt_texts)}) must match "
-                    f"number of media_ids ({len(self.media_ids)})",
-                    platform="twitter",
-                    field="alt_texts",
-                )
-
-
-@dataclass
-class ThreadResult:
-    """Result of creating a Twitter thread.
-
-    Attributes:
-        thread_id: ID of the first tweet in the thread.
-        tweet_ids: List of all tweet IDs in order.
-        tweets: List of Post objects for each tweet.
-        total_tweets: Total number of tweets in the thread.
-    """
-
-    thread_id: str
-    tweet_ids: list[str]
-    tweets: list[Post]
-
-    @property
-    def total_tweets(self) -> int:
-        """Get total number of tweets in thread."""
-        return len(self.tweet_ids)
-
-    def __str__(self) -> str:
-        """String representation of thread result."""
-        return (
-            f"Thread(id={self.thread_id}, "
-            f"tweets={self.total_tweets}, "
-            f"ids={self.tweet_ids})"
-        )
-
-
-class TwitterThreadManager:
-    """Manager for creating and managing Twitter threads.
-
-    Example:
-        >>> manager = TwitterThreadManager(tweepy_client)
-        >>> tweets = [
-        ...     TweetData("First tweet in thread"),
-        ...     TweetData("Second tweet with more info"),
-        ...     TweetData("Final tweet with conclusion"),
-        ... ]
-        >>> result = await manager.create_thread(tweets)
-        >>> print(f"Created thread: {result.thread_id}")
-    """
-
-    def __init__(self, tweepy_client: tweepy.Client) -> None:
-        """Initialize thread manager.
-
-        Args:
-            tweepy_client: Authenticated tweepy Client instance.
-        """
-        self.client = tweepy_client
-
-    async def create_thread(
-        self,
-        tweets: list[TweetData],
-        *,
-        auto_number: bool = False,
-        number_format: str = "{index}/{total}",
-    ) -> ThreadResult:
-        """Create a Twitter thread from multiple tweets.
-
-        Args:
-            tweets: List of TweetData objects representing the thread.
-            auto_number: If True, automatically add tweet numbers to content.
-            number_format: Format string for auto-numbering (supports {index}, {total}).
-
-        Returns:
-            ThreadResult with thread ID and all tweet information.
-
-        Raises:
-            ValidationError: If thread data is invalid.
-            PlatformError: If thread creation fails.
-
-        Example:
-            >>> tweets = [
-            ...     TweetData("Part 1: Introduction"),
-            ...     TweetData("Part 2: Details"),
-            ...     TweetData("Part 3: Conclusion"),
-            ... ]
-            >>> result = await manager.create_thread(tweets, auto_number=True)
-        """
-        if not tweets:
-            raise ValidationError(
-                "Thread must contain at least one tweet",
-                platform="twitter",
-                field="tweets",
-            )
-
-        if len(tweets) > 25:
-            raise ValidationError(
-                f"Thread too long ({len(tweets)} tweets). "
-                "Consider splitting into multiple threads.",
-                platform="twitter",
-                field="tweets",
-            )
-
-        thread_id: str | None = None
-        tweet_ids: list[str] = []
-        post_objects: list[Post] = []
-        previous_tweet_id: str | None = None
-
-        try:
-            for index, tweet_data in enumerate(tweets, start=1):
-                # Prepare tweet content
-                content = tweet_data.content
-
-                # Add auto-numbering if requested
-                if auto_number and len(tweets) > 1:
-                    number_prefix = number_format.format(
-                        index=index,
-                        total=len(tweets),
-                    )
-                    content = f"{number_prefix} {content}"
-
-                    # Validate length after numbering
-                    if len(content) > 280:
-                        raise ValidationError(
-                            f"Tweet {index} exceeds 280 characters after auto-numbering "
-                            f"({len(content)} characters). Consider shorter content or "
-                            "disable auto_number.",
-                            platform="twitter",
-                            field="content",
-                        )
-
-                # Prepare tweet parameters
-                tweet_params: dict[str, Any] = {"text": content}
-
-                # Add reply-to for threading
-                if previous_tweet_id:
-                    tweet_params["in_reply_to_tweet_id"] = previous_tweet_id
-
-                # Add media if provided
-                if tweet_data.media_ids:
-                    tweet_params["media_ids"] = tweet_data.media_ids
-
-                # Create tweet
-                response = self.client.create_tweet(**tweet_params)
-                tweet_id = str(response.data["id"])  # type: ignore[index]
-
-                # Store IDs
-                if thread_id is None:
-                    thread_id = tweet_id
-                tweet_ids.append(tweet_id)
-                previous_tweet_id = tweet_id
-
-                # Fetch full tweet details
-                tweet_response = self.client.get_tweet(
-                    tweet_id,
-                    tweet_fields=[
-                        "created_at",
-                        "public_metrics",
-                        "attachments",
-                        "author_id",
-                    ],
-                )
-
-                # Convert to Post object
-                tweet = tweet_response.data  # type: ignore[attr-defined]
-                post = Post(
-                    post_id=tweet_id,
-                    platform="twitter",
-                    content=content,
-                    status=PostStatus.PUBLISHED,
-                    created_at=tweet.created_at,
-                    author_id=str(tweet.author_id) if tweet.author_id else None,
-                    raw_data=tweet.data,
-                )
-                post_objects.append(post)
-
-        except tweepy.TweepyException as e:
-            # If thread creation fails partway through, we have partial thread
-            # Log the created tweets for cleanup if needed
-            if tweet_ids:
-                raise PlatformError(
-                    f"Thread creation failed at tweet {len(tweet_ids) + 1}. "
-                    f"Partial thread created with IDs: {tweet_ids}. "
-                    f"Error: {e}",
-                    platform="twitter",
-                ) from e
-            raise PlatformError(
-                f"Failed to create thread: {e}",
-                platform="twitter",
-            ) from e
-
-        if not thread_id:
-            raise PlatformError(
-                "Thread creation completed but no thread ID available",
-                platform="twitter",
-            )
-
-        return ThreadResult(
-            thread_id=thread_id,
-            tweet_ids=tweet_ids,
-            tweets=post_objects,
-        )
-
-    async def delete_thread(
-        self,
-        thread_id: str,
-        tweet_ids: list[str],
-        *,
-        continue_on_error: bool = True,
-    ) -> dict[str, bool]:
-        """Delete all tweets in a thread.
-
-        Args:
-            thread_id: ID of the first tweet (for logging).
-            tweet_ids: List of all tweet IDs to delete.
-            continue_on_error: If True, continue deleting even if some fail.
-
-        Returns:
-            Dictionary mapping tweet_id to deletion success status.
-
-        Example:
-            >>> result = await manager.delete_thread(
-            ...     thread_id="123",
-            ...     tweet_ids=["123", "456", "789"]
-            ... )
-            >>> print(f"Deleted: {sum(result.values())} / {len(result)} tweets")
-        """
-        results: dict[str, bool] = {}
-        errors: list[str] = []
-
-        # Delete in reverse order (newest to oldest)
-        for tweet_id in reversed(tweet_ids):
-            try:
-                self.client.delete_tweet(tweet_id)
-                results[tweet_id] = True
-            except tweepy.TweepyException as e:
-                results[tweet_id] = False
-                errors.append(f"Tweet {tweet_id}: {e}")
-
-                if not continue_on_error:
-                    raise PlatformError(
-                        f"Failed to delete tweet {tweet_id} in thread {thread_id}: {e}",
-                        platform="twitter",
-                    ) from e
-
-        # If there were errors but continue_on_error=True, log them
-        if errors:
-            error_summary = "; ".join(errors)
-            raise PlatformError(
-                f"Some tweets in thread {thread_id} failed to delete: {error_summary}",
-                platform="twitter",
-            )
-
-        return results
-
-
-def split_content_into_tweets(
-    content: str,
-    *,
-    max_length: int = 280,
-    split_on_sentences: bool = True,
-    add_continuation: bool = True,
-    continuation_suffix: str = "...",
-) -> list[str]:
-    """Split long content into multiple tweet-sized chunks.
-
-    Attempts to split on sentence boundaries when possible.
-
-    Args:
-        content: Long text content to split.
-        max_length: Maximum characters per tweet (default: 280).
-        split_on_sentences: Try to split on sentence boundaries.
-        add_continuation: Add continuation indicator to split tweets.
-        continuation_suffix: Suffix to add when splitting mid-content.
-
-    Returns:
-        List of tweet content strings.
-
-    Example:
-        >>> long_text = "This is a very long piece of content..." * 20
-        >>> tweets = split_content_into_tweets(long_text)
-        >>> print(f"Split into {len(tweets)} tweets")
-    """
-    if len(content) <= max_length:
-        return [content]
-
-    tweets: list[str] = []
-    remaining = content
-
-    while remaining:
-        # Calculate available space
-        available = max_length
-        if add_continuation and len(remaining) > max_length:
-            available -= len(continuation_suffix)
-
-        if len(remaining) <= available:
-            # Last chunk
-            tweets.append(remaining)
-            break
-
-        # Find split point
-        split_point = available
-
-        if split_on_sentences:
-            # Try to split on sentence boundary
-            sentence_ends = [". ", "! ", "? ", ".\n", "!\n", "?\n"]
-            best_split = 0
-
-            for sent_end in sentence_ends:
-                pos = remaining[:available].rfind(sent_end)
-                if pos > best_split:
-                    best_split = pos + len(sent_end)
-
-            if best_split > 0:
-                split_point = best_split
-            else:
-                # Try to split on word boundary
-                last_space = remaining[:available].rfind(" ")
-                if last_space > 0:
-                    split_point = last_space + 1
-
-        # Extract chunk
-        chunk = remaining[:split_point].rstrip()
-
-        # Add continuation indicator if not at end
-        if add_continuation and len(remaining) > split_point:
-            chunk += continuation_suffix
-
-        tweets.append(chunk)
-        remaining = remaining[split_point:].lstrip()
-
-    return tweets
-
-
-def create_numbered_thread(
-    content_parts: list[str],
-    *,
-    number_format: str = "{index}/{total}",
-    media_per_tweet: list[list[str]] | None = None,
-) -> list[TweetData]:
-    """Create a numbered thread from content parts.
-
-    Convenience function to create TweetData with auto-numbering.
-
-    Args:
-        content_parts: List of content strings, one per tweet.
-        number_format: Format string for numbering.
-        media_per_tweet: Optional list of media ID lists, one per tweet.
-
-    Returns:
-        List of TweetData objects ready for thread creation.
-
-    Example:
-        >>> parts = ["Introduction", "Main content", "Conclusion"]
-        >>> tweets = create_numbered_thread(parts)
-        >>> # Tweets will be: "1/3 Introduction", "2/3 Main content", "3/3 Conclusion"
-    """
-    total = len(content_parts)
-    tweet_data_list: list[TweetData] = []
-
-    for index, content in enumerate(content_parts, start=1):
-        # Add number prefix
-        number_prefix = number_format.format(index=index, total=total)
-        numbered_content = f"{number_prefix} {content}"
-
-        # Get media for this tweet if provided
-        media_ids = None
-        if media_per_tweet and index - 1 < len(media_per_tweet):
-            media_ids = media_per_tweet[index - 1]
-
-        tweet_data_list.append(
-            TweetData(
-                content=numbered_content,
-                media_ids=media_ids,
-            )
-        )
-
-    return tweet_data_list

marqetive/registry_init.py

@@ -1,66 +0,0 @@
-"""Registry initialization for platform managers.
-
-This module provides the initialization function that registers all available
-platform managers with the global registry.
-"""
-
-import logging
-
-from src.marqetive.core.registry import register_platform
-from src.marqetive.platforms.instagram.manager import InstagramPostManager
-from src.marqetive.platforms.linkedin.manager import LinkedInPostManager
-from src.marqetive.platforms.twitter.manager import TwitterPostManager
-
-logger = logging.getLogger(__name__)
-
-_initialized = False
-
-
-def initialize_platform_registry() -> None:
-    """Initialize the platform registry with all available platforms.
-
-    This function registers all platform managers (Twitter, LinkedIn, Instagram)
-    with the global registry. It should be called once at application startup.
-
-    This function is idempotent - calling it multiple times is safe.
-
-    Example:
-        >>> from marqetive_lib import initialize_platform_registry
-        >>> initialize_platform_registry()
-        >>> # Now you can use get_manager_for_platform()
-        >>> from marqetive_lib import get_manager_for_platform
-        >>> manager = get_manager_for_platform("twitter")
-    """
-    global _initialized
-
-    if _initialized:
-        logger.debug("Platform registry already initialized")
-        return
-
-    logger.info("Initializing platform registry...")
-
-    # Register all platform managers
-    register_platform("twitter", TwitterPostManager)
-    register_platform("linkedin", LinkedInPostManager)
-    register_platform("instagram", InstagramPostManager)
-
-    _initialized = True
-    logger.info("Platform registry initialized with 3 platforms")
-
-
-def is_registry_initialized() -> bool:
-    """Check if registry has been initialized.
-
-    Returns:
-        True if initialized, False otherwise.
-    """
-    return _initialized
-
-
-def reset_registry() -> None:
-    """Reset the initialization flag.
-
-    This is mainly useful for testing. It allows re-initialization of the registry.
-    """
-    global _initialized
-    _initialized = False

marqetive_lib-0.1.2.dist-info/RECORD

@@ -1,48 +0,0 @@
-marqetive/__init__.py,sha256=XVnYmB817AILAnJYg1WVNnmrd1MvJns3QpPbfdjmwRE,3142
-marqetive/core/__init__.py,sha256=5Wgcby-EQkTxrPVD4so69nBmZ66Ng9JGqBov4RQMT4A,117
-marqetive/core/account_factory.py,sha256=9fsP6fzLYp3UGU59fkxwURgzn7eBxr8-WJt3aP-Z65U,7153
-marqetive/core/base_manager.py,sha256=z28bV4p1FC7s9g_YkXIKW_qkv8bjF4tMoF-cGGksJuA,10047
-marqetive/core/client.py,sha256=2_FoNpqaRglsWg10i5RTbyDg_kRQKhgWjYs6iDdFxLg,3210
-marqetive/core/progress.py,sha256=5Vyksf8YfQUVRudwDEuegcxoc0js5qbHM2SFZ6VLxHM,8593
-marqetive/core/registry.py,sha256=D6qlafpvemYfE9GouWcWZyltK0aNcFLSi_2M-WdTIdE,8084
-marqetive/platforms/__init__.py,sha256=6QjetNWodf32pgGQsmLKs7W-v-pG2kKckb5JEPqIPNI,1351
-marqetive/platforms/base.py,sha256=zmCda00Szq_LswRdsWPI5V88TysLH3FIZ0mKwH6b8dE,11957
-marqetive/platforms/exceptions.py,sha256=Xyj0bzNiZm5VTErmzXgVW8T6IQnOpF92-HJiKPKjIio,7076
-marqetive/platforms/instagram/__init__.py,sha256=9V0GPVm9HSTtDdV0bQEfuND8r7PEF2smOL3lb5BZevg,343
-marqetive/platforms/instagram/client.py,sha256=PxVsHUW8SSpPe2Kdd5zGezD7LUvJj5tdyNj8In_ChxI,24955
-marqetive/platforms/instagram/exceptions.py,sha256=zFG_CkstlZWG47zsFdnObOZviTDIx3Z8yVG9-x7GMVY,8987
-marqetive/platforms/instagram/factory.py,sha256=082cF47zs9GvrnrFFaKmftbt_GmvcHZvSNIJsOQcupY,3553
-marqetive/platforms/instagram/manager.py,sha256=RhV2QpLp9z2p-MCP3E-UzeYFCmuB0K8PIdDfwSaxdJI,3730
-marqetive/platforms/instagram/media.py,sha256=tbFzOf670T8UDoCD9fVeS03Uzhp6HSUFrpPgJVgpdRE,21174
-marqetive/platforms/linkedin/__init__.py,sha256=mcHNOKW5niq0MGBMuRpCJfEg2DkE3sCt0J0AqSZUPBs,333
-marqetive/platforms/linkedin/client.py,sha256=d7YDd23VAqUMAHw8Oi9Swpq5RwhIIpl4TjbrBI9GkfE,23574
-marqetive/platforms/linkedin/exceptions.py,sha256=64J02_99cUcUW5i5xHE_sa0_6V4ibW8PmCEz2aROIE4,9771
-marqetive/platforms/linkedin/factory.py,sha256=8JNxAMC-lJcU1trnd0PFge0LQWQMiIVzZORJHwcBhmM,4536
-marqetive/platforms/linkedin/manager.py,sha256=XB6HB6-MWsDz2Arij5GuyRH_j5xWkYb8sHCTlKFWzMg,4000
-marqetive/platforms/linkedin/media.py,sha256=busrlTA3CisY43qDy9dmiAmbFVz8De4nDsA4CV9PeWk,16917
-marqetive/platforms/models.py,sha256=W_yOuRWItWSn82n8vXRNN_ScdNkzY1De2qqXaVN2RGU,10974
-marqetive/platforms/tiktok/__init__.py,sha256=_lfPj-5VfNaL4cE39Uiv8QOI1DtRnKiP5feKdPQ53zI,313
-marqetive/platforms/tiktok/client.py,sha256=p0uhPCyjykMj8mx0y3oCEOTNwEM_obr1CW8iLz-8AMw,10715
-marqetive/platforms/tiktok/exceptions.py,sha256=SKzmAEIfBf9qeYPXdOFKL2ARx7MK_h57fyohbg_86vY,5780
-marqetive/platforms/tiktok/factory.py,sha256=aqzyWe42i0R3Tvr2ml2xEYeW2e3USqIkz5-o8O5ae64,6764
-marqetive/platforms/tiktok/manager.py,sha256=0bIL26NCppN5PFk0DKPaH2zyrm4wwA-Mfm8KQwq97UY,4113
-marqetive/platforms/tiktok/media.py,sha256=B3QoE05xlQ0OSZ_1y_MiNX8bJFwbyM4jDvM4w7A-HHA,10652
-marqetive/platforms/twitter/__init__.py,sha256=TRVOejA-wa_tw50_YUwTYnhGyGuOK2IFpZWvVZP94HQ,325
-marqetive/platforms/twitter/client.py,sha256=s5nLUc3wOSEBCNuFCqxoLqUypBI6eDK6fRC1iP5OnZU,20856
-marqetive/platforms/twitter/exceptions.py,sha256=yRLLcodSouaFV076iwbxcWZzXUuoswAOXuL_-iPvLOk,8935
-marqetive/platforms/twitter/factory.py,sha256=nBBl5aFcNCgIwf45PWywjpx_Qp0aOdbOHthvQX-BzI4,5286
-marqetive/platforms/twitter/manager.py,sha256=NEqFllDdQ6nlUQMV1M5koX8DMURuvNsa39gKiTpm5A0,4108
-marqetive/platforms/twitter/media.py,sha256=szkILg8geuH5wVbGXUBeHr9B-48j08njb-NlClPDcQQ,24984
-marqetive/platforms/twitter/threads.py,sha256=F1msBRcmpAb_NKaZvdDn0oA_cQwwzFoXGeiUIdr7rrY,14772
-marqetive/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-marqetive/registry_init.py,sha256=ozvGN_lWWx_vvYcU_ONA49EzwN4ymbrB1jtkRchYvAU,2051
-marqetive/utils/__init__.py,sha256=qBn_DN-L2YTfuB_G-n_bHJjtuVRiyH3ftl9JZ0JO93M,989
-marqetive/utils/file_handlers.py,sha256=IUdRZxr_jxAuwxUypUkUgKqiGDcIHNr1LhCb2Ne2a98,12572
-marqetive/utils/helpers.py,sha256=8-ljhL47SremKcQO2GF8DIHOPODEv1rSioVNuSPCbec,2634
-marqetive/utils/media.py,sha256=Rvxw9XKU65n-z4G1bEihG3wXZBmjSDZUqClfjGFrg6k,12013
-marqetive/utils/oauth.py,sha256=B8GbzliQKEV5XpPshrKCHNlFl_arEOfZ10KKIUDKfQg,12113
-marqetive/utils/retry.py,sha256=lAniJLMNWp9XsHrvU0XBNifpNEjfde4MGfd5hlFTPfA,7636
-marqetive/utils/token_validator.py,sha256=asLMiEgT-BtqEpn_HDX15vJoSBcH7CGW0abervFOXxM,6707
-marqetive_lib-0.1.2.dist-info/METADATA,sha256=xk2oWdG9QJlzw1Mu49BWngovHJ4izI2N0pwZFKNzP-4,7798
-marqetive_lib-0.1.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-marqetive_lib-0.1.2.dist-info/RECORD,,