pararamio-aio 2.1.1__py3-none-any.whl

pararamio_aio/constants/__init__.py

@@ -0,0 +1,16 @@
+"""Constants for pararamio_aio package."""
+
+# Import all constants from core
+from pararamio_aio._core.constants import (
+    BASE_API_URL,
+    POSTS_LIMIT,
+    REQUEST_TIMEOUT,
+    XSRF_HEADER_NAME,
+)
+
+__all__ = [
+    "BASE_API_URL",
+    "POSTS_LIMIT",
+    "REQUEST_TIMEOUT",
+    "XSRF_HEADER_NAME",
+]

pararamio_aio/cookie_manager.py

@@ -0,0 +1,15 @@
+"""Cookie managers for asynchronous Pararamio client."""
+
+from pararamio_aio._core.cookie_manager import (
+    AsyncCookieManager,
+    AsyncFileCookieManager,
+    AsyncInMemoryCookieManager,
+    AsyncRedisCookieManager,
+)
+
+__all__ = [
+    "AsyncCookieManager",
+    "AsyncFileCookieManager",
+    "AsyncInMemoryCookieManager",
+    "AsyncRedisCookieManager",
+]

pararamio_aio/exceptions/__init__.py

@@ -0,0 +1,31 @@
+"""Exceptions for pararamio_aio package."""
+
+from pararamio_aio._core.exceptions import (
+    PararamioAuthenticationException,
+    PararamioCaptchaAuthenticationException,
+    PararamioException,
+    PararamioHTTPRequestException,
+    PararamioPasswordAuthenticationException,
+    PararamioRequestException,
+    PararamioSecondFactorAuthenticationException,
+    PararamioValidationException,
+    PararamioXSFRRequestError,
+    PararamModelNotLoaded,
+    PararamNoNextPost,
+    PararamNoPrevPost,
+)
+
+__all__ = [
+    "PararamioException",
+    "PararamioAuthenticationException",
+    "PararamioCaptchaAuthenticationException",
+    "PararamioPasswordAuthenticationException",
+    "PararamioSecondFactorAuthenticationException",
+    "PararamioXSFRRequestError",
+    "PararamioHTTPRequestException",
+    "PararamioRequestException",
+    "PararamioValidationException",
+    "PararamModelNotLoaded",
+    "PararamNoPrevPost",
+    "PararamNoNextPost",
+]

pararamio_aio/exceptions/base.py

@@ -0,0 +1 @@
+"""Base exceptions for pararamio_aio package."""

pararamio_aio/file_operations.py

@@ -0,0 +1,232 @@
+"""Async file operations for Pararamio client."""
+
+from __future__ import annotations
+
+import mimetypes
+import os
+from io import BytesIO
+from typing import TYPE_CHECKING, BinaryIO
+from urllib.parse import quote
+
+import aiohttp
+from pararamio_aio._core import (
+    REQUEST_TIMEOUT,
+    UPLOAD_TIMEOUT,
+    PararamioHTTPRequestException,
+)
+
+# File upload base URL
+FILE_UPLOAD_URL = "https://file.pararam.io"
+
+if TYPE_CHECKING:
+    pass
+
+__all__ = (
+    "async_xupload_file",
+    "async_delete_file",
+    "async_download_file",
+)
+
+
+async def multipart_encode_async(
+    fd: BinaryIO | BytesIO,
+    *,
+    fields: list[tuple[str, str | None | int]] | None = None,
+    boundary: str | None = None,
+    form_field_name: str = "data",
+    filename: str | None = None,
+    content_type: str | None = None,
+) -> bytes:
+    """
+    Async version of multipart encoding for file uploads.
+
+    Args:
+        fd: A file-like object opened in binary mode that is to be included in the payload.
+        fields: An optional list of tuples representing additional form fields.
+        boundary: An optional string used to separate parts of the multipart message.
+        form_field_name: The name of the form field for the file being uploaded.
+        filename: An optional string representing the filename for the file being uploaded.
+        content_type: An optional string representing the content type of the file.
+
+    Returns:
+        A bytes object representing the encoded multipart/form-data payload.
+    """
+    if fields is None:
+        fields = []
+    if boundary is None:
+        boundary = "FORM-BOUNDARY"
+
+    body = BytesIO()
+
+    # Write fields
+    if fields:
+        for key, value in fields:
+            if value is None:
+                continue
+            body.write(f"--{boundary}\r\n".encode())
+            body.write(f'Content-Disposition: form-data; name="{key}"'.encode())
+            body.write(f"\r\n\r\n{value}\r\n".encode())
+
+    # Get filename if not provided
+    if not filename and hasattr(fd, "name"):
+        filename = os.path.basename(fd.name)
+
+    if not content_type and filename:
+        content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream"
+
+    # Write file data
+    fd.seek(0)
+    body.write(f"--{boundary}\r\n".encode())
+    body.write(
+        f'Content-Disposition: form-data; name="{form_field_name}"; '
+        f'filename="{filename}"\r\n'.encode()
+    )
+    body.write(f"Content-Type: {content_type}\r\n\r\n".encode())
+    body.write(fd.read())
+    body.write(f"\r\n--{boundary}--\r\n\r\n".encode())
+
+    return body.getvalue()
+
+
+async def async_xupload_file(
+    session: aiohttp.ClientSession,
+    fp: BinaryIO | BytesIO,
+    fields: list[tuple[str, str | None | int]],
+    *,
+    filename: str | None = None,
+    content_type: str | None = None,
+    headers: dict[str, str] | None = None,
+    timeout: int = UPLOAD_TIMEOUT,
+) -> dict:
+    """
+    Async version of xupload_file for uploading files to Pararamio.
+
+    Args:
+        session: aiohttp client session
+        fp: A binary file-like object to upload
+        fields: A list of tuples containing field names and values
+        filename: Optional filename for the upload
+        content_type: Optional MIME type of the file
+        headers: Optional additional headers
+        timeout: Timeout in seconds for the upload
+
+    Returns:
+        Dictionary with upload response data
+    """
+    url = f"{FILE_UPLOAD_URL}/upload"
+    boundary = "FORM-BOUNDARY"
+
+    # Prepare headers
+    _headers = {
+        "User-agent": "pararamio-aio",
+        "Accept": "application/json",
+        "Content-Type": f"multipart/form-data; boundary={boundary}",
+    }
+    if headers:
+        _headers.update(headers)
+
+    # Encode multipart data
+    data = await multipart_encode_async(
+        fp,
+        fields=fields,
+        filename=filename,
+        content_type=content_type,
+        boundary=boundary,
+    )
+
+    # Make request
+    timeout_obj = aiohttp.ClientTimeout(total=timeout)
+    async with session.post(url, data=data, headers=_headers, timeout=timeout_obj) as response:
+        if response.status == 200:
+            return await response.json()
+        raise PararamioHTTPRequestException(
+            url,
+            response.status,
+            f"HTTP {response.status}",
+            dict(response.headers),
+            await response.text(),
+        )
+
+
+async def async_delete_file(
+    session: aiohttp.ClientSession,
+    guid: str,
+    headers: dict[str, str] | None = None,
+    timeout: int = REQUEST_TIMEOUT,
+) -> dict:
+    """
+    Async version of delete_file for deleting files from Pararamio.
+
+    Args:
+        session: aiohttp client session
+        guid: The GUID of the file to delete
+        headers: Optional additional headers
+        timeout: Timeout in seconds for the request
+
+    Returns:
+        Dictionary with deletion response data
+    """
+    url = f"{FILE_UPLOAD_URL}/delete/{guid}"
+
+    _headers = {
+        "User-agent": "pararamio-aio",
+        "Accept": "application/json",
+    }
+    if headers:
+        _headers.update(headers)
+
+    timeout_obj = aiohttp.ClientTimeout(total=timeout)
+    async with session.delete(url, headers=_headers, timeout=timeout_obj) as response:
+        if response.status in (200, 204):
+            if response.status == 204:
+                return {"success": True}
+            return await response.json()
+        raise PararamioHTTPRequestException(
+            url,
+            response.status,
+            f"HTTP {response.status}",
+            dict(response.headers),
+            await response.text(),
+        )
+
+
+async def async_download_file(
+    session: aiohttp.ClientSession,
+    guid: str,
+    filename: str,
+    headers: dict[str, str] | None = None,
+    timeout: int = REQUEST_TIMEOUT,
+) -> BytesIO:
+    """
+    Async version of download_file for downloading files from Pararamio.
+
+    Args:
+        session: aiohttp client session
+        guid: The GUID of the file to download
+        filename: The filename for the download
+        headers: Optional additional headers
+        timeout: Timeout in seconds for the request
+
+    Returns:
+        BytesIO object containing the downloaded file content
+    """
+    url = f"{FILE_UPLOAD_URL}/download/{guid}/{quote(filename)}"
+
+    _headers = {
+        "User-agent": "pararamio-aio",
+    }
+    if headers:
+        _headers.update(headers)
+
+    timeout_obj = aiohttp.ClientTimeout(total=timeout)
+    async with session.get(url, headers=_headers, timeout=timeout_obj) as response:
+        if response.status == 200:
+            content = await response.read()
+            return BytesIO(content)
+        raise PararamioHTTPRequestException(
+            url,
+            response.status,
+            f"HTTP {response.status}",
+            dict(response.headers),
+            await response.text(),
+        )

pararamio_aio/models/__init__.py

@@ -0,0 +1,32 @@
+"""Async models for Pararamio API."""
+
+from .activity import Activity, ActivityAction
+from .attachment import Attachment
+from .bot import AsyncPararamioBot
+from .chat import Chat
+from .deferred_post import DeferredPost
+from .file import File
+from .group import Group
+from .poll import Poll, PollOption
+from .post import Post
+from .team import Team, TeamMember, TeamMemberStatus
+from .user import User, UserSearchResult
+
+__all__ = (
+    "Chat",
+    "User",
+    "UserSearchResult",
+    "Post",
+    "Group",
+    "File",
+    "Team",
+    "TeamMember",
+    "TeamMemberStatus",
+    "Poll",
+    "PollOption",
+    "AsyncPararamioBot",
+    "DeferredPost",
+    "Activity",
+    "ActivityAction",
+    "Attachment",
+)

pararamio_aio/models/activity.py

@@ -0,0 +1,127 @@
+"""Async Activity model."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, Callable, Coroutine
+
+# Imports from core
+from pararamio_aio._core.utils.helpers import parse_iso_datetime
+
+__all__ = ("ActivityAction", "Activity")
+
+
+class ActivityAction(Enum):
+    """Activity action types."""
+
+    ONLINE = "online"
+    OFFLINE = "offline"
+    AWAY = "away"
+    READ = "thread-read"
+    POST = "thread-post"
+    CALL = "calling"
+    CALL_END = "endcall"
+
+
+class Activity:
+    """User activity record."""
+
+    def __init__(self, action: ActivityAction, time: datetime):
+        """Initialize activity.
+
+        Args:
+            action: Activity action type
+            time: Activity timestamp
+        """
+        self.action = action
+        self.time = time
+
+    @classmethod
+    def from_api_data(cls, data: dict[str, str]) -> Activity:
+        """Create Activity from API response data.
+
+        Args:
+            data: API response data
+
+        Returns:
+            Activity instance
+
+        Raises:
+            ValueError: If time format is invalid
+        """
+        time = parse_iso_datetime(data, "datetime")
+        if time is None:
+            raise ValueError("Invalid time format")
+
+        return cls(
+            action=ActivityAction(data["action"]),
+            time=time,
+        )
+
+    @classmethod
+    async def get_activity(
+        cls,
+        page_loader: Callable[..., Coroutine[Any, Any, dict[str, Any]]],
+        start: datetime,
+        end: datetime,
+        actions: list[ActivityAction] | None = None,
+    ) -> list[Activity]:
+        """Get user activity within date range.
+
+        Args:
+            page_loader: Async function to load activity pages
+            start: Start datetime
+            end: End datetime
+            actions: Optional list of actions to filter
+
+        Returns:
+            List of Activity objects sorted by time
+        """
+        results = []
+        actions_to_check: list[ActivityAction | None] = [None]
+
+        if actions:
+            actions_to_check = actions  # type: ignore[assignment]
+
+        for action in actions_to_check:
+            page = 1
+            is_last_page = False
+
+            while not is_last_page:
+                # Call async page loader
+                response = await page_loader(action, page=page)
+                data = response.get("data", [])
+
+                if not data:
+                    break
+
+                for activity_data in data:
+                    activity = cls.from_api_data(activity_data)
+
+                    if activity.time > end:
+                        continue
+
+                    if activity.time < start:
+                        is_last_page = True
+                        break
+
+                    results.append(activity)
+
+                page += 1
+
+        return sorted(results, key=lambda x: x.time)
+
+    def __str__(self) -> str:
+        """String representation."""
+        return f"Activity({self.time}, {self.action.value})"
+
+    def __repr__(self) -> str:
+        """Detailed representation."""
+        return f"<Activity(action={self.action}, time={self.time})>"
+
+    def __eq__(self, other) -> bool:
+        """Check equality."""
+        if not isinstance(other, Activity):
+            return False
+        return self.action == other.action and self.time == other.time

pararamio_aio/models/attachment.py

@@ -0,0 +1,141 @@
+"""Async Attachment model."""
+
+from __future__ import annotations
+
+import mimetypes
+import os
+from dataclasses import dataclass
+from io import BufferedReader, BytesIO
+from os import PathLike
+from os.path import basename
+from typing import BinaryIO
+
+import aiofiles
+
+__all__ = ("Attachment",)
+
+
+def guess_mime_type(filename: str | PathLike) -> str:
+    """Guess MIME type from filename.
+
+    Args:
+        filename: File name or path
+
+    Returns:
+        MIME type string
+    """
+    if not mimetypes.inited:
+        mimetypes.init(files=os.environ.get("PARARAMIO_MIME_TYPES_PATH", None))
+    return mimetypes.guess_type(str(filename))[0] or "application/octet-stream"
+
+
+@dataclass
+class Attachment:
+    """File attachment representation.
+
+    This is a utility class for handling file attachments before upload.
+    It can handle various file input types and provides helpers for
+    filename and content type detection.
+    """
+
+    file: str | bytes | PathLike | BytesIO | BinaryIO
+    filename: str | None = None
+    content_type: str | None = None
+
+    @property
+    def guess_filename(self) -> str:
+        """Guess filename from file object.
+
+        Returns:
+            Guessed filename or 'unknown'
+        """
+        if self.filename:
+            return self.filename
+
+        if isinstance(self.file, (str, PathLike)):
+            return basename(str(self.file))
+
+        if isinstance(self.file, (BytesIO, BinaryIO, BufferedReader)):
+            try:
+                name = getattr(self.file, "name", None)
+                if name:
+                    return basename(name)
+            except AttributeError:
+                pass
+
+        return "unknown"
+
+    @property
+    def guess_content_type(self) -> str:
+        """Guess content type from file.
+
+        Returns:
+            MIME type string
+        """
+        if self.content_type:
+            return self.content_type
+
+        if isinstance(self.file, (str, PathLike)):
+            return guess_mime_type(self.file)
+
+        if isinstance(self.file, (BinaryIO, BufferedReader)):
+            name = getattr(self.file, "name", None)
+            if name:
+                return guess_mime_type(name)
+
+        return "application/octet-stream"
+
+    async def get_fp(self) -> BytesIO | BinaryIO:
+        """Get file pointer asynchronously.
+
+        This method handles async file reading for path-based files.
+
+        Returns:
+            File-like object (BytesIO or BinaryIO)
+
+        Raises:
+            TypeError: If file type is not supported
+        """
+        if isinstance(self.file, bytes):
+            return BytesIO(self.file)
+
+        if isinstance(self.file, (str, PathLike)):
+            # Read file asynchronously
+            async with aiofiles.open(self.file, "rb") as f:
+                content = await f.read()
+                return BytesIO(content)
+
+        if isinstance(self.file, (BytesIO, BinaryIO, BufferedReader)):
+            return self.file
+
+        raise TypeError(f"Unsupported type {type(self.file)}")
+
+    @property
+    def fp(self) -> BytesIO | BinaryIO:
+        """Get file pointer.
+
+        Note: This is a sync property. For async file reading,
+        use get_fp() method instead.
+
+        Returns:
+            File-like object
+
+        Raises:
+            TypeError: If file type is not supported
+        """
+        if isinstance(self.file, bytes):
+            return BytesIO(self.file)
+
+        if isinstance(self.file, (str, PathLike)):
+            # Sync file read - not recommended in async context
+            with open(self.file, "rb") as f:
+                return BytesIO(f.read())
+
+        if isinstance(self.file, (BytesIO, BinaryIO, BufferedReader)):
+            return self.file
+
+        raise TypeError(f"Unsupported type {type(self.file)}")
+
+    def __str__(self) -> str:
+        """String representation."""
+        return f"Attachment({self.guess_filename})"

pararamio_aio/models/base.py

@@ -0,0 +1,83 @@
+"""Base classes for async models."""
+
+from __future__ import annotations
+
+from abc import ABC
+from datetime import datetime
+from typing import TYPE_CHECKING, Any
+
+# Imports from core
+from pararamio_aio._core.models.base import CoreBaseModel
+from pararamio_aio._core.utils.helpers import parse_iso_datetime
+
+if TYPE_CHECKING:
+    from ..client import AsyncPararamio
+
+__all__ = ("BaseModel",)
+
+
+class BaseModel(CoreBaseModel, ABC):
+    """Base async model class.
+
+    Unlike sync models, async models don't use lazy loading.
+    All data must be explicitly loaded via async methods.
+    """
+
+    def __init__(self, client: AsyncPararamio, **kwargs):
+        """Initialize async model.
+
+        Args:
+            client: AsyncPararamio client instance
+            **kwargs: Model data
+        """
+        super().__init__(**kwargs)
+        self._client = client
+
+    @property
+    def client(self) -> AsyncPararamio:
+        """Get the client instance."""
+        return self._client
+
+    @classmethod
+    def from_dict(cls, client: AsyncPararamio, data: dict[str, Any]) -> BaseModel:
+        """Create model instance from dict data.
+
+        Args:
+            client: AsyncPararamio client instance
+            data: Raw API data
+
+        Returns:
+            Model instance
+        """
+        # Apply any formatting transformations
+        formatted_data = {}
+        for key, value in data.items():
+            if key.endswith("_created") or key.endswith("_updated") or key.endswith("_edited"):
+                if isinstance(value, str):
+                    formatted_data[key] = parse_iso_datetime(data, key)
+                else:
+                    formatted_data[key] = value
+            else:
+                formatted_data[key] = value
+
+        return cls(client, **formatted_data)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert model to dictionary.
+
+        Returns:
+            Model data as dict
+        """
+        result = {}
+        for key, value in self._data.items():
+            if isinstance(value, datetime):
+                result[key] = value.isoformat()
+            else:
+                result[key] = value
+        return result
+
+    def __repr__(self) -> str:
+        """String representation of the model."""
+        model_name = self.__class__.__name__
+        id_value = getattr(self, "id", None)
+        return f"<{model_name}(id={id_value})>"