pararamio-aio 3.0.0__py3-none-any.whl

pararamio_aio/_core/endpoints.py

@@ -0,0 +1,67 @@
+"""API endpoints constants for pararamio."""
+
+__all__ = [
+    'AUTH_ENDPOINTS',
+    'CHAT_ENDPOINTS',
+    'FILE_ENDPOINTS',
+    'POST_ENDPOINTS',
+    'USER_ENDPOINTS',
+]
+
+
+# User-related endpoints
+USER_ENDPOINTS = {
+    'search': '/user/search',
+    'list': '/user/list',
+    'profile': '/user/profile',
+    'activity': '/activity',
+}
+
+# Chat-related endpoints
+CHAT_ENDPOINTS = {
+    'core': '/core/chat',
+    'list': '/core/chat',
+    'create': '/core/chat',
+    'edit': '/core/chat/{chat_id}',
+    'delete': '/core/chat/{chat_id}',
+    'transfer': '/core/chat/{chat_id}/transfer/{org_id}',
+    'hide': '/core/chat/{chat_id}/hide',
+    'show': '/core/chat/{chat_id}/show',
+    'favorite': '/core/chat/{chat_id}/favorite',
+    'unfavorite': '/core/chat/{chat_id}/unfavorite',
+    'enter': '/core/chat/{chat_id}/enter',
+    'quit': '/core/chat/{chat_id}/quit',
+    'custom_title': '/core/chat/{chat_id}/custom_title',
+    'add_users': '/core/chat/{chat_id}/user/{ids}',
+    'delete_users': '/core/chat/{chat_id}/user/{ids}',
+    'add_admins': '/core/chat/{chat_id}/admin/{ids}',
+    'delete_admins': '/core/chat/{chat_id}/admin/{ids}',
+    'add_groups': '/core/chat/{chat_id}/group/{ids}',
+    'delete_groups': '/core/chat/{chat_id}/group/{ids}',
+    'private_message': '/core/chat/pm/{user_id}',
+    'sync': '/core/chat/sync',
+}
+
+# Post-related endpoints
+POST_ENDPOINTS = {
+    'list': '/msg/post',
+    'create': '/msg/post',
+    'edit': '/msg/post/{post_id}',
+    'delete': '/msg/post/{post_id}',
+    'search': '/posts/search',
+    'last_read': '/msg/lastread/{chat_id}',
+}
+
+# Authentication endpoints
+AUTH_ENDPOINTS = {
+    'login': '/auth/login',
+    'logout': '/auth/logout',
+    'second_step': '/auth/second_step',
+    'profile': '/auth/profile',
+}
+
+# File-related endpoints
+FILE_ENDPOINTS = {
+    'upload': '/msg/file',
+    'download': '/msg/file/{file_id}',
+}

pararamio_aio/_core/exceptions/__init__.py

@@ -0,0 +1,6 @@
+"""Exceptions module."""
+
+# Import base exceptions
+# Import auth-specific exceptions
+from .auth import *
+from .base import *

pararamio_aio/_core/exceptions/auth.py

@@ -0,0 +1,91 @@
+"""Authentication-specific exceptions."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .base import PararamioException
+
+__all__ = (
+    'AuthenticationException',
+    'CaptchaRequiredException',
+    'InvalidCredentialsException',
+    'RateLimitException',
+    'SessionExpiredException',
+    'TwoFactorFailedException',
+    'TwoFactorRequiredException',
+    'XSRFTokenException',
+)
+
+
+class AuthenticationException(PararamioException):
+    """Base authentication exception."""
+
+    def __init__(
+        self,
+        message: str,
+        error_code: str | None = None,
+        response_data: dict[str, Any] | None = None,
+    ):
+        super().__init__(message)
+        self.error_code = error_code
+        self.response_data = response_data or {}
+
+
+class InvalidCredentialsException(AuthenticationException):
+    """Invalid login credentials."""
+
+    def __init__(self, message: str = 'Invalid email or password'):
+        super().__init__(message, error_code='invalid_credentials')
+
+
+class XSRFTokenException(AuthenticationException):
+    """XSRF token related errors."""
+
+    def __init__(self, message: str = 'XSRF token validation failed'):
+        super().__init__(message, error_code='xsrf_token_error')
+
+
+class TwoFactorRequiredException(AuthenticationException):
+    """Two-factor authentication is required."""
+
+    def __init__(self, message: str = 'Two-factor authentication required'):
+        super().__init__(message, error_code='2fa_required')
+
+
+class TwoFactorFailedException(AuthenticationException):
+    """Two-factor authentication failed."""
+
+    def __init__(self, message: str = 'Invalid two-factor authentication code'):
+        super().__init__(message, error_code='2fa_failed')
+
+
+class CaptchaRequiredException(AuthenticationException):
+    """Captcha verification required."""
+
+    def __init__(
+        self,
+        message: str = 'Captcha verification required',
+        captcha_url: str | None = None,
+    ):
+        super().__init__(message, error_code='captcha_required')
+        self.captcha_url = captcha_url
+
+
+class RateLimitException(AuthenticationException):
+    """Rate limit exceeded (429 Too Many Requests)."""
+
+    def __init__(
+        self,
+        message: str = 'Rate limit exceeded',
+        retry_after: int | None = None,
+    ):
+        super().__init__(message, error_code='rate_limit')
+        self.retry_after = retry_after
+
+
+class SessionExpiredException(AuthenticationException):
+    """Session has expired."""
+
+    def __init__(self, message: str = 'Session has expired, please authenticate again'):
+        super().__init__(message, error_code='session_expired')

pararamio_aio/_core/exceptions/base.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+__all__ = (
+    'PararamModelNotLoaded',
+    'PararamNoNextPost',
+    'PararamNoPrevPost',
+    'PararamNotFound',
+    'PararamioAuthenticationException',
+    'PararamioCaptchaAuthenticationException',
+    'PararamioException',
+    'PararamioHTTPRequestException',
+    'PararamioLimitExceededException',
+    'PararamioMethodNotAllowed',
+    'PararamioPasswordAuthenticationException',
+    'PararamioRequestException',
+    'PararamioSecondFactorAuthenticationException',
+    'PararamioServerResponseException',
+    'PararamioValidationException',
+    'PararamioXSFRRequestError',
+)
+
+import json
+from json import JSONDecodeError
+from typing import IO
+from urllib.error import HTTPError
+
+
+class PararamioException(Exception):  # noqa: N818
+    pass
+
+
+class PararamioValidationException(PararamioException):
+    pass
+
+
+class PararamModelNotLoaded(PararamioException):
+    """Exception raised when trying to access an attribute that hasn't been loaded yet."""
+
+
+class PararamNotFound(PararamioException):
+    pass
+
+
+class PararamioHTTPRequestException(HTTPError, PararamioException):  # noqa: N818  # pylint: disable=too-many-ancestors
+    _response: bytes | None
+    fp: IO[bytes]
+
+    def __init__(self, url: str, code: int, msg: str, hdrs: list[tuple[str, str]], fp: IO[bytes]):
+        self._response = None
+        self.msg = msg
+        super().__init__(url, code, msg, hdrs, fp)  # type: ignore
+
+    @property
+    def response(self):
+        if not self._response and self.fp is not None:
+            self._response = self.fp.read()
+        return self._response
+
+    @property
+    def message(self) -> str | None:
+        if self.code in [403, 400]:
+            try:
+                resp = json.loads(self.response)
+                return resp.get('error', None) or resp.get('message', None)
+            except JSONDecodeError:
+                pass
+        return None
+
+    def __str__(self):
+        msg = self.message
+        if msg:
+            return msg
+        return str(super(HTTPError, self))
+
+
+class PararamioRequestException(PararamioException):
+    pass
+
+
+class PararamioServerResponseException(PararamioRequestException):
+    response: dict
+
+    def __init__(self, msg: str, response: dict):
+        self.msg = msg
+        self.response = response
+
+    def __str__(self):
+        return f'{self.__class__.__name__}, {self.msg or " has been raised"}'
+
+
+class PararamioLimitExceededException(PararamioRequestException):
+    pass
+
+
+class PararamioMethodNotAllowed(PararamioException):
+    pass
+
+
+class PararamioAuthenticationException(PararamioException):
+    retry_after: int | None = None
+
+
+class PararamioXSFRRequestError(PararamioAuthenticationException):
+    pass
+
+
+class PararamioPasswordAuthenticationException(PararamioAuthenticationException):
+    pass
+
+
+class PararamioSecondFactorAuthenticationException(PararamioAuthenticationException):
+    pass
+
+
+class PararamioCaptchaAuthenticationException(PararamioAuthenticationException):
+    pass
+
+
+class PararamNoNextPost(PararamioException, StopIteration):
+    pass
+
+
+class PararamNoPrevPost(PararamioException, StopIteration):
+    pass

pararamio_aio/_core/models/__init__.py

@@ -0,0 +1,17 @@
+"""Core models for pararamio packages."""
+
+from .base import *
+from .chat import *
+from .post import *
+from .user import *
+
+__all__ = [
+    # Base classes
+    'CoreBaseModel',
+    # Models
+    'CoreChat',
+    'CoreClientObject',
+    'CorePost',
+    'CoreUser',
+    'UserInfoParsedItem',
+]

pararamio_aio/_core/models/base.py

@@ -0,0 +1,66 @@
+"""Simplified base classes for core models without lazy loading."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from pararamio_aio._core._types import FormatterT
+
+__all__ = (
+    'CoreBaseModel',
+    'CoreClientObject',
+)
+
+
+class CoreBaseModel:
+    """Base model class without lazy loading magic."""
+
+    _data: dict[str, Any]
+    _attr_formatters: FormatterT
+
+    def __init__(self, **kwargs: Any) -> None:
+        self._data = kwargs
+        self._attr_formatters = {}
+
+    def __getattribute__(self, key: str) -> Any:
+        # Simple version without lazy loading
+        try:
+            return super().__getattribute__(key)
+        except AttributeError:
+            if key.startswith('_'):
+                raise
+
+            # Get from _data if exists
+            data = super().__getattribute__('_data')
+            if key in data:
+                value = data[key]
+                # Apply formatter if exists
+                formatters = super().__getattribute__('_attr_formatters')
+                if key in formatters:
+                    return formatters[key](data, key)
+                return value
+            raise
+
+    def load_data(self, data: dict[str, Any]) -> None:
+        """Load data into the model."""
+        self._data.update(data)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Get data as dictionary."""
+        return self._data.copy()
+
+
+class CoreClientObject:
+    """Base class for objects that need client reference."""
+
+    _client: Any  # Union[ClientProtocol, AsyncClientProtocol] but without import
+
+    def __init__(self, client: Any, **kwargs: Any) -> None:
+        self._client = client
+        # kwargs are passed to subclasses, not used here
+        _ = kwargs
+
+    @property
+    def client(self) -> Any:
+        return self._client

pararamio_aio/_core/models/chat.py

@@ -0,0 +1,92 @@
+"""Core Chat model without lazy loading."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pararamio_aio._core.utils.helpers import parse_iso_datetime
+
+from .base import CoreBaseModel, CoreClientObject
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+    from pararamio_aio._core._types import FormatterT
+
+__all__ = ('CoreChat',)
+
+
+# Attribute formatters for Chat
+CHAT_ATTR_FORMATTERS: FormatterT = {
+    'time_edited': parse_iso_datetime,
+    'time_updated': parse_iso_datetime,
+    'time_created': parse_iso_datetime,
+    'user_time_edited': parse_iso_datetime,
+}
+
+
+class CoreChat(CoreBaseModel, CoreClientObject):
+    """Core Chat model with common functionality."""
+
+    # Chat attributes (copied from original)
+    id: int
+    title: str
+    history_mode: str
+    description: str | None
+    posts_count: int
+    pm: bool
+    e2e: bool
+    time_created: datetime
+    time_updated: datetime
+    time_edited: datetime | None
+    author_id: int
+    two_step_required: bool
+    org_visible: bool
+    organization_id: int | None
+    posts_live_time: int | None
+    allow_api: bool
+    read_only: bool
+    tnew: bool
+    adm_flag: bool
+    custom_title: str | None
+    is_favorite: bool
+    inviter_id: int | None
+    tshow: bool
+    user_time_edited: datetime
+    history_start: int
+    pinned: list[int]
+    thread_groups: list[int]
+    thread_users: list[int]
+    thread_admins: list[int]
+    thread_users_all: list[int]
+    last_msg_author_id: int | None
+    last_msg_author: str
+    last_msg_bot_name: str
+    last_msg_text: str
+    last_msg: str
+    last_read_post_no: int
+    thread_guests: list[int]
+
+    def __init__(self, client: Any, chat_id: int | None = None, **kwargs: Any) -> None:
+        # ID processing (as in original)
+        if chat_id is None:
+            chat_id = kwargs.get('chat_id')
+            if chat_id is None:
+                chat_id = kwargs['thread_id']
+
+        self.id = int(chat_id)
+        self._attr_formatters = CHAT_ATTR_FORMATTERS
+
+        # Call parent constructors
+        CoreBaseModel.__init__(self, id=self.id, **kwargs)
+        CoreClientObject.__init__(self, client)
+
+    def __str__(self) -> str:
+        title = self._data.get('title', '')
+        id_ = self.id or ''
+        return f'{id_} - {title}'
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CoreChat):
+            return id(other) == id(self)
+        return self.id == other.id

pararamio_aio/_core/models/post.py

@@ -0,0 +1,65 @@
+"""Core Post model without lazy loading."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pararamio_aio._core.utils.helpers import parse_iso_datetime
+
+from .base import CoreBaseModel
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+    from pararamio_aio._core._types import FormatterT, PostMetaT, TextParsedT
+
+__all__ = ('CorePost',)
+
+
+# Attribute formatters for Post
+POST_ATTR_FORMATTERS: FormatterT = {
+    'post_no': lambda data, key: int(data[key]),
+    'time_edited': parse_iso_datetime,
+    'time_created': parse_iso_datetime,
+}
+
+
+class CorePost(CoreBaseModel):
+    """Core Post model with common functionality."""
+
+    # Post attributes (copied from original)
+    _chat: Any  # Reference to chat object
+    chat_id: int
+    event: dict[str, Any] | None
+    id: int | None
+    is_deleted: bool
+    meta: PostMetaT
+    post_no: int
+    reply_no: int | None
+    text: str
+    text_parsed: list[TextParsedT]
+    time_created: datetime
+    time_edited: datetime | None
+    user_id: int
+    uuid: str | None
+    ver: int | None
+
+    def __init__(self, chat: Any, **kwargs: Any) -> None:
+        self._chat = chat
+        self._attr_formatters = POST_ATTR_FORMATTERS
+
+        # Call parent constructor
+        CoreBaseModel.__init__(self, **kwargs)
+
+    @property
+    def chat(self) -> Any:
+        """Get chat object."""
+        return self._chat
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CorePost):
+            return id(other) == id(self)
+        return self.chat_id == other.chat_id and self.post_no == other.post_no
+
+    def __str__(self) -> str:
+        return f'Post {self.post_no} in Chat {self.chat_id}'

pararamio_aio/_core/models/user.py

@@ -0,0 +1,54 @@
+"""Core User model without lazy loading."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .base import CoreBaseModel, CoreClientObject
+
+__all__ = ('CoreUser', 'UserInfoParsedItem')
+
+
+# Types for User
+class UserInfoParsedItem(dict[str, Any]):
+    """Parsed user info item."""
+
+    type: str
+    value: str
+
+
+class CoreUser(CoreBaseModel, CoreClientObject):
+    """Core User model with common functionality."""
+
+    # User attributes (copied from original)
+    id: int
+    name: str
+    name_trans: str
+    info: str
+    unique_name: str
+    deleted: bool
+    active: bool
+    time_updated: str
+    time_created: str
+    is_bot: bool
+    alias: None | None
+    timezone_offset_minutes: int
+    owner_id: None | None
+    organizations: list[int]
+    info_parsed: list[UserInfoParsedItem]
+
+    def __init__(self, client: Any, user_id: int, **kwargs: Any) -> None:
+        self.id = user_id
+        self._attr_formatters = {}  # User has no special formatters
+
+        # Call parent constructors
+        CoreBaseModel.__init__(self, id=user_id, **kwargs)
+        CoreClientObject.__init__(self, client)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CoreUser):
+            return id(other) == id(self)
+        return self.id == other.id
+
+    def __str__(self) -> str:
+        return self._data.get('name', '')

pararamio_aio/_core/py.typed

@@ -0,0 +1,2 @@
+# This file indicates that this package supports type hints
+# See PEP 561 for more details

pararamio_aio/_core/utils/__init__.py

@@ -0,0 +1,73 @@
+from .auth_flow import AuthenticationFlow, AuthenticationResult, generate_otp
+from .authentication import authenticate, do_second_step, do_second_step_with_code, get_xsrf_token
+from .captcha import get_captcha_img, verify_captcha
+from .helpers import (
+    check_login_opts,
+    encode_chat_id,
+    encode_digit,
+    format_datetime,
+    format_or_none,
+    get_empty_vars,
+    get_formatted_attr_or_load,
+    get_utc,
+    join_ids,
+    lazy_loader,
+    parse_datetime,
+    parse_iso_datetime,
+    unescape_dict,
+)
+from .http_client import (
+    HTTPClientConfig,
+    RateLimitHandler,
+    RequestResult,
+    build_url,
+    prepare_headers,
+    should_retry_request,
+)
+from .requests import (
+    api_request,
+    bot_request,
+    delete_file,
+    download_file,
+    raw_api_request,
+    upload_file,
+    xupload_file,
+)
+
+__all__ = (
+    'AuthenticationFlow',
+    'AuthenticationResult',
+    'HTTPClientConfig',
+    'RateLimitHandler',
+    'RequestResult',
+    'api_request',
+    'authenticate',
+    'bot_request',
+    'build_url',
+    'check_login_opts',
+    'delete_file',
+    'do_second_step',
+    'do_second_step_with_code',
+    'download_file',
+    'encode_chat_id',
+    'encode_digit',
+    'format_datetime',
+    'format_or_none',
+    'generate_otp',
+    'get_captcha_img',
+    'get_empty_vars',
+    'get_formatted_attr_or_load',
+    'get_utc',
+    'get_xsrf_token',
+    'join_ids',
+    'lazy_loader',
+    'parse_datetime',
+    'parse_iso_datetime',
+    'prepare_headers',
+    'raw_api_request',
+    'should_retry_request',
+    'unescape_dict',
+    'upload_file',
+    'verify_captcha',
+    'xupload_file',
+)