maxapi-python 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

pymax/filters.py

@@ -0,0 +1,38 @@
+from .static import MessageStatus, MessageType
+from .types import Message
+
+
+class Filter:
+    def __init__(
+        self,
+        user_id: int | None = None,
+        text: list[str] | None = None,
+        status: MessageStatus | str | None = None,
+        type: MessageType | str | None = None,
+        text_contains: str | None = None,
+        reaction_info: bool | None = None,
+    ) -> None:
+        self.user_id = user_id
+        self.text = text
+        self.status = status
+        self.type = type
+        self.reaction_info = reaction_info
+        self.text_contains = text_contains
+
+    def match(self, message: Message) -> bool:
+        if self.user_id is not None and message.sender != self.user_id:
+            return False
+        if self.text is not None and any(
+            text not in message.text for text in self.text
+        ):
+            return False
+        if self.text_contains is not None and self.text_contains not in message.text:
+            return False
+        if self.status is not None and message.status != self.status:
+            return False
+        if self.type is not None and message.type != self.type:
+            return False
+        if self.reaction_info is not None and message.reactionInfo is None:  # noqa: SIM103
+            return False
+
+        return True

pymax/interfaces.py

@@ -0,0 +1,67 @@
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Callable
+from logging import Logger
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import websockets
+
+from .filters import Filter
+from .static import Constants
+from .types import Channel, Chat, Dialog, Me, Message, User
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+    from .crud import Database
+
+
+class ClientProtocol(ABC):
+    def __init__(self, logger: Logger) -> None:
+        super().__init__()
+        self.logger = logger
+        self._users: dict[int, User] = {}
+        self.chats: list[Chat] = []
+        self.phone: str = ""
+        self._database: Database
+        self._device_id: UUID
+        self._on_message_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self.uri: str
+        self.is_connected: bool = False
+        self.phone: str
+        self.chats: list[Chat] = []
+        self.dialogs: list[Dialog] = []
+        self.channels: list[Channel] = []
+        self.me: Me | None = None
+        self._users: dict[int, User] = {}
+        self._work_dir: str
+        self._database_path: Path
+        self._ws: websockets.ClientConnection | None = None
+        self._seq: int = 0
+        self._pending: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._recv_task: asyncio.Task[Any] | None = None
+        self._incoming: asyncio.Queue[dict[str, Any]] | None = None
+        self.user_agent = Constants.DEFAULT_USER_AGENT.value
+        self._on_message_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
+        self._background_tasks: set[asyncio.Task[Any]] = set()
+
+    @abstractmethod
+    async def _send_and_wait(
+        self,
+        opcode: int,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = Constants.DEFAULT_TIMEOUT.value,
+    ) -> dict[str, Any]:
+        pass
+
+    @abstractmethod
+    async def _get_chat(self, chat_id: int) -> Chat | None:
+        pass

pymax/mixins/__init__.py

@@ -0,0 +1,18 @@
+from .auth import AuthMixin
+from .channel import ChannelMixin
+from .handler import HandlerMixin
+from .message import MessageMixin
+from .self import SelfMixin
+from .user import UserMixin
+from .websocket import WebSocketMixin
+
+
+class ApiMixin(
+    AuthMixin,
+    HandlerMixin,
+    UserMixin,
+    ChannelMixin,
+    SelfMixin,
+    MessageMixin,
+):
+    pass

pymax/mixins/auth.py

@@ -0,0 +1,81 @@
+import asyncio
+import re
+from typing import Any
+
+from pymax.interfaces import ClientProtocol
+from pymax.payloads import RequestCodePayload, SendCodePayload
+from pymax.static import AuthType, Constants, Opcode
+
+
+class AuthMixin(ClientProtocol):
+    def _check_phone(self) -> bool:
+        return bool(re.match(Constants.PHONE_REGEX.value, self.phone))
+
+    async def _request_code(
+        self, phone: str, language: str = "ru"
+    ) -> dict[str, int | str]:
+        try:
+            self.logger.info("Requesting auth code")
+
+            payload = RequestCodePayload(
+                phone=phone, type=AuthType.START_AUTH, language=language
+            ).model_dump(by_alias=True)
+
+            data = await self._send_and_wait(
+                opcode=Opcode.AUTH_REQUEST, payload=payload
+            )
+            self.logger.debug(
+                "Code request response opcode=%s seq=%s",
+                data.get("opcode"),
+                data.get("seq"),
+            )
+            return data.get("payload")
+        except Exception:
+            self.logger.error("Request code failed", exc_info=True)
+            raise RuntimeError("Request code failed")
+
+    async def _send_code(self, code: str, token: str) -> dict[str, Any]:
+        try:
+            self.logger.info("Sending verification code")
+
+            payload = SendCodePayload(
+                token=token,
+                verify_code=code,
+                auth_token_type=AuthType.CHECK_CODE,
+            ).model_dump(by_alias=True)
+
+            data = await self._send_and_wait(opcode=Opcode.AUTH, payload=payload)
+            self.logger.debug(
+                "Send code response opcode=%s seq=%s",
+                data.get("opcode"),
+                data.get("seq"),
+            )
+            return data.get("payload")
+        except Exception:
+            self.logger.error("Send code failed", exc_info=True)
+            raise RuntimeError("Send code failed")
+
+    async def _login(self) -> None:
+        self.logger.info("Starting login flow")
+        request_code_payload = await self._request_code(self.phone)
+        temp_token = request_code_payload.get("token")
+        if not temp_token or not isinstance(temp_token, str):
+            self.logger.critical("Failed to request code: token missing")
+            raise ValueError("Failed to request code")
+
+        code = await asyncio.to_thread(input, "Введите код: ")
+        if len(code) != 6 or not code.isdigit():
+            self.logger.error("Invalid code format entered")
+            raise ValueError("Invalid code format")
+
+        login_resp = await self._send_code(code, temp_token)
+        token: str | None = (
+            login_resp.get("tokenAttrs", {}).get("LOGIN", {}).get("token")
+        )
+        if not token:
+            self.logger.critical("Failed to login, token not received")
+            raise ValueError("Failed to login, token not received")
+
+        self._token = token
+        self._database.update_auth_token(self._device_id, self._token)
+        self.logger.info("Login successful, token saved to database")

pymax/mixins/channel.py

@@ -0,0 +1,25 @@
+from pymax.interfaces import ClientProtocol
+from pymax.payloads import ResolveLinkPayload
+from pymax.static import Opcode
+
+
+class ChannelMixin(ClientProtocol):
+    async def resolve_channel_by_name(self, name: str) -> bool:
+        """
+        Пытается найти канал по его имени
+
+        Args:
+            name (str): Имя канала
+
+        Returns:
+            bool: True, если канал найден
+        """
+        payload = ResolveLinkPayload(
+            link=f"https://max.ru/{name}",
+        ).model_dump(by_alias=True)
+
+        data = await self._send_and_wait(opcode=Opcode.LINK_INFO, payload=payload)
+        if error := data.get("payload", {}).get("error"):
+            self.logger.error("Resolve link error: %s", error)
+            return False
+        return True

pymax/mixins/group.py

@@ -0,0 +1,220 @@
+import time
+
+from pymax.interfaces import ClientProtocol
+from pymax.payloads import (
+    ChangeGroupProfilePayload,
+    ChangeGroupSettingsOptions,
+    ChangeGroupSettingsPayload,
+    CreateGroupAttach,
+    CreateGroupMessage,
+    CreateGroupPayload,
+    InviteUsersPayload,
+    RemoveUsersPayload,
+)
+from pymax.static import Opcode
+from pymax.types import Chat, Message
+
+
+class GroupMixin(ClientProtocol):
+    async def create_group(
+        self, name: str, participant_ids: list[int] | None = None, notify: bool = True
+    ) -> tuple[Chat, Message] | None:
+        """
+        Создает группу
+
+        Args:
+            name (str): Название группы.
+            participant_ids (list[int] | None, optional): Список идентификаторов участников. Defaults to None.
+            notify (bool, optional): Флаг оповещения. Defaults to True.
+
+        Returns:
+            tuple[Chat, Message] | None: Объект Chat и Message или None при ошибке.
+        """
+        try:
+            payload = CreateGroupPayload(
+                message=CreateGroupMessage(
+                    cid=int(time.time() * 1000),
+                    attaches=[
+                        CreateGroupAttach(
+                            _type="CONTROL",
+                            title=name,
+                            user_ids=participant_ids if participant_ids else [],
+                        )
+                    ],
+                ),
+                notify=notify,
+            ).model_dump(by_alias=True)
+
+            data = await self._send_and_wait(opcode=Opcode.MSG_SEND, payload=payload)
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Create group error: %s", error)
+                return None
+
+            chat = Chat.from_dict(data["payload"]["chat"])
+            message = Message.from_dict(data["payload"]["message"])
+
+            if chat:
+                cached_chat = await self._get_chat(chat.id)
+                if cached_chat is None:
+                    self.chats.append(chat)
+                else:
+                    idx = self.chats.index(cached_chat)
+                    self.chats[idx] = chat
+
+            return chat, message
+
+        except Exception:
+            self.logger.exception("Create group failed")
+
+    async def invite_users_to_group(
+        self,
+        chat_id: int,
+        user_ids: list[int],
+        show_history: bool = True,
+    ) -> bool:
+        """
+        Приглашает пользователей в группу
+
+        Args:
+            chat_id (int): ID группы.
+            user_ids (list[int]): Список идентификаторов пользователей.
+            show_history (bool, optional): Флаг оповещения. Defaults to True.
+
+        Returns:
+            bool: True, если пользователи успешно приглашены
+        """
+        try:
+            payload = InviteUsersPayload(
+                chat_id=chat_id,
+                user_ids=user_ids,
+                show_history=show_history,
+                operation="add",
+            ).model_dump(by_alias=True)
+
+            data = await self._send_and_wait(
+                opcode=Opcode.CHAT_MEMBERS_UPDATE, payload=payload
+            )
+
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Create group error: %s", error)
+                return False
+
+            chat = Chat.from_dict(data["payload"]["chat"])
+            if chat:
+                cached_chat = await self._get_chat(chat.id)
+                if cached_chat is None:
+                    self.chats.append(chat)
+                else:
+                    idx = self.chats.index(cached_chat)
+                    self.chats[idx] = chat
+
+            return True
+
+        except Exception:
+            self.logger.exception("Invite users to group failed")
+            return False
+
+    async def remove_users_from_group(
+        self,
+        chat_id: int,
+        user_ids: list[int],
+        clean_msg_period: int,
+    ) -> bool:
+        try:
+            payload = RemoveUsersPayload(
+                chat_id=chat_id,
+                user_ids=user_ids,
+                clean_msg_period=clean_msg_period,
+            ).model_dump(by_alias=True)
+
+            data = await self._send_and_wait(
+                opcode=Opcode.CHAT_MEMBERS_UPDATE, payload=payload
+            )
+
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Remove users from group error: %s", error)
+                return False
+
+            chat = Chat.from_dict(data["payload"]["chat"])
+            if chat:
+                cached_chat = await self._get_chat(chat.id)
+                if cached_chat is None:
+                    self.chats.append(chat)
+                else:
+                    idx = self.chats.index(cached_chat)
+                    self.chats[idx] = chat
+
+            return True
+        except Exception:
+            self.logger.exception("Remove users from group failed")
+            return False
+
+    async def change_group_settings(
+        self,
+        chat_id: int,
+        all_can_pin_message: bool | None = None,
+        only_owner_can_change_icon_title: bool | None = None,
+        only_admin_can_add_member: bool | None = None,
+        only_admin_can_call: bool | None = None,
+        members_can_see_private_link: bool | None = None,
+    ):
+        try:
+            payload = ChangeGroupSettingsPayload(
+                chat_id=chat_id,
+                options=ChangeGroupSettingsOptions(
+                    ALL_CAN_PIN_MESSAGE=all_can_pin_message,
+                    ONLY_OWNER_CAN_CHANGE_ICON_TITLE=only_owner_can_change_icon_title,
+                    ONLY_ADMIN_CAN_ADD_MEMBER=only_admin_can_add_member,
+                    ONLY_ADMIN_CAN_CALL=only_admin_can_call,
+                    MEMBERS_CAN_SEE_PRIVATE_LINK=members_can_see_private_link,
+                ),
+            ).model_dump(by_alias=True, exclude_none=True)
+
+            data = await self._send_and_wait(opcode=Opcode.CHAT_UPDATE, payload=payload)
+
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Change group settings error: %s", error)
+                return
+
+            chat = Chat.from_dict(data["payload"]["chat"])
+            if chat:
+                cached_chat = await self._get_chat(chat.id)
+                if cached_chat is None:
+                    self.chats.append(chat)
+                else:
+                    idx = self.chats.index(cached_chat)
+                    self.chats[idx] = chat
+
+        except Exception:
+            self.logger.exception("Change group settings failed")
+
+    async def change_group_profile(
+        self,
+        chat_id: int,
+        name: str | None,
+        description: str | None = None,
+    ):
+        try:
+            payload = ChangeGroupProfilePayload(
+                chat_id=chat_id,
+                theme=name,
+                description=description,
+            ).model_dump(by_alias=True, exclude_none=True)
+
+            data = await self._send_and_wait(opcode=Opcode.CHAT_UPDATE, payload=payload)
+
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Change group profile error: %s", error)
+                return
+
+            chat = Chat.from_dict(data["payload"]["chat"])
+            if chat:
+                cached_chat = await self._get_chat(chat.id)
+                if cached_chat is None:
+                    self.chats.append(chat)
+                else:
+                    idx = self.chats.index(cached_chat)
+                    self.chats[idx] = chat
+
+        except Exception:
+            self.logger.exception("Change group profile failed")

pymax/mixins/handler.py

@@ -0,0 +1,60 @@
+from typing import Any, Awaitable, Callable
+
+from pymax.interfaces import ClientProtocol, Filter
+from pymax.types import Message
+
+
+class HandlerMixin(ClientProtocol):
+    def on_message(
+        self, *, filter: Filter | None = None
+    ) -> Callable[
+        [Callable[[Any], Any | Awaitable[Any]]], Callable[[Any], Any | Awaitable[Any]]
+    ]:
+        """
+        Декоратор для установки обработчика входящих сообщений.
+
+        Args:
+            filter: Фильтр для обработки сообщений.
+
+        Returns:
+            Декоратор.
+        """
+
+        def decorator(
+            handler: Callable[[Any], Any | Awaitable[Any]],
+        ) -> Callable[[Any], Any | Awaitable[Any]]:
+            self._on_message_handlers.append((handler, filter))
+            self.logger.info(f"on_message handler set: {handler}, filter: {filter}")
+            return handler
+
+        return decorator
+
+    def on_start(
+        self, handler: Callable[[], Any | Awaitable[Any]]
+    ) -> Callable[[], Any | Awaitable[Any]]:
+        """
+        Устанавливает обработчик, вызываемый при старте клиента.
+
+        Args:
+            handler: Функция или coroutine без аргументов.
+
+        Returns:
+            Установленный обработчик.
+        """
+        self._on_start_handler = handler
+        self.logger.debug("on_start handler set: %r", handler)
+        return handler
+
+    def add_message_handler(
+        self, handler: Callable[[Message], Any | Awaitable[Any]], filter: Filter | None
+    ) -> Callable[[Message], Any | Awaitable[Any]]:
+        self.logger.debug("add_message_handler (alias) used")
+        self._on_message_handlers.append((handler, filter))
+        return handler
+
+    def add_on_start_handler(
+        self, handler: Callable[[], Any | Awaitable[Any]]
+    ) -> Callable[[], Any | Awaitable[Any]]:
+        self.logger.debug("add_on_start_handler (alias) used")
+        self._on_start_handler = handler
+        return handler