maxapi-python 2.4.1__py3-none-any.whl → 2.5.0__py3-none-any.whl

pymax/api/bots/payloads.py

@@ -1,7 +1,15 @@
 from pymax.api.models import CamelModel
+from pymax.types import ButtonType
 
 
 class RequestInitDataPayload(CamelModel):
     bot_id: int
     chat_id: int | None = None
     start_param: str | None = None
+
+
+class SendCallbackPayload(CamelModel):
+    callback_id: str
+    type: ButtonType
+    payload: str | None = None
+    timestamp: int

pymax/api/bots/service.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
+import time
 from typing import TYPE_CHECKING
 
+from pymax.api.binding import bind_api_model
 from pymax.api.response import require_payload_model
 from pymax.logging import get_logger
 from pymax.protocol import Opcode
+from pymax.types import ButtonType, CallbackResponse
 from pymax.types.domain import InitData
 
-from .payloads import RequestInitDataPayload
+from .payloads import RequestInitDataPayload, SendCallbackPayload
 
 if TYPE_CHECKING:
     from pymax.app import App
@@ -29,3 +32,12 @@ class BotsService:
         frame = RequestInitDataPayload(bot_id=bot_id, chat_id=chat_id, start_param=start_param)
         response = await self.app.invoke(Opcode.WEB_APP_INIT_DATA, frame.to_payload())
         return require_payload_model(response, InitData)
+
+    async def send_callback(
+        self, callback_id: str, type: ButtonType, payload: str | None = None
+    ) -> CallbackResponse:
+        frame = SendCallbackPayload(
+            callback_id=callback_id, type=type, payload=payload, timestamp=int(time.time() * 1000)
+        )
+        response = await self.app.invoke(Opcode.MSG_SEND_CALLBACK, frame.to_payload())
+        return bind_api_model(self.app, require_payload_model(response, CallbackResponse))

pymax/api/chats/enums.py

@@ -11,6 +11,7 @@ class ChatMemberOperation(str, Enum):
 
 
 class ChatOption(str, Enum):
+    COMMENTS = "COMMENTS"
     ONLY_OWNER_CAN_CHANGE_ICON_TITLE = "ONLY_OWNER_CAN_CHANGE_ICON_TITLE"
     ALL_CAN_PIN_MESSAGE = "ALL_CAN_PIN_MESSAGE"
     ONLY_ADMIN_CAN_ADD_MEMBER = "ONLY_ADMIN_CAN_ADD_MEMBER"

pymax/api/chats/payloads.py

@@ -137,3 +137,22 @@ class AddAdminPayload(CamelModel):
     type: PermType = PermType.ADMIN
     operation: str = "add"
     permissions: int
+
+
+class ChannelCommentsOptions(CamelModel):
+    comments: bool = Field(serialization_alias=ChatOption.COMMENTS.value)
+
+
+class SetChannelCommentsPayload(CamelModel):
+    chat_id: int
+    options: ChannelCommentsOptions
+
+
+class BlockCommentAuthorPayload(CamelModel):
+    chat_id: int
+    post_id: int
+    user_ids: list[int]
+    message_id: int
+    type: Literal["COMMENTS_BLACKLIST"] = "COMMENTS_BLACKLIST"
+    operation: ChatMemberOperation = ChatMemberOperation.ADD
+    clean_msg_period: int = 0

pymax/api/chats/service.py

@@ -22,9 +22,11 @@ from pymax.types.domain import Chat, Member, Message
 from .enums import ChannelPermissions, ChatLinkPrefix, ChatMemberOperation, ChatPayloadKey
 from .payloads import (
     AddAdminPayload,
+    BlockCommentAuthorPayload,
     ChangeGroupProfilePayload,
     ChangeGroupSettingsOptions,
     ChangeGroupSettingsPayload,
+    ChannelCommentsOptions,
     CreateGroupAttach,
     CreateGroupMessage,
     CreateGroupPayload,
@@ -40,6 +42,7 @@ from .payloads import (
     LinkInfoPayload,
     RemoveUsersPayload,
     ReworkInviteLinkPayload,
+    SetChannelCommentsPayload,
 )
 
 if TYPE_CHECKING:
@@ -422,3 +425,34 @@ class ChatService:
         )
 
         await self.app.invoke(Opcode.CHAT_MEMBERS_UPDATE, frame.to_payload())
+
+    async def set_channel_comments(self, chat_id: int, enabled: bool) -> None:
+        frame = SetChannelCommentsPayload(
+            chat_id=chat_id,
+            options=ChannelCommentsOptions(comments=enabled),
+        )
+        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 block_comment_author(
+        self,
+        chat_id: int,
+        post_id: int,
+        user_ids: list[int],
+        message_id: int,
+        clean_msg_period: int = 0,
+    ) -> bool:
+        frame = BlockCommentAuthorPayload(
+            chat_id=chat_id,
+            post_id=post_id,
+            user_ids=user_ids,
+            message_id=message_id,
+            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

pymax/api/facade.py

@@ -10,6 +10,7 @@ from .chats import ChatService
 from .messages import MessageService
 from .self import SelfService
 from .session import SessionService
+from .stories import StoriesService
 from .uploads import UploadService
 from .users import UserService
 
@@ -31,4 +32,5 @@ class ApiFacade:
         self.session = SessionService(app)
         self.auth = AuthService(app)
         self.uploads = UploadService(app)
+        self.stories = StoriesService(app)
         logger.debug("api facade initialized")

pymax/api/messages/enums.py

@@ -16,3 +16,4 @@ class MessagePayloadKey(str, Enum):
     MESSAGES = "messages"
     REACTION_INFO = "reactionInfo"
     MESSAGES_REACTIONS = "messagesReactions"
+    COMMENTS_INFO_UPDATES = "commentsInfoUpdates"

pymax/api/messages/payloads.py

@@ -18,6 +18,10 @@ class GetMessagesPayload(CamelModel):
     message_ids: list[int]
 
 
+class GetCommentsPayload(GetMessagesPayload):
+    post_id: int
+
+
 class EditMessagePayload(CamelModel):
     chat_id: int
     message_id: int
@@ -28,6 +32,10 @@ class EditMessagePayload(CamelModel):
     )
 
 
+class EditCommentPayload(EditMessagePayload):
+    post_id: int
+
+
 class ReplyLink(CamelModel):
     type: str = "REPLY"  # TODO: enum?
     message_id: int
@@ -53,6 +61,10 @@ class SendMessagePayload(CamelModel):
     notify: bool = False
 
 
+class SendCommentPayload(SendMessagePayload):
+    post_id: int
+
+
 class ForwardLink(CamelModel):
     type: Literal["FORWARD"] = "FORWARD"
     message_id: str
@@ -86,6 +98,10 @@ class ChatHistoryPayload(CamelModel):
     interactive: bool = False
 
 
+class CommentsHistoryPayload(ChatHistoryPayload):
+    post_id: int
+
+
 class DeleteMessagePayload(CamelModel):
     chat_id: int
     message_ids: list[int]
@@ -134,7 +150,7 @@ class RemoveReactionPayload(CamelModel):
 class ReadMessagesPayload(CamelModel):
     type: ReadAction
     chat_id: int
-    message_id: str | int  # Сокет просит int а вс str
+    message_id: int
     mark: int
 
 
@@ -143,3 +159,33 @@ class VotePollPayload(CamelModel):
     message_id: int
     poll_id: int
     answers_ids: list[int]
+
+
+class DeleteCommentPayload(DeleteMessagePayload):
+    post_id: int
+
+
+class AddCommentReactionPayload(AddReactionPayload):
+    post_id: int
+
+
+class RemoveCommentReactionPayload(RemoveReactionPayload):
+    post_id: int
+
+
+class SubscribeCommentsPayload(CamelModel):
+    chat_id: int
+    post_id: int
+    subscribe: bool = True
+
+
+class GetCommentsInfoPayload(CamelModel):
+    chat_id: int
+    post_ids: list[int]
+
+
+class DeleteUserCommentsPayload(CamelModel):
+    chat_id: int
+    post_id: int
+    user_id: int
+    message_id: int

pymax/api/messages/service.py

@@ -27,6 +27,7 @@ from pymax.formatting.markdown import Formatter
 from pymax.logging import get_logger
 from pymax.protocol import Opcode
 from pymax.types.domain import (
+    CommentsInfoUpdate,
     FileRequest,
     Message,
     Poll,
@@ -38,14 +39,21 @@ from pymax.types.domain import (
 
 from .enums import ItemType, MessagePayloadKey, ReadAction
 from .payloads import (
+    AddCommentReactionPayload,
     AddReactionPayload,
     ChatHistoryPayload,
+    CommentsHistoryPayload,
     DelayedAttributes,
+    DeleteCommentPayload,
     DeleteMessagePayload,
+    DeleteUserCommentsPayload,
+    EditCommentPayload,
     EditMessagePayload,
     ForwardLink,
     ForwardMessagePayload,
     ForwardMessagePayloadMessage,
+    GetCommentsInfoPayload,
+    GetCommentsPayload,
     GetFilePayload,
     GetMessagesPayload,
     GetReactionsPayload,
@@ -53,10 +61,13 @@ from .payloads import (
     PinMessagePayload,
     ReactionInfoPayload,
     ReadMessagesPayload,
+    RemoveCommentReactionPayload,
     RemoveReactionPayload,
     ReplyLink,
+    SendCommentPayload,
     SendMessagePayload,
     SendMessagePayloadMessage,
+    SubscribeCommentsPayload,
     VotePollPayload,
 )
 
@@ -85,6 +96,40 @@ class MessageService:
         logger.debug("generated message cid=%s", e)
         return e
 
+    async def _prepare_message(
+        self,
+        text: str | None,
+        reply_to: int | None,
+        attachments: SendAttachments,
+        *,
+        delayed_attributes: DelayedAttributes | None = None,
+    ) -> tuple[
+        SendMessagePayloadMessage,
+        list[
+            AttachPhotoPayload | VideoAttachPayload | AttachFilePayload | VoiceAttachPayload | Poll
+        ],
+    ]:
+        if not text and not attachments:
+            raise ValueError("Either text or attachments must be provided")
+
+        if text:
+            clean_text, elements = Formatter.format_markdown(text)
+        else:
+            clean_text, elements = None, []
+
+        attaches = await self._upload_attachments(attachments)
+
+        message = SendMessagePayloadMessage(
+            text=clean_text,
+            cid=self._next_cid(),
+            elements=elements,
+            attaches=attaches,
+            link=ReplyLink(message_id=reply_to) if reply_to else None,
+            delayed_attributes=delayed_attributes,
+        )
+
+        return message, attaches
+
     async def _upload_attachments(
         self, attachments: SendAttachments
     ) -> list[
@@ -202,32 +247,21 @@ class MessageService:
     ) -> Message:
         logger.info("sending message chat_id=%s text_len=%s", chat_id, len(text) if text else 0)
 
-        if not text and not attachments:
-            logger.error("send_message failed: no text or attachments provided")
-            raise ValueError("Either text or attachments must be provided")
-
-        if text:
-            clean_text, elements = Formatter.format_markdown(text)
-        else:
-            clean_text, elements = None, []
-
-        attaches = await self._upload_attachments(attachments)
+        message, attaches = await self._prepare_message(
+            text,
+            reply_to,
+            attachments,
+            delayed_attributes=DelayedAttributes(
+                time_to_fire=self._convert_time(send_at),
+                notify_sender=notify,
+            )
+            if send_at
+            else None,
+        )
 
         frame = SendMessagePayload(
             chat_id=chat_id,
-            message=SendMessagePayloadMessage(
-                text=clean_text,
-                cid=self._next_cid(),
-                elements=elements,
-                attaches=attaches,
-                link=ReplyLink(message_id=reply_to) if reply_to else None,
-                delayed_attributes=DelayedAttributes(
-                    time_to_fire=self._convert_time(send_at),
-                    notify_sender=notify,
-                )
-                if send_at
-                else None,
-            ),
+            message=message,
             notify=notify,
         )
 
@@ -390,6 +424,33 @@ class MessageService:
         )
         return messages
 
+    async def fetch_comments(
+        self,
+        chat_id: int,
+        post_id: int,
+        from_: int | None = None,
+        backward: int = 30,
+        get_messages: bool = True,
+        forward: int = 0,
+    ) -> list[Message]:
+        frame = CommentsHistoryPayload(
+            chat_id=chat_id,
+            forward=forward,
+            backward=backward,
+            post_id=post_id,
+            from_=-1 if from_ is None else from_,
+            get_messages=get_messages,
+        )
+        response = await self.app.invoke(
+            Opcode.CHAT_HISTORY,
+            payload=frame.to_payload(),
+        )
+        messages = bind_api_models(
+            self.app,
+            parse_payload_list(response, MessagePayloadKey.MESSAGES, Message),
+        )
+        return messages
+
     async def delete_message(
         self,
         chat_id: int,
@@ -551,7 +612,7 @@ class MessageService:
 
         return None
 
-    async def read_message(self, message_id: int | str, chat_id: int) -> ReadState:
+    async def read_message(self, message_id: int, chat_id: int) -> ReadState:
         logger.info(
             "marking message as read chat_id=%s message_id=%s",
             chat_id,
@@ -580,3 +641,226 @@ class MessageService:
         response = await self.app.invoke(Opcode.SEND_VOTE, frame.to_payload())
 
         return require_payload_item_model(response, "state", PollState)
+
+    async def send_comment(
+        self,
+        chat_id: int,
+        post_id: int,
+        text: str | None = None,
+        reply_to: int | None = None,
+        attachments: SendAttachments = None,
+        *,
+        notify: bool = True,
+    ) -> Message:
+        message, attaches = await self._prepare_message(text, reply_to, attachments)
+
+        frame = SendCommentPayload(
+            chat_id=chat_id,
+            post_id=post_id,
+            notify=notify,
+            message=message,
+        )
+
+        try:
+            response = await self.app.invoke(Opcode.MSG_SEND, frame.to_payload())
+        except ApiError as e:
+            if e.error == "attachment.not.ready":
+                await self._process_attachment_error(attaches)
+                response = await self.app.invoke(Opcode.MSG_SEND, frame.to_payload())
+            else:
+                raise
+
+        return bind_api_model(
+            self.app,
+            require_payload_model(response, Message),
+        )
+
+    async def get_comments(
+        self,
+        chat_id: int,
+        post_id: int,
+        message_ids: list[int],
+    ) -> list[Message]:
+        frame = GetCommentsPayload(
+            chat_id=chat_id,
+            post_id=post_id,
+            message_ids=message_ids,
+        )
+
+        response = await self.app.invoke(Opcode.MSG_GET, frame.to_payload())
+        messages = parse_payload_list(response, MessagePayloadKey.MESSAGES, Message)
+        for message in messages:
+            if message.chat_id is None:
+                message.chat_id = chat_id
+
+        return bind_api_models(self.app, messages)
+
+    async def get_comment(
+        self,
+        chat_id: int,
+        post_id: int,
+        message_id: int,
+    ) -> Message | None:
+        messages = await self.get_comments(chat_id, post_id, [message_id])
+        return messages[0] if messages else None
+
+    async def edit_comment(
+        self,
+        chat_id: int,
+        post_id: int,
+        message_id: int,
+        text: str | None = None,
+        attachments: SendAttachments = None,
+    ) -> Message:
+        if not text and not attachments:
+            logger.error("edit_comment failed: no text or attachments provided")
+            raise ValueError("Either text or attachments must be provided")
+
+        if text:
+            clean_text, elements = Formatter.format_markdown(text)
+        else:
+            clean_text, elements = None, []
+
+        attaches = await self._upload_attachments(attachments)
+
+        frame = EditCommentPayload(
+            chat_id=chat_id,
+            post_id=post_id,
+            message_id=message_id,
+            text=clean_text,
+            elements=elements,
+            attachments=attaches,
+        )
+        try:
+            response = await self.app.invoke(Opcode.MSG_EDIT, frame.to_payload())
+        except ApiError as e:
+            if e.error == "attachment.not.ready":
+                await self._process_attachment_error(attaches)
+
+                response = await self.app.invoke(Opcode.MSG_EDIT, frame.to_payload())
+            else:
+                raise
+
+        message = require_payload_item_model(
+            response,
+            MessagePayloadKey.MESSAGE,
+            Message,
+        )
+        if message.chat_id is None:
+            message.chat_id = chat_id
+
+        return bind_api_model(self.app, message)
+
+    async def delete_comment(
+        self,
+        chat_id: int,
+        post_id: int,
+        message_ids: list[int],
+        for_me: bool = False,
+    ) -> bool:
+        logger.info(
+            "deleting messages chat_id=%s ids=%s for_me=%s",
+            chat_id,
+            message_ids,
+            for_me,
+        )
+        frame = DeleteCommentPayload(
+            chat_id=chat_id,
+            post_id=post_id,
+            message_ids=message_ids,
+            for_me=for_me,
+        )
+
+        await self.app.invoke(Opcode.MSG_DELETE, frame.to_payload())
+        logger.info("messages deleted chat_id=%s count=%s", chat_id, len(message_ids))
+        return True
+
+    async def add_comment_reaction(
+        self,
+        chat_id: int,
+        post_id: int,
+        message_id: int,
+        reaction: str,
+    ) -> ReactionInfo | None:
+        logger.info(
+            "adding reaction chat_id=%s message_id=%s reaction=%s",
+            chat_id,
+            message_id,
+            reaction,
+        )
+        frame = AddCommentReactionPayload(
+            chat_id=chat_id,
+            post_id=post_id,
+            message_id=message_id,
+            reaction=ReactionInfoPayload(id=reaction),
+        )
+
+        response = await self.app.invoke(Opcode.MSG_REACTION, frame.to_payload())
+        reaction_info = payload_item(response, MessagePayloadKey.REACTION_INFO)
+        if reaction_info:
+            return ReactionInfo.model_validate(reaction_info)
+
+        return None
+
+    async def remove_comment_reaction(
+        self,
+        chat_id: int,
+        post_id: int,
+        message_id: int,
+    ) -> ReactionInfo | None:
+        logger.info(
+            "removing reaction chat_id=%s message_id=%s",
+            chat_id,
+            message_id,
+        )
+        frame = RemoveCommentReactionPayload(
+            chat_id=chat_id, post_id=post_id, message_id=message_id
+        )
+
+        response = await self.app.invoke(
+            Opcode.MSG_CANCEL_REACTION,
+            frame.to_payload(),
+        )
+        reaction_info = payload_item(response, MessagePayloadKey.REACTION_INFO)
+        if reaction_info:
+            return ReactionInfo.model_validate(reaction_info)
+
+        return None
+
+    async def subscribe_comments(
+        self,
+        chat_id: int,
+        post_id: int,
+        subscribe: bool = True,
+    ) -> None:
+        frame = SubscribeCommentsPayload(chat_id=chat_id, post_id=post_id, subscribe=subscribe)
+        await self.app.invoke(Opcode.CHAT_SUBSCRIBE, frame.to_payload())
+
+    async def get_comments_info(
+        self,
+        chat_id: int,
+        post_ids: list[int],
+    ) -> list[CommentsInfoUpdate]:
+        frame = GetCommentsInfoPayload(chat_id=chat_id, post_ids=post_ids)
+        response = await self.app.invoke(Opcode.MSG_GET_COMMENTS_INFO, frame.to_payload())
+        return parse_payload_list(
+            response,
+            MessagePayloadKey.COMMENTS_INFO_UPDATES,
+            CommentsInfoUpdate,
+        )
+
+    async def delete_user_comments(
+        self,
+        chat_id: int,
+        post_id: int,
+        user_id: int,
+        message_id: int,
+    ) -> bool:
+        frame = DeleteUserCommentsPayload(
+            chat_id=chat_id,
+            post_id=post_id,
+            user_id=user_id,
+            message_id=message_id,
+        )
+        await self.app.invoke(Opcode.MSG_DELETE_USER_COMMENTS, frame.to_payload())
+        return True

pymax/api/response.py

@@ -60,7 +60,7 @@ def payload_item(
     if validation_type is None:
         return data
 
-    return cast(Any, validation_type)(data)
+    return cast("Any", validation_type)(data)
 
 
 def require_payload_item(

pymax/api/stories/__init__.py

@@ -0,0 +1,2 @@
+from .enums import StoryStatsFilter
+from .service import StoriesService

pymax/api/stories/enums.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class StoryStatsFilter(int, Enum):
+    """Фильтр подробной статистики: просмотры (``0``) или реакции (``1``)."""
+
+    VIEWS = 0
+    REACTIONS = 1
+
+
+class StoryPayloadKey(str, Enum):
+    STORIES = "stories"
+    PEER_STORIES = "peerStories"
+    STORY = "story"
+    STORIES_PREVIEWS = "storiesPreviews"
+    CURSOR = "cursor"
+    STORY_DETAILED_STATS = "storyDetailedStats"
+    MARKER = "marker"
+    SUCCESS = "success"