maxapi-python 1.2.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

pymax/api/chats/service.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+from pymax.api.response import (
+    parse_payload_item_model,
+    parse_payload_list,
+    require_payload_item_model,
+    require_payload_model,
+)
+from pymax.exceptions import PyMaxError
+from pymax.logging import get_logger
+from pymax.protocol import Opcode
+from pymax.types.domain import Chat, Message
+
+from .enums import ChatLinkPrefix, ChatPayloadKey
+from .payloads import (
+    ChangeGroupProfilePayload,
+    ChangeGroupSettingsOptions,
+    ChangeGroupSettingsPayload,
+    CreateGroupAttach,
+    CreateGroupMessage,
+    CreateGroupPayload,
+    FetchChatsPayload,
+    GetChatInfoPayload,
+    InviteUsersPayload,
+    JoinChatPayload,
+    LeaveChatPayload,
+    LinkInfoPayload,
+    RemoveUsersPayload,
+    ReworkInviteLinkPayload,
+)
+
+if TYPE_CHECKING:
+    from pymax.app import App
+
+
+logger = get_logger(__name__)
+
+
+class ChatService:
+    def __init__(self, app: App) -> None:
+        self.app = app
+
+    def _bind_chat(self, chat: Chat) -> Chat:
+        return chat.bind(self.app.api.messages, self)
+
+    def _cache_chat(self, chat: Chat) -> Chat:
+        chat = self._bind_chat(chat)
+        if self.app.chats is None:
+            self.app.chats = [chat]
+            return chat
+
+        for index, cached in enumerate(self.app.chats):
+            if cached.id == chat.id:
+                self.app.chats[index] = chat
+                return chat
+
+        self.app.chats.append(chat)
+        return chat
+
+    def _get_cached_chat(self, chat_id: int) -> Chat | None:
+        for chat in self.app.chats or []:
+            if chat.id == chat_id:
+                return chat
+        return None
+
+    def _remove_cached_chat(self, chat_id: int) -> None:
+        if self.app.chats is None:
+            return
+
+        self.app.chats = [chat for chat in self.app.chats if chat.id != chat_id]
+
+    @staticmethod
+    def _process_chat_join_link(link: str) -> str | None:
+        idx = link.find(ChatLinkPrefix.JOIN)
+        return link[idx:] if idx != -1 else None
+
+    async def create_group(
+        self,
+        name: str,
+        participant_ids: list[int] | None = None,
+        notify: bool = True,
+    ) -> tuple[Chat, Message] | None:
+        logger.info(
+            "creating group name_len=%s participants=%s notify=%s",
+            len(name),
+            len(participant_ids or []),
+            notify,
+        )
+        frame = CreateGroupPayload(
+            message=CreateGroupMessage(
+                cid=int(time.time() * 1000),
+                attaches=[
+                    CreateGroupAttach(
+                        title=name,
+                        user_ids=participant_ids or [],
+                    )
+                ],
+            ),
+            notify=notify,
+        )
+
+        response = await self.app.invoke(Opcode.MSG_SEND, frame.to_payload())
+        chat = parse_payload_item_model(response, ChatPayloadKey.CHAT, Chat)
+        if chat is None:
+            return None
+
+        chat = self._cache_chat(chat)
+        message = require_payload_model(response, Message).bind(self.app.api.messages)
+        return chat, message
+
+    async def invite_users_to_group(
+        self,
+        chat_id: int,
+        user_ids: list[int],
+        show_history: bool = True,
+    ) -> Chat | None:
+        frame = InviteUsersPayload(
+            chat_id=chat_id,
+            user_ids=user_ids,
+            show_history=show_history,
+        )
+
+        response = await self.app.invoke(
+            Opcode.CHAT_MEMBERS_UPDATE,
+            frame.to_payload(),
+        )
+        chat = parse_payload_item_model(response, ChatPayloadKey.CHAT, Chat)
+        if chat:
+            return self._cache_chat(chat)
+
+        return None
+
+    async def invite_users_to_channel(
+        self,
+        chat_id: int,
+        user_ids: list[int],
+        show_history: bool = True,
+    ) -> Chat | None:
+        return await self.invite_users_to_group(chat_id, user_ids, show_history)
+
+    async def remove_users_from_group(
+        self,
+        chat_id: int,
+        user_ids: list[int],
+        clean_msg_period: int,
+    ) -> bool:
+        frame = RemoveUsersPayload(
+            chat_id=chat_id,
+            user_ids=user_ids,
+            clean_msg_period=clean_msg_period,
+        )
+
+        response = await self.app.invoke(
+            Opcode.CHAT_MEMBERS_UPDATE,
+            frame.to_payload(),
+        )
+        chat = parse_payload_item_model(response, ChatPayloadKey.CHAT, Chat)
+        if chat:
+            self._cache_chat(chat)
+
+        return True
+
+    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,
+    ) -> None:
+        frame = 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,
+            ),
+        )
+
+        response = await self.app.invoke(Opcode.CHAT_UPDATE, frame.to_payload())
+        chat = parse_payload_item_model(response, ChatPayloadKey.CHAT, Chat)
+        if chat:
+            self._cache_chat(chat)
+
+    async def change_group_profile(
+        self,
+        chat_id: int,
+        name: str | None,
+        description: str | None = None,
+    ) -> None:
+        frame = ChangeGroupProfilePayload(
+            chat_id=chat_id,
+            theme=name,
+            description=description,
+        )
+
+        response = await self.app.invoke(Opcode.CHAT_UPDATE, frame.to_payload())
+        chat = parse_payload_item_model(response, ChatPayloadKey.CHAT, Chat)
+        if chat:
+            self._cache_chat(chat)
+
+    async def join_group(self, link: str) -> Chat:
+        proceed_link = self._process_chat_join_link(link)
+        if proceed_link is None:
+            raise ValueError("Invalid group link")
+
+        frame = JoinChatPayload(link=proceed_link)
+        response = await self.app.invoke(Opcode.CHAT_JOIN, frame.to_payload())
+        chat = require_payload_item_model(response, ChatPayloadKey.CHAT, Chat)
+        return self._cache_chat(chat)
+
+    async def resolve_group_by_link(self, link: str) -> Chat | None:
+        proceed_link = self._process_chat_join_link(link)
+        if proceed_link is None:
+            raise ValueError("Invalid group link")
+
+        frame = LinkInfoPayload(link=proceed_link)
+        response = await self.app.invoke(Opcode.LINK_INFO, frame.to_payload())
+        chat = parse_payload_item_model(response, ChatPayloadKey.CHAT, Chat)
+        if chat:
+            return self._bind_chat(chat)
+
+        return None
+
+    async def rework_invite_link(self, chat_id: int) -> Chat:
+        frame = ReworkInviteLinkPayload(chat_id=chat_id)
+        response = await self.app.invoke(Opcode.CHAT_UPDATE, frame.to_payload())
+        chat = require_payload_item_model(response, ChatPayloadKey.CHAT, Chat)
+        return self._cache_chat(chat)
+
+    async def get_chats(self, chat_ids: list[int]) -> list[Chat]:
+        cached = {
+            chat_id: chat
+            for chat_id in chat_ids
+            if (chat := self._get_cached_chat(chat_id)) is not None
+        }
+        missed_chat_ids = [chat_id for chat_id in chat_ids if chat_id not in cached]
+
+        if missed_chat_ids:
+            frame = GetChatInfoPayload(chat_ids=missed_chat_ids)
+            response = await self.app.invoke(Opcode.CHAT_INFO, frame.to_payload())
+            for chat in parse_payload_list(response, ChatPayloadKey.CHATS, Chat):
+                chat = self._cache_chat(chat)
+                cached[chat.id] = chat
+
+        return [cached[chat_id] for chat_id in chat_ids if chat_id in cached]
+
+    async def get_chat(self, chat_id: int) -> Chat:
+        chats = await self.get_chats([chat_id])
+        if not chats:
+            raise PyMaxError("Chat not found in response")
+
+        return chats[0]
+
+    async def leave_group(self, chat_id: int) -> None:
+        frame = LeaveChatPayload(chat_id=chat_id)
+        await self.app.invoke(Opcode.CHAT_LEAVE, frame.to_payload())
+        self._remove_cached_chat(chat_id)
+
+    async def leave_channel(self, chat_id: int) -> None:
+        await self.leave_group(chat_id)
+
+    async def fetch_chats(self, marker: int | None = None) -> list[Chat]:
+        frame = FetchChatsPayload(marker=marker or int(time.time() * 1000))
+        response = await self.app.invoke(Opcode.CHATS_LIST, frame.to_payload())
+
+        chats = [
+            self._cache_chat(chat)
+            for chat in parse_payload_list(response, ChatPayloadKey.CHATS, Chat)
+        ]
+        return chats

pymax/api/facade.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pymax.logging import get_logger
+
+from .auth import AuthService
+from .chats import ChatService
+from .messages import MessageService
+from .self import SelfService
+from .session import SessionService
+from .uploads import UploadService
+from .users import UserService
+
+if TYPE_CHECKING:
+    from pymax.app import App
+
+
+logger = get_logger(__name__)
+
+
+class ApiFacade:
+    def __init__(self, app: App) -> None:
+        self.app = app
+        self.messages = MessageService(app)
+        self.chats = ChatService(app)
+        self.users = UserService(app)
+        self.account = SelfService(app)
+        self.session = SessionService(app)
+        self.auth = AuthService(app)
+        self.uploads = UploadService(app)
+        logger.debug("api facade initialized")

pymax/api/messages/__init__.py

@@ -0,0 +1 @@
+from .service import MessageService

pymax/api/messages/enums.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class ItemType(str, Enum):
+    REGULAR = "REGULAR"
+    DELAYED = "DELAYED"
+
+
+class ReadAction(str, Enum):
+    READ_MESSAGE = "READ_MESSAGE"
+    READ_REACTION = "READ_REACTION"
+
+
+class MessagePayloadKey(str, Enum):
+    MESSAGES = "messages"
+    REACTION_INFO = "reactionInfo"
+    MESSAGES_REACTIONS = "messagesReactions"

pymax/api/messages/payloads.py

@@ -0,0 +1,92 @@
+from typing import Any
+
+from pydantic import Field
+
+from pymax.api.models import CamelModel
+from pymax.api.uploads.payloads import AttachFilePayload, AttachPhotoPayload, VideoAttachPayload
+
+from .enums import ItemType, ReadAction
+
+
+class ReplyLink(CamelModel):
+    type: str = "REPLY"  # TODO: enum?
+    message_id: int
+
+
+class SendMessagePayloadMessage(CamelModel):
+    text: str
+    cid: int
+    elements: list[Any]
+    attaches: list[AttachPhotoPayload | VideoAttachPayload | AttachFilePayload]
+    link: ReplyLink | None = None
+
+
+class SendMessagePayload(CamelModel):
+    chat_id: int
+    message: SendMessagePayloadMessage
+    notify: bool = False
+
+
+class ChatHistoryPayload(CamelModel):
+    chat_id: int
+    forward: int
+    backward: int = 40
+    backward_time: int = 0
+    forward_time: int = 0
+    get_chat: bool = False
+    from_: int = Field(serialization_alias="from")
+    item_type: ItemType = ItemType.REGULAR
+    get_messages: bool = True
+    interactive: bool = False
+
+
+class DeleteMessagePayload(CamelModel):
+    chat_id: int
+    message_ids: list[int]
+    for_me: bool = False
+
+
+class PinMessagePayload(CamelModel):
+    chat_id: int
+    notify_pin: bool
+    pin_message_id: int
+
+
+class GetVideoPayload(CamelModel):
+    chat_id: int
+    message_id: int | str
+    video_id: int
+
+
+class GetFilePayload(CamelModel):
+    chat_id: int
+    message_id: int | str
+    file_id: int
+
+
+class ReactionInfoPayload(CamelModel):
+    reaction_type: str = "EMOJI"
+    id: str
+
+
+class AddReactionPayload(CamelModel):
+    chat_id: int
+    message_id: str
+    reaction: ReactionInfoPayload
+
+
+class GetReactionsPayload(CamelModel):
+    chat_id: int
+    message_ids: list[str]
+
+
+class RemoveReactionPayload(CamelModel):
+    chat_id: int
+    message_id: str
+
+
+class ReadMessagesPayload(CamelModel):
+    type: ReadAction
+    chat_id: int
+    message_id: str
+    mark: int