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

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

pymax/mixins/message.py

@@ -0,0 +1,293 @@
+import time
+
+import aiohttp
+from aiohttp import ClientSession
+
+from pymax.files import File, Photo, Video
+from pymax.interfaces import ClientProtocol
+from pymax.payloads import (
+    AttachPhotoPayload,
+    DeleteMessagePayload,
+    EditMessagePayload,
+    FetchHistoryPayload,
+    PinMessagePayload,
+    ReplyLink,
+    SendMessagePayload,
+    SendMessagePayloadMessage,
+    UploadPhotoPayload,
+)
+from pymax.static import AttachType, Opcode
+from pymax.types import Attach, Message
+
+
+class MessageMixin(ClientProtocol):
+    async def _upload_photo(self, photo: Photo) -> None | Attach:
+        try:
+            self.logger.info("Uploading photo")
+            payload = UploadPhotoPayload().model_dump(by_alias=True)
+
+            data = await self._send_and_wait(
+                opcode=Opcode.PHOTO_UPLOAD,
+                payload=payload,
+            )
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Upload photo error: %s", error)
+                return None
+
+            url = data.get("payload", {}).get("url")
+            if not url:
+                self.logger.error("No upload URL received")
+                return None
+
+            photo_data = photo.validate_photo()
+            if not photo_data:
+                self.logger.error("Photo validation failed")
+                return None
+
+            form = aiohttp.FormData()
+            form.add_field(
+                name="file",
+                value=await photo.read(),
+                filename=f"image.{photo_data[0]}",
+                content_type=photo_data[1],
+            )
+
+            async with (
+                ClientSession() as session,
+                session.post(
+                    url=url,
+                    data=form,
+                ) as response,
+            ):
+                if response.status != 200:
+                    self.logger.error(f"Upload failed with status {response.status}")
+                    return None
+
+                result = await response.json()
+
+                if not result.get("photos"):
+                    self.logger.error("No photos in response")
+                    return None
+
+                photo_data = next(iter(result["photos"].values()), None)
+                if not photo_data or "token" not in photo_data:
+                    self.logger.error("No token in response")
+                    return None
+
+                return Attach(
+                    _type=AttachType.PHOTO,
+                    photo_token=photo_data["token"],
+                )
+
+        except Exception as e:
+            self.logger.exception("Upload photo failed: %s", str(e))
+            return None
+
+    async def send_message(
+        self,
+        text: str,
+        chat_id: int,
+        notify: bool,
+        photo: Photo | None = None,
+        photos: list[Photo] | None = None,
+        reply_to: int | None = None,
+    ) -> Message | None:
+        """
+        Отправляет сообщение в чат.
+        """
+        try:
+            self.logger.info("Sending message to chat_id=%s notify=%s", chat_id, notify)
+            if photos and photo:
+                self.logger.warning("Both photo and photos provided; using photos")
+                photo = None
+            attaches = []
+            if photo:
+                self.logger.info("Uploading photo for message")
+                attach = await self._upload_photo(photo)
+                if not attach or not attach.photo_token:
+                    self.logger.error("Photo upload failed, message not sent")
+                    return None
+                attaches = [
+                    AttachPhotoPayload(photo_token=attach.photo_token).model_dump(
+                        by_alias=True
+                    )
+                ]
+            elif photos:
+                self.logger.info("Uploading multiple photos for message")
+                for p in photos:
+                    attach = await self._upload_photo(p)
+                    if attach and attach.photo_token:
+                        attaches.append(
+                            AttachPhotoPayload(
+                                photo_token=attach.photo_token
+                            ).model_dump(by_alias=True)
+                        )
+                if not attaches:
+                    self.logger.error("All photo uploads failed, message not sent")
+                    return None
+
+            payload = SendMessagePayload(
+                chat_id=chat_id,
+                message=SendMessagePayloadMessage(
+                    text=text,
+                    cid=int(time.time() * 1000),
+                    elements=[],
+                    attaches=attaches,
+                    link=ReplyLink(message_id=str(reply_to)) if reply_to else None,
+                ),
+                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("Send message error: %s", error)
+                print(data)
+                return None
+            msg = (
+                Message.from_dict(data["payload"]["message"])
+                if data.get("payload")
+                else None
+            )
+            self.logger.debug("send_message result: %r", msg)
+            return msg
+        except Exception:
+            self.logger.exception("Send message failed")
+            return None
+
+    async def edit_message(
+        self, chat_id: int, message_id: int, text: str
+    ) -> Message | None:
+        """
+        Редактирует сообщение.
+        """
+        try:
+            self.logger.info(
+                "Editing message chat_id=%s message_id=%s", chat_id, message_id
+            )
+            payload = EditMessagePayload(
+                chat_id=chat_id,
+                message_id=message_id,
+                text=text,
+                elements=[],
+                attaches=[],
+            ).model_dump(by_alias=True)
+            data = await self._send_and_wait(opcode=Opcode.MSG_EDIT, payload=payload)
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Edit message error: %s", error)
+            msg = (
+                Message.from_dict(data["payload"]["message"])
+                if data.get("payload")
+                else None
+            )
+            self.logger.debug("edit_message result: %r", msg)
+            return msg
+        except Exception:
+            self.logger.exception("Edit message failed")
+            return None
+
+    async def delete_message(
+        self, chat_id: int, message_ids: list[int], for_me: bool
+    ) -> bool:
+        """
+        Удаляет сообщения.
+        """
+        try:
+            self.logger.info(
+                "Deleting messages chat_id=%s ids=%s for_me=%s",
+                chat_id,
+                message_ids,
+                for_me,
+            )
+
+            payload = DeleteMessagePayload(
+                chat_id=chat_id, message_ids=message_ids, for_me=for_me
+            ).model_dump(by_alias=True)
+
+            data = await self._send_and_wait(opcode=Opcode.MSG_DELETE, payload=payload)
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Delete message error: %s", error)
+                return False
+            self.logger.debug("delete_message success")
+            return True
+        except Exception:
+            self.logger.exception("Delete message failed")
+            return False
+
+    async def pin_message(
+        self, chat_id: int, message_id: int, notify_pin: bool
+    ) -> bool:
+        """
+        Закрепляет сообщение.
+
+        Args:
+            chat_id (int): ID чата
+            message_id (int): ID сообщения
+            notify_pin (bool): Оповещать о закреплении
+
+        Returns:
+            bool: True, если сообщение закреплено
+        """
+        try:
+            payload = PinMessagePayload(
+                chat_id=chat_id,
+                notify_pin=notify_pin,
+                pin_message_id=message_id,
+            ).model_dump(by_alias=True)
+
+            data = await self._send_and_wait(opcode=Opcode.CHAT_UPDATE, payload=payload)
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Pin message error: %s", error)
+                return False
+            self.logger.debug("pin_message success")
+            return True
+        except Exception:
+            self.logger.exception("Pin message failed")
+            return False
+
+    async def fetch_history(
+        self,
+        chat_id: int,
+        from_time: int | None = None,
+        forward: int = 0,
+        backward: int = 200,
+    ) -> list[Message] | None:
+        """
+        Получает историю сообщений чата.
+        """
+        if from_time is None:
+            from_time = int(time.time() * 1000)
+
+        try:
+            self.logger.info(
+                "Fetching history chat_id=%s from=%s forward=%s backward=%s",
+                chat_id,
+                from_time,
+                forward,
+                backward,
+            )
+
+            payload = FetchHistoryPayload(
+                chat_id=chat_id,
+                from_time=from_time,  # pyright: ignore[reportCallIssue] FIXME: Pydantic Field alias
+                forward=forward,
+                backward=backward,
+            ).model_dump(by_alias=True)
+
+            self.logger.debug("Payload dict keys: %s", list(payload.keys()))
+
+            data = await self._send_and_wait(
+                opcode=Opcode.CHAT_HISTORY, payload=payload, timeout=10
+            )
+
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Fetch history error: %s", error)
+                return None
+
+            messages = [
+                Message.from_dict(msg) for msg in data["payload"].get("messages", [])
+            ]
+            self.logger.debug("History fetched: %d messages", len(messages))
+            return messages
+        except Exception:
+            self.logger.exception("Fetch history failed")
+            return None