marqetive-lib 0.1.14__tar.gz → 0.1.16__tar.gz

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/PKG-INFO

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

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "marqetive-lib"
-version = "0.1.14"
+version = "0.1.16"
 description = "Modern Python utilities for web APIs"
 readme = "README.md"
 requires-python = ">=3.12"

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/src/marqetive/core/base.py

@@ -9,7 +9,7 @@ import inspect
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
 from datetime import datetime
-from traceback import TracebackException
+from types import TracebackType
 from typing import Any
 
 from marqetive.core.client import APIClient
@@ -119,7 +119,7 @@ class SocialMediaPlatform(ABC):
         return self
 
     async def __aexit__(
-        self, exc_type: type[Exception], exc_val: Any, exc_tb: TracebackException
+        self, exc_type: type[Exception] | None, exc_val: Exception | None, exc_tb: TracebackType | None
     ) -> None:
         """Async context manager exit."""
         if self.api_client:

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/src/marqetive/platforms/instagram/client.py

@@ -360,7 +360,16 @@ class InstagramClient(SocialMediaPlatform):
         )
 
         result = await self._media_manager.publish_container(container_ids[0])
-        return await self.get_post(result.media_id)
+
+        # Return minimal Post object without fetching details
+        return Post(
+            post_id=result.media_id,
+            platform=self.platform_name,
+            content=request.content,
+            status=PostStatus.PUBLISHED,
+            created_at=datetime.now(),
+            url=cast(HttpUrl, result.permalink) if result.permalink else None,
+        )
 
     async def _create_carousel_post(self, request: PostCreateRequest) -> Post:
         """Create a carousel post (2-10 images).
@@ -789,7 +798,9 @@ class InstagramClient(SocialMediaPlatform):
             alt_text = None
             if alt_texts and idx < len(alt_texts):
                 alt_text = alt_texts[idx]
-            media_items.append(MediaItem(url=validated_url, type="image", alt_text=alt_text))
+            media_items.append(
+                MediaItem(url=validated_url, type="image", alt_text=alt_text)
+            )
 
         # Create containers
         container_ids = await self._media_manager.create_feed_containers(
@@ -801,8 +812,15 @@ class InstagramClient(SocialMediaPlatform):
         # Publish
         result = await self._media_manager.publish_container(container_ids[0])
 
-        # Fetch and return post
-        return await self.get_post(result.media_id)
+        # Return minimal Post object without fetching details
+        return Post(
+            post_id=result.media_id,
+            platform=self.platform_name,
+            content=caption,
+            status=PostStatus.PUBLISHED,
+            created_at=datetime.now(),
+            url=cast(HttpUrl, result.permalink) if result.permalink else None,
+        )
 
     async def create_reel(
         self,
@@ -858,8 +876,15 @@ class InstagramClient(SocialMediaPlatform):
         # Publish
         result = await self._media_manager.publish_container(container_id)
 
-        # Fetch and return post
-        return await self.get_post(result.media_id)
+        # Return minimal Post object without fetching details
+        return Post(
+            post_id=result.media_id,
+            platform=self.platform_name,
+            content=caption,
+            status=PostStatus.PUBLISHED,
+            created_at=datetime.now(),
+            url=cast(HttpUrl, result.permalink) if result.permalink else None,
+        )
 
     async def create_story(
         self,
@@ -902,8 +927,15 @@ class InstagramClient(SocialMediaPlatform):
         # Publish
         result = await self._media_manager.publish_container(container_id)
 
-        # Fetch and return post
-        return await self.get_post(result.media_id)
+        # Return minimal Post object without fetching details
+        return Post(
+            post_id=result.media_id,
+            platform=self.platform_name,
+            content=None,  # Stories don't have captions
+            status=PostStatus.PUBLISHED,
+            created_at=datetime.now(),
+            url=cast(HttpUrl, result.permalink) if result.permalink else None,
+        )
 
     # ==================== Helper Methods ====================
 

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/src/marqetive/platforms/linkedin/client.py

@@ -8,7 +8,8 @@ API Documentation: https://learn.microsoft.com/en-us/linkedin/marketing/communit
 """
 
 import contextlib
-from datetime import datetime
+import os
+from datetime import datetime, timedelta
 from typing import Any, cast
 from urllib.parse import quote
 
@@ -202,11 +203,15 @@ class LinkedInClient(SocialMediaPlatform):
         LinkedIn access tokens typically expire after 60 days. Use the
         refresh token to obtain a new access token.
 
+        Requires LINKEDIN_CLIENT_ID and LINKEDIN_CLIENT_SECRET environment
+        variables, or provide OAuth credentials via PlatformFactory.
+
         Returns:
             Updated credentials with new access token.
 
         Raises:
-            PlatformAuthError: If token refresh fails.
+            PlatformAuthError: If token refresh fails or OAuth credentials
+                are missing.
         """
         if not self.credentials.refresh_token:
             raise PlatformAuthError(
@@ -214,13 +219,64 @@ class LinkedInClient(SocialMediaPlatform):
                 platform=self.platform_name,
             )
 
-        # Note: LinkedIn OAuth token refresh requires making a request to
-        # https://www.linkedin.com/oauth/v2/accessToken
-        # This is simplified for demonstration
-        raise PlatformAuthError(
-            "Token refresh not yet implemented. Please re-authenticate.",
-            platform=self.platform_name,
-        )
+        # Get OAuth credentials from environment
+        client_id = os.getenv("LINKEDIN_CLIENT_ID")
+        client_secret = os.getenv("LINKEDIN_CLIENT_SECRET")
+
+        if not client_id or not client_secret:
+            raise PlatformAuthError(
+                "LinkedIn OAuth credentials required for token refresh. "
+                "Set LINKEDIN_CLIENT_ID and LINKEDIN_CLIENT_SECRET environment "
+                "variables, or use PlatformFactory for automatic token refresh.",
+                platform=self.platform_name,
+            )
+
+        # Make token refresh request
+        token_url = "https://www.linkedin.com/oauth/v2/accessToken"
+        params = {
+            "grant_type": "refresh_token",
+            "refresh_token": self.credentials.refresh_token,
+            "client_id": client_id,
+            "client_secret": client_secret,
+        }
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    token_url,
+                    data=params,
+                    headers={"Content-Type": "application/x-www-form-urlencoded"},
+                    timeout=30.0,
+                )
+                response.raise_for_status()
+                token_data = response.json()
+
+        except httpx.HTTPStatusError as e:
+            raise PlatformAuthError(
+                f"Failed to refresh token: {e.response.text}",
+                platform=self.platform_name,
+                status_code=e.response.status_code,
+            ) from e
+
+        except httpx.HTTPError as e:
+            raise PlatformAuthError(
+                f"Network error refreshing token: {e}",
+                platform=self.platform_name,
+            ) from e
+
+        # Update credentials
+        self.credentials.access_token = token_data["access_token"]
+
+        # LinkedIn might provide new refresh token
+        if "refresh_token" in token_data:
+            self.credentials.refresh_token = token_data["refresh_token"]
+
+        # Calculate expiry
+        if "expires_in" in token_data:
+            expires_in = int(token_data["expires_in"])
+            self.credentials.expires_at = datetime.now() + timedelta(seconds=expires_in)
+
+        return self.credentials
 
     async def is_authenticated(self) -> bool:
         """Check if LinkedIn credentials are valid.
@@ -370,8 +426,16 @@ class LinkedInClient(SocialMediaPlatform):
                     platform=self.platform_name,
                 )
 
-            # Fetch full post details
-            return await self.get_post(post_id)
+            # Return minimal Post object without fetching details
+            return Post(
+                post_id=post_id,
+                platform=self.platform_name,
+                content=request.content or "",
+                status=PostStatus.PUBLISHED,
+                created_at=datetime.now(),
+                author_id=self.author_urn,
+                raw_data=response.data,
+            )
 
         except httpx.HTTPError as e:
             raise PlatformError(

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/src/marqetive/platforms/tiktok/client.py

@@ -231,24 +231,18 @@ class TikTokClient(SocialMediaPlatform):
             wait_for_publish=True,
         )
 
-        # 4. Return post - either fetch full details or create minimal Post
-        if upload_result.video_id:
-            # Fetch the created post to return full Post object
-            return await self.get_post(upload_result.video_id)
-
-        # For private/SELF_ONLY posts, TikTok may not return video_id
-        # Return a minimal Post object with publish_id
+        # 4. Return minimal Post object without fetching details
         return Post(
-            post_id=upload_result.publish_id,
+            post_id=upload_result.video_id or upload_result.publish_id,
             platform=self.platform_name,
             content=request.content,
             status=PostStatus.PUBLISHED,
             created_at=datetime.now(),
             raw_data={
                 "publish_id": upload_result.publish_id,
+                "video_id": upload_result.video_id,
                 "upload_status": upload_result.status,
                 "privacy_level": privacy_level.value,
-                "note": "Video published but video_id not returned (common for private posts)",
             },
         )
 

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/src/marqetive/platforms/tiktok/media.py

@@ -718,7 +718,9 @@ class TikTokMediaManager:
                     os.remove(temp_file_path)
                     logger.debug(f"Cleaned up temp file: {temp_file_path}")
                 except OSError as e:
-                    logger.warning(f"Failed to clean up temp file {temp_file_path}: {e}")
+                    logger.warning(
+                        f"Failed to clean up temp file {temp_file_path}: {e}"
+                    )
 
     def _normalize_chunk_size(self, chunk_size: int, file_size: int) -> int:
         """Normalize chunk size to TikTok's requirements.

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/src/marqetive/platforms/twitter/client.py

@@ -32,8 +32,10 @@ from marqetive.core.models import (
     PostCreateRequest,
     PostStatus,
     PostUpdateRequest,
+    ProgressStatus,
 )
 from marqetive.platforms.twitter.media import TwitterMediaManager
+from marqetive.platforms.twitter.models import TwitterPostRequest
 
 
 class TwitterClient(SocialMediaPlatform):
@@ -226,6 +228,16 @@ class TwitterClient(SocialMediaPlatform):
             if media_ids:
                 tweet_params["media_ids"] = media_ids
 
+            # Check for reply_to_post_id (used for threads and replies)
+            reply_to_id = getattr(request, "reply_to_post_id", None)
+            if reply_to_id:
+                tweet_params["in_reply_to_tweet_id"] = reply_to_id
+
+            # Check for quote_post_id (used for quote tweets)
+            quote_id = getattr(request, "quote_post_id", None)
+            if quote_id:
+                tweet_params["quote_tweet_id"] = quote_id
+
             response = self._tweepy_client.create_tweet(**tweet_params, user_auth=False)
             tweet_id = response.data["id"]  # type: ignore[index]
 
@@ -530,6 +542,87 @@ class TwitterClient(SocialMediaPlatform):
                 media_type=media_type,
             ) from e
 
+    # ==================== Retweet Methods ====================
+
+    async def retweet(self, tweet_id: str) -> bool:
+        """Retweet a tweet.
+
+        Args:
+            tweet_id: ID of the tweet to retweet.
+
+        Returns:
+            True if retweet was successful.
+
+        Raises:
+            PostNotFoundError: If tweet doesn't exist.
+            PlatformError: If retweet fails.
+            RuntimeError: If client not used as context manager.
+        """
+        if not self._tweepy_client:
+            raise RuntimeError("Client must be used as async context manager")
+
+        try:
+            response = self._tweepy_client.retweet(tweet_id, user_auth=False)
+            return response.data.get("retweeted", False)  # type: ignore[union-attr]
+
+        except tweepy.errors.NotFound as e:  # type: ignore[attr-defined]
+            raise PostNotFoundError(
+                post_id=tweet_id,
+                platform=self.platform_name,
+                status_code=404,
+            ) from e
+        except tweepy.TweepyException as e:
+            if "429" in str(e):
+                raise RateLimitError(
+                    "Twitter rate limit exceeded",
+                    platform=self.platform_name,
+                    status_code=429,
+                ) from e
+            raise PlatformError(
+                f"Failed to retweet: {e}",
+                platform=self.platform_name,
+            ) from e
+
+    async def unretweet(self, tweet_id: str) -> bool:
+        """Undo a retweet (unretweet).
+
+        Args:
+            tweet_id: ID of the tweet to unretweet.
+
+        Returns:
+            True if unretweet was successful.
+
+        Raises:
+            PostNotFoundError: If tweet doesn't exist.
+            PlatformError: If unretweet fails.
+            RuntimeError: If client not used as context manager.
+        """
+        if not self._tweepy_client:
+            raise RuntimeError("Client must be used as async context manager")
+
+        try:
+            response = self._tweepy_client.unretweet(tweet_id, user_auth=False)
+            # Response indicates retweeted=False when successfully unretweeted
+            return not response.data.get("retweeted", True)  # type: ignore[union-attr]
+
+        except tweepy.errors.NotFound as e:  # type: ignore[attr-defined]
+            raise PostNotFoundError(
+                post_id=tweet_id,
+                platform=self.platform_name,
+                status_code=404,
+            ) from e
+        except tweepy.TweepyException as e:
+            if "429" in str(e):
+                raise RateLimitError(
+                    "Twitter rate limit exceeded",
+                    platform=self.platform_name,
+                    status_code=429,
+                ) from e
+            raise PlatformError(
+                f"Failed to unretweet: {e}",
+                platform=self.platform_name,
+            ) from e
+
     # ==================== Thread Methods ====================
 
     async def create_thread(
@@ -567,9 +660,6 @@ class TwitterClient(SocialMediaPlatform):
             ...     for post in thread_posts:
             ...         print(f"Tweet {post.post_id}: {post.content}")
         """
-        from marqetive.core.models import ProgressStatus
-        from marqetive.platforms.twitter.models import TwitterPostRequest
-
         if not posts:
             raise ValidationError(
                 "At least one tweet is required for thread creation",

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/src/marqetive/utils/file_handlers.py

@@ -17,7 +17,99 @@ from typing import Any
 import aiofiles
 import httpx
 
-from marqetive.utils.media import detect_mime_type, format_file_size
+from marqetive.core.exceptions import ValidationError
+from marqetive.utils.media import detect_mime_type, format_file_size, validate_media_url
+
+# System directories that should never be written to
+# Includes both standard paths and macOS /private/* equivalents
+_BLOCKED_SYSTEM_DIRS: frozenset[str] = frozenset(
+    {
+        "/etc",
+        "/private/etc",
+        "/usr",
+        "/bin",
+        "/sbin",
+        "/var",
+        "/private/var",
+        "/root",
+        "/lib",
+        "/lib64",
+        "/boot",
+    }
+)
+
+
+def _validate_path(
+    file_path: str,
+    *,
+    allowed_base_dirs: set[str] | None = None,
+) -> str:
+    """Validate and normalize a file path for security.
+
+    Prevents path traversal attacks by:
+    1. Checking for null bytes (injection attack)
+    2. Resolving to absolute path (handles .. and symlinks)
+    3. Blocking writes to sensitive system directories
+
+    Args:
+        file_path: Path to validate.
+        allowed_base_dirs: Optional set of allowed base directories.
+            If provided, path must be within one of these directories.
+
+    Returns:
+        Normalized absolute path.
+
+    Raises:
+        ValidationError: If path is invalid or blocked.
+
+    Example:
+        >>> _validate_path("/tmp/myfile.txt")
+        '/tmp/myfile.txt'
+        >>> _validate_path("../../../etc/passwd")  # raises ValidationError
+    """
+    # Check for null bytes (path injection attack)
+    if "\x00" in file_path:
+        raise ValidationError(
+            "Path contains null bytes",
+            platform="file_handlers",
+            field="file_path",
+        )
+
+    # Resolve to absolute path (handles .., symlinks, etc.)
+    try:
+        resolved = Path(file_path).resolve()
+        resolved_str = str(resolved)
+    except (OSError, RuntimeError) as e:
+        raise ValidationError(
+            f"Invalid path: {e}",
+            platform="file_handlers",
+            field="file_path",
+        ) from e
+
+    # Block writes to system directories
+    for blocked in _BLOCKED_SYSTEM_DIRS:
+        if resolved_str.startswith(blocked + "/") or resolved_str == blocked:
+            raise ValidationError(
+                f"Writing to system directory '{blocked}' is not allowed",
+                platform="file_handlers",
+                field="file_path",
+            )
+
+    # If allowed_base_dirs specified, validate path is within them
+    if allowed_base_dirs:
+        is_allowed = any(
+            resolved_str.startswith(str(Path(base).resolve()) + "/")
+            or resolved_str == str(Path(base).resolve())
+            for base in allowed_base_dirs
+        )
+        if not is_allowed:
+            raise ValidationError(
+                f"Path '{file_path}' is outside allowed directories",
+                platform="file_handlers",
+                field="file_path",
+            )
+
+    return resolved_str
 
 
 class DownloadProgress:
@@ -68,8 +160,9 @@ async def download_file(
     chunk_size: int = 8192,
     progress_callback: Callable[[DownloadProgress], None] | None = None,
     timeout: float = 300.0,
+    validate_url: bool = True,
 ) -> str:
-    """Download a file from URL asynchronously.
+    """Download a file from URL asynchronously with SSRF protection.
 
     Args:
         url: URL to download from.
@@ -77,11 +170,14 @@ async def download_file(
         chunk_size: Size of chunks to download (default: 8KB).
         progress_callback: Optional callback function called with progress updates.
         timeout: Request timeout in seconds (default: 5 minutes).
+        validate_url: If True (default), validate URL for SSRF protection.
+            Blocks private IPs, localhost, and other internal addresses.
 
     Returns:
         Path to the downloaded file.
 
     Raises:
+        ValidationError: If URL fails security validation.
         httpx.HTTPError: If download fails.
         IOError: If file write fails.
 
@@ -95,6 +191,14 @@ async def download_file(
         ...     progress_callback=on_progress
         ... )
     """
+    # Validate URL for SSRF protection (blocks private IPs, localhost, etc.)
+    if validate_url:
+        url = validate_media_url(
+            url,
+            block_private_ips=True,
+            platform="file_handlers",
+        )
+
     # Create temp file if no destination specified
     if destination is None:
         temp_fd, destination = tempfile.mkstemp()
@@ -131,8 +235,9 @@ async def download_to_memory(
     *,
     max_size: int | None = None,
     timeout: float = 60.0,
+    validate_url: bool = True,
 ) -> bytes:
-    """Download a file into memory.
+    """Download a file into memory with SSRF protection.
 
     Useful for small files that need to be processed immediately.
 
@@ -140,11 +245,14 @@ async def download_to_memory(
         url: URL to download from.
         max_size: Maximum allowed file size in bytes (raises ValueError if exceeded).
         timeout: Request timeout in seconds (default: 1 minute).
+        validate_url: If True (default), validate URL for SSRF protection.
+            Blocks private IPs, localhost, and other internal addresses.
 
     Returns:
         File content as bytes.
 
     Raises:
+        ValidationError: If URL fails security validation.
         httpx.HTTPError: If download fails.
         ValueError: If file exceeds max_size.
 
@@ -154,6 +262,14 @@ async def download_to_memory(
         ...     max_size=1024 * 1024  # 1MB limit
         ... )
     """
+    # Validate URL for SSRF protection (blocks private IPs, localhost, etc.)
+    if validate_url:
+        url = validate_media_url(
+            url,
+            block_private_ips=True,
+            platform="file_handlers",
+        )
+
     async with httpx.AsyncClient(timeout=timeout) as client:
         response = await client.get(url)
         response.raise_for_status()
@@ -242,53 +358,75 @@ async def read_file_bytes(file_path: str) -> bytes:
         return await f.read()
 
 
-async def write_file_bytes(file_path: str, content: bytes) -> None:
-    """Write bytes to file asynchronously.
+async def write_file_bytes(
+    file_path: str,
+    content: bytes,
+    *,
+    allowed_base_dirs: set[str] | None = None,
+) -> None:
+    """Write bytes to file asynchronously with path validation.
 
     Args:
         file_path: Path where file should be written.
         content: Content to write.
+        allowed_base_dirs: Optional set of allowed base directories.
+            If provided, path must be within one of these directories.
 
     Raises:
+        ValidationError: If path is invalid or blocked.
         IOError: If write fails.
 
     Example:
-        >>> await write_file_bytes('/path/to/output.bin', b'some data')
+        >>> await write_file_bytes('/tmp/output.bin', b'some data')
     """
+    # Validate path for security (prevents path traversal)
+    validated_path = _validate_path(file_path, allowed_base_dirs=allowed_base_dirs)
+
     # Ensure parent directory exists
-    parent_dir = Path(file_path).parent
+    parent_dir = Path(validated_path).parent
     parent_dir.mkdir(parents=True, exist_ok=True)
 
-    async with aiofiles.open(file_path, "wb") as f:
+    async with aiofiles.open(validated_path, "wb") as f:
         await f.write(content)
 
 
-async def copy_file_async(source: str, destination: str) -> None:
-    """Copy file asynchronously.
+async def copy_file_async(
+    source: str,
+    destination: str,
+    *,
+    allowed_base_dirs: set[str] | None = None,
+) -> None:
+    """Copy file asynchronously with path validation.
 
     Args:
         source: Source file path.
         destination: Destination file path.
+        allowed_base_dirs: Optional set of allowed base directories.
+            If provided, destination must be within one of these directories.
 
     Raises:
         FileNotFoundError: If source doesn't exist.
+        ValidationError: If destination path is invalid or blocked.
         IOError: If copy fails.
 
     Example:
-        >>> await copy_file_async('/path/to/source.txt', '/path/to/dest.txt')
+        >>> await copy_file_async('/path/to/source.txt', '/tmp/dest.txt')
     """
     if not os.path.exists(source):
         raise FileNotFoundError(f"Source file not found: {source}")
 
+    # Validate destination path for security (prevents path traversal)
+    validated_dest = _validate_path(destination, allowed_base_dirs=allowed_base_dirs)
+
     # Ensure destination directory exists
-    dest_dir = Path(destination).parent
+    dest_dir = Path(validated_dest).parent
     dest_dir.mkdir(parents=True, exist_ok=True)
 
     # Read from source and write to destination
     async with aiofiles.open(source, "rb") as src:
         content = await src.read()
 
-    async with aiofiles.open(destination, "wb") as dest:
+    async with aiofiles.open(validated_dest, "wb") as dest:
         await dest.write(content)
 
 

marqetive_lib-0.1.16/src/marqetive/utils/helpers.py

@@ -0,0 +1,50 @@
+"""Helper functions for common API operations."""
+
+import json
+from typing import Any
+from urllib.parse import parse_qs, urlparse
+
+
+def format_response(
+    data: dict[str, Any], *, pretty: bool = False, indent: int = 2
+) -> str:
+    """Format API response data as a string.
+
+    Args:
+        data: The response data dictionary
+        pretty: Whether to format with indentation (default: False)
+        indent: Number of spaces for indentation if pretty=True (default: 2)
+
+    Returns:
+        Formatted string representation of the response
+
+    Example:
+        >>> data = {"user": "john", "status": "active"}
+        >>> print(format_response(data, pretty=True))
+        {
+          "user": "john",
+          "status": "active"
+        }
+    """
+    if pretty:
+        return json.dumps(data, indent=indent, sort_keys=True)
+    return json.dumps(data)
+
+
+def parse_query_params(url: str) -> dict[str, Any]:
+    """Parse query parameters from a URL.
+
+    Args:
+        url: The URL string to parse
+
+    Returns:
+        Dictionary of query parameters
+
+    Example:
+        >>> url = "https://api.example.com/users?page=1&limit=10"
+        >>> params = parse_query_params(url)
+        >>> print(params)
+        {'page': ['1'], 'limit': ['10']}
+    """
+    parsed = urlparse(url)
+    return dict(parse_qs(parsed.query))

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/src/marqetive/utils/media.py

@@ -17,6 +17,8 @@ from pathlib import Path
 from typing import Literal
 from urllib.parse import urlparse
 
+import aiofiles
+
 from marqetive.core.exceptions import ValidationError
 
 # Initialize mimetypes database
@@ -314,8 +316,6 @@ async def chunk_file(
         >>> async for chunk in chunk_file('large_video.mp4', chunk_size=5*1024*1024):
         ...     await upload_chunk(chunk)
     """
-    import aiofiles
-
     if not os.path.exists(file_path):
         raise FileNotFoundError(f"File not found: {file_path}")
 

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/src/marqetive/utils/oauth.py

@@ -4,6 +4,7 @@ This module provides utilities for refreshing OAuth2 access tokens across
 different social media platforms.
 """
 
+import base64
 import logging
 import re
 from datetime import datetime, timedelta
@@ -147,8 +148,6 @@ async def refresh_twitter_token(
         ...     os.getenv("TWITTER_CLIENT_SECRET")
         ... )
     """
-    import base64
-
     if not credentials.refresh_token:
         raise PlatformAuthError(
             "No refresh token available",

{marqetive_lib-0.1.14 → marqetive_lib-0.1.16}/src/marqetive/utils/retry.py

@@ -7,6 +7,7 @@ with exponential backoff for async functions.
 import asyncio
 import functools
 import logging
+import random
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from typing import Any, TypeVar
@@ -51,8 +52,6 @@ class BackoffConfig:
         Returns:
             Delay in seconds.
         """
-        import random
-
         delay = min(
             self.base_delay * (self.exponential_base**attempt),
             self.max_delay,

marqetive_lib-0.1.14/src/marqetive/utils/helpers.py

@@ -1,99 +0,0 @@
-"""Helper functions for common API operations."""
-
-from typing import Any
-from urllib.parse import parse_qs, urlencode, urlparse
-
-
-def format_response(
-    data: dict[str, Any], *, pretty: bool = False, indent: int = 2
-) -> str:
-    """Format API response data as a string.
-
-    Args:
-        data: The response data dictionary
-        pretty: Whether to format with indentation (default: False)
-        indent: Number of spaces for indentation if pretty=True (default: 2)
-
-    Returns:
-        Formatted string representation of the response
-
-    Example:
-        >>> data = {"user": "john", "status": "active"}
-        >>> print(format_response(data, pretty=True))
-        {
-          "user": "john",
-          "status": "active"
-        }
-    """
-    import json
-
-    if pretty:
-        return json.dumps(data, indent=indent, sort_keys=True)
-    return json.dumps(data)
-
-
-def parse_query_params(url: str) -> dict[str, Any]:
-    """Parse query parameters from a URL.
-
-    Args:
-        url: The URL string to parse
-
-    Returns:
-        Dictionary of query parameters
-
-    Example:
-        >>> url = "https://api.example.com/users?page=1&limit=10"
-        >>> params = parse_query_params(url)
-        >>> print(params)
-        {'page': ['1'], 'limit': ['10']}
-    """
-    parsed = urlparse(url)
-    return dict(parse_qs(parsed.query))
-
-
-def build_query_string(params: dict[str, Any]) -> str:
-    """Build a query string from a dictionary of parameters.
-
-    Args:
-        params: Dictionary of query parameters
-
-    Returns:
-        URL-encoded query string
-
-    Example:
-        >>> params = {"page": 1, "limit": 10, "sort": "name"}
-        >>> query = build_query_string(params)
-        >>> print(query)
-        page=1&limit=10&sort=name
-    """
-    return urlencode(params)
-
-
-def merge_headers(
-    default_headers: dict[str, str] | None = None,
-    custom_headers: dict[str, str] | None = None,
-) -> dict[str, str]:
-    """Merge default and custom headers.
-
-    Custom headers take precedence over default headers.
-
-    Args:
-        default_headers: Default headers dictionary
-        custom_headers: Custom headers to merge
-
-    Returns:
-        Merged headers dictionary
-
-    Example:
-        >>> defaults = {"Content-Type": "application/json"}
-        >>> custom = {"Authorization": "Bearer token"}
-        >>> headers = merge_headers(defaults, custom)
-        >>> print(headers)
-        {'Content-Type': 'application/json', 'Authorization': 'Bearer token'}
-    """
-    result = {}
-    if default_headers:
-        result.update(default_headers)
-    if custom_headers:
-        result.update(custom_headers)
-    return result

marqetive_lib-0.1.14/src/marqetive/utils/token_validator.py

@@ -1,240 +0,0 @@
-"""Token validation utilities for checking credential validity.
-
-This module provides utilities for validating OAuth tokens and determining
-if they need to be refreshed.
-"""
-
-import re
-from datetime import datetime, timedelta
-from typing import Any
-
-from marqetive.core.models import AuthCredentials
-
-
-def is_token_expired(
-    expires_at: datetime | None,
-    threshold_minutes: int = 5,
-) -> bool:
-    """Check if a token has expired or will expire soon.
-
-    Args:
-        expires_at: Token expiration timestamp.
-        threshold_minutes: Consider expired if expires within this many minutes.
-
-    Returns:
-        True if token is expired or will expire soon, False otherwise.
-
-    Example:
-        >>> from datetime import datetime, timedelta
-        >>> expires = datetime.now() + timedelta(minutes=3)
-        >>> is_token_expired(expires, threshold_minutes=5)
-        True
-        >>> expires = datetime.now() + timedelta(hours=1)
-        >>> is_token_expired(expires, threshold_minutes=5)
-        False
-    """
-    if expires_at is None:
-        # No expiry means token doesn't expire
-        return False
-
-    threshold = datetime.now() + timedelta(minutes=threshold_minutes)
-    return expires_at <= threshold
-
-
-def needs_refresh(
-    credentials: AuthCredentials,
-    threshold_minutes: int = 5,  # noqa: ARG001
-) -> bool:
-    """Check if credentials need to be refreshed.
-
-    Args:
-        credentials: Credentials to check.
-        threshold_minutes: Expiry threshold in minutes.
-
-    Returns:
-        True if refresh is needed, False otherwise.
-
-    Example:
-        >>> creds = AuthCredentials(
-        ...     platform="twitter",
-        ...     access_token="token",
-        ...     expires_at=datetime.now() + timedelta(minutes=2)
-        ... )
-        >>> needs_refresh(creds)
-        True
-    """
-    return credentials.needs_refresh()
-
-
-def validate_token_format(token: str, min_length: int = 10) -> bool:
-    """Validate basic token format.
-
-    Checks if token looks valid (not empty, meets minimum length).
-
-    Args:
-        token: Token string to validate.
-        min_length: Minimum acceptable token length.
-
-    Returns:
-        True if token format is valid, False otherwise.
-
-    Example:
-        >>> validate_token_format("abc123xyz")
-        False
-        >>> validate_token_format("a" * 50)
-        True
-    """
-    if not token or not isinstance(token, str):
-        return False
-
-    # Remove whitespace
-    token = token.strip()
-
-    # Check minimum length
-    if len(token) < min_length:
-        return False
-
-    # Check for obviously invalid tokens
-    return token.lower() not in ["none", "null", "undefined", ""]
-
-
-def validate_bearer_token(token: str) -> bool:
-    """Validate Bearer token format.
-
-    Args:
-        token: Bearer token to validate.
-
-    Returns:
-        True if token appears valid, False otherwise.
-
-    Example:
-        >>> validate_bearer_token("ya29.a0AfH6SMB...")
-        True
-        >>> validate_bearer_token("invalid")
-        False
-    """
-    # Bearer tokens are typically base64-like strings
-    if not validate_token_format(token, min_length=20):
-        return False
-
-    # Check for suspicious patterns
-    return not re.search(r"[<>\"']", token)
-
-
-def calculate_token_ttl(expires_at: datetime | None) -> timedelta | None:
-    """Calculate time-to-live for a token.
-
-    Args:
-        expires_at: Token expiration timestamp.
-
-    Returns:
-        Time remaining until expiration, or None if no expiry.
-
-    Example:
-        >>> from datetime import datetime, timedelta
-        >>> expires = datetime.now() + timedelta(hours=1)
-        >>> ttl = calculate_token_ttl(expires)
-        >>> ttl.total_seconds() > 3500  # Approximately 1 hour
-        True
-    """
-    if expires_at is None:
-        return None
-
-    now = datetime.now()
-    if expires_at <= now:
-        return timedelta(0)
-
-    return expires_at - now
-
-
-def should_proactively_refresh(
-    credentials: AuthCredentials,
-    refresh_threshold_minutes: int = 5,
-) -> bool:
-    """Determine if token should be proactively refreshed.
-
-    Checks if token will expire soon and if refresh token is available.
-
-    Args:
-        credentials: Credentials to check.
-        refresh_threshold_minutes: Refresh if expires within this many minutes.
-
-    Returns:
-        True if should proactively refresh, False otherwise.
-
-    Example:
-        >>> creds = AuthCredentials(
-        ...     platform="twitter",
-        ...     access_token="token",
-        ...     refresh_token="refresh",
-        ...     expires_at=datetime.now() + timedelta(minutes=3)
-        ... )
-        >>> should_proactively_refresh(creds)
-        True
-    """
-    # Need refresh token to refresh
-    if not credentials.refresh_token:
-        return False
-
-    # Check if expiring soon
-    return is_token_expired(credentials.expires_at, refresh_threshold_minutes)
-
-
-def is_credentials_complete(credentials: AuthCredentials) -> bool:
-    """Check if credentials have all required fields.
-
-    Args:
-        credentials: Credentials to validate.
-
-    Returns:
-        True if credentials are complete, False otherwise.
-
-    Example:
-        >>> creds = AuthCredentials(
-        ...     platform="twitter",
-        ...     access_token="token"
-        ... )
-        >>> is_credentials_complete(creds)
-        True
-    """
-    # Must have platform and access token
-    if not credentials.platform or not credentials.access_token:
-        return False
-
-    # Access token must be valid format
-    return validate_token_format(credentials.access_token)
-
-
-def get_token_health_status(credentials: AuthCredentials) -> dict[str, Any]:
-    """Get comprehensive health status of credentials.
-
-    Args:
-        credentials: Credentials to analyze.
-
-    Returns:
-        Dictionary with health information.
-
-    Example:
-        >>> creds = AuthCredentials(
-        ...     platform="twitter",
-        ...     access_token="token",
-        ...     expires_at=datetime.now() + timedelta(hours=1)
-        ... )
-        >>> status = get_token_health_status(creds)
-        >>> status["is_valid"]
-        True
-        >>> status["needs_refresh"]
-        False
-    """
-    ttl = calculate_token_ttl(credentials.expires_at)
-
-    return {
-        "is_valid": credentials.is_valid(),
-        "is_expired": credentials.is_expired(),
-        "needs_refresh": credentials.needs_refresh(),
-        "has_refresh_token": credentials.refresh_token is not None,
-        "time_to_expiry_seconds": ttl.total_seconds() if ttl else None,
-        "should_proactively_refresh": should_proactively_refresh(credentials),
-        "status": credentials.status.value,
-        "is_complete": is_credentials_complete(credentials),
-    }