maxapi-python 2.1.2__py3-none-any.whl → 2.2.0__py3-none-any.whl

pymax/connection/connection.py

@@ -20,16 +20,19 @@ class ConnectionManager:
         transport: Transport,
         protocol: BaseProtocol,
         on_event: Callable[[InboundFrame], Awaitable[None]] | None = None,
+        on_close: Callable[[Exception | None], None] | None = None,
     ) -> None:
         self.reader = reader
         self.transport = transport
         self.protocol = protocol
         self.on_event = on_event
+        self.on_close = on_close
 
         self.requests = PendingRequests()
 
         self._is_open = False
         self._connection_lost = False
+        self._close_reported = False
         self._seq = -1
 
         self._recv_task: asyncio.Task[None] | None = None
@@ -44,6 +47,7 @@ class ConnectionManager:
         await self.transport.connect()
         self._is_open = True
         self._connection_lost = False
+        self._close_reported = False
 
         self._recv_task = asyncio.create_task(self._recv_loop())
         logger.debug("receive loop started")
@@ -80,7 +84,7 @@ class ConnectionManager:
         self._connection_lost = True
         self.requests.cancel_all(exc=exc)
         await self.transport.close()
-        self._is_open = False
+        self._mark_closed(exc)
 
     async def send(self, frame: OutboundFrame) -> None:
         if not self._is_open:
@@ -116,20 +120,38 @@ class ConnectionManager:
             )
             await self.transport.send(raw)
             return await asyncio.wait_for(future, timeout)
-        except Exception as e:
+        except asyncio.CancelledError:
+            self.requests.discard(frame.seq)
+            raise
+        except (ConnectionError, EOFError, OSError, TimeoutError) as e:
+            logger.warning(
+                "request failed seq=%s opcode=%s error=%s",
+                frame.seq,
+                frame.opcode,
+                e,
+            )
+            self.requests.discard(frame.seq)
+            raise
+        except Exception:
             logger.exception(
                 "request failed seq=%s opcode=%s",
                 frame.seq,
                 frame.opcode,
             )
-            self.requests.reject(frame.seq, e)
+            self.requests.discard(frame.seq)
             raise
 
     async def wait_closed(self) -> None:
         if not self._recv_task:
             return
 
-        await self._recv_task
+        try:
+            await self._recv_task
+        except Exception as e:
+            if self._connection_lost:
+                raise ConnectionError("Connection lost") from e
+            raise
+
         if self._connection_lost:
             raise ConnectionError("Connection lost")
 
@@ -147,27 +169,25 @@ class ConnectionManager:
                 await self._handle_inbound(model)
 
         except EOFError:
+            exc = ConnectionError("Connection closed by the server")
             logger.warning("connection closed by server")
-            self.requests.cancel_all(
-                exc=ConnectionError("Connection closed by the server")
-            )
+            self.requests.cancel_all(exc=exc)
             self._connection_lost = True
-            self._is_open = False
-        except TimeoutError as e:
-            logger.exception("connection timed out")
-            self.requests.cancel_all(
-                exc=ConnectionError("Connection timed out")
-            )
+            self._mark_closed(exc)
+        except (ConnectionError, OSError, TimeoutError) as e:
+            exc = ConnectionError(f"Connection error: {e}")
+            logger.warning("connection closed while reading payload: %s", e)
+            self.requests.cancel_all(exc=exc)
             self._connection_lost = True
-            self._is_open = False
-            raise e
+            self._mark_closed(exc)
         except Exception as e:
+            exc = ConnectionError(f"Connection error: {e}")
             logger.exception("connection receive loop failed")
-            self.requests.cancel_all(
-                exc=ConnectionError(f"Connection error: {e}")
-            )
+
+            self.requests.cancel_all(exc=exc)
+
             self._connection_lost = True
-            self._is_open = False
+            self._mark_closed(exc)
             raise e
 
     async def _handle_inbound(self, frame: InboundFrame) -> None:
@@ -210,6 +230,15 @@ class ConnectionManager:
         self._seq = (self._seq + 1) % 0x10000
         return self._seq
 
+    def _mark_closed(self, exc: Exception | None = None) -> None:
+        self._is_open = False
+        if self._close_reported:
+            return
+
+        self._close_reported = True
+        if self.on_close:
+            self.on_close(exc)
+
     @property
     def is_open(self) -> bool:
         return self._is_open

pymax/connection/readers/tcp.py

@@ -8,9 +8,7 @@ logger = get_logger(__name__)
 
 
 class TCPReader(BaseReader):
-    def __init__(
-        self, transport: TCPTransport, framer: TcpPacketFramer
-    ) -> None:
+    def __init__(self, transport: TCPTransport, framer: TcpPacketFramer) -> None:
         super().__init__()
         self.transport = transport
         self.framer = framer

pymax/dispatch/dispatcher.py

@@ -9,6 +9,12 @@ from pymax.logging import get_logger
 from pymax.protocol import InboundFrame
 from pymax.types import Chat, MessageDeleteEvent
 from pymax.types.domain import Message
+from pymax.types.events import (
+    MessageReadEvent,
+    PresenceEvent,
+    ReactionUpdateEvent,
+    TypingEvent,
+)
 
 from .enums import EventType
 from .mapping import EventMapper, EventResolver
@@ -33,9 +39,7 @@ ClientT = TypeVar("ClientT")
 
 
 class Dispatcher(Generic[ClientT]):
-    def __init__(
-        self, app: App, root_router: Router[ClientT] | None = None
-    ) -> None:
+    def __init__(self, app: App, root_router: Router[ClientT] | None = None) -> None:
         self.root_router: Router[ClientT] = root_router or Router()
         self.internal_router: Router[ClientT] = Router()
         self.resolver = EventResolver()
@@ -71,9 +75,7 @@ class Dispatcher(Generic[ClientT]):
         event: EventType,
         *filters: FilterCallback[Any],
     ) -> HandlerDecorator[Any, ClientT]:
-        logger.debug(
-            "registering handler event=%s filters=%s", event, len(filters)
-        )
+        logger.debug("registering handler event=%s filters=%s", event, len(filters))
         return self.root_router.on(event, *filters)
 
     def on_message(
@@ -87,9 +89,7 @@ class Dispatcher(Generic[ClientT]):
         self,
         *filters: FilterCallback[Message],
     ) -> HandlerDecorator[Message, ClientT]:
-        logger.debug(
-            "registering message edit handler filters=%s", len(filters)
-        )
+        logger.debug("registering message edit handler filters=%s", len(filters))
         return self.root_router.on_message_edit(*filters)
 
     def on_message_delete(
@@ -98,6 +98,30 @@ class Dispatcher(Generic[ClientT]):
     ) -> HandlerDecorator[MessageDeleteEvent, ClientT]:
         return self.root_router.on_message_delete(*filters)
 
+    def on_message_read(
+        self,
+        *filters: FilterCallback[MessageReadEvent],
+    ) -> HandlerDecorator[MessageReadEvent, ClientT]:
+        return self.root_router.on_message_read(*filters)
+
+    def on_typing(
+        self,
+        *filters: FilterCallback[TypingEvent],
+    ) -> HandlerDecorator[TypingEvent, ClientT]:
+        return self.root_router.on_typing(*filters)
+
+    def on_presence(
+        self,
+        *filters: FilterCallback[PresenceEvent],
+    ) -> HandlerDecorator[PresenceEvent, ClientT]:
+        return self.root_router.on_presence(*filters)
+
+    def on_reaction_update(
+        self,
+        *filters: FilterCallback[ReactionUpdateEvent],
+    ) -> HandlerDecorator[ReactionUpdateEvent, ClientT]:
+        return self.root_router.on_reaction_update(*filters)
+
     def on_chat_update(
         self,
         *filters: FilterCallback[Chat],
@@ -116,9 +140,7 @@ class Dispatcher(Generic[ClientT]):
     def iter_routers(self) -> Generator[Router[ClientT], Any, None]:
         yield from self._iter_router(self.root_router)
 
-    def _iter_router(
-        self, router: Router[ClientT]
-    ) -> Generator[Router[ClientT], Any, None]:
+    def _iter_router(self, router: Router[ClientT]) -> Generator[Router[ClientT], Any, None]:
         yield router
 
         for child in router.children:
@@ -161,9 +183,7 @@ class Dispatcher(Generic[ClientT]):
         if event_type is not None:
             logger.debug("dispatching event type=%s", event_type)
             event = self.mapper.map(event_type, frame)
-            await self._dispatch_to_router(
-                self.internal_router, event_type, event
-            )
+            await self._dispatch_to_router(self.internal_router, event_type, event)
             await self._dispatch_to_router(self.root_router, event_type, event)
         else:
             logger.debug(
@@ -209,9 +229,7 @@ class Dispatcher(Generic[ClientT]):
                 return False
         return True
 
-    async def _call(
-        self, callback: HandlerCallback[Any, ClientT], event: Any
-    ) -> Any:
+    async def _call(self, callback: HandlerCallback[Any, ClientT], event: Any) -> Any:
         if self.client is None:
             raise RuntimeError("client is not bound")
 

pymax/dispatch/enums.py

@@ -5,6 +5,10 @@ class EventType(str, Enum):
     MESSAGE_NEW = "message_new"
     MESSAGE_EDIT = "message_edit"
     MESSAGE_DELETE = "message_delete"
+    MESSAGE_READ = "message_read"
+    TYPING = "typing"
+    PRESENCE = "presence"
+    REACTION_UPDATE = "reaction_update"
     CHAT_UPDATE = "chat_update"
     USER_UPDATE = "user_update"
     VIDEO_READY = "video_ready"

pymax/dispatch/mapping.py

@@ -3,11 +3,19 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import TYPE_CHECKING
 
+from pymax.api.binding import bind_api_model
 from pymax.protocol import InboundFrame, Opcode
 from pymax.protocol.enums import Command
 from pymax.types import Chat, MessageDeleteEvent
 from pymax.types.domain import Message
-from pymax.types.events import FileUploadSignal, VideoUploadSignal
+from pymax.types.events import (
+    FileUploadSignal,
+    MessageReadEvent,
+    PresenceEvent,
+    ReactionUpdateEvent,
+    TypingEvent,
+    VideoUploadSignal,
+)
 
 from .enums import EventType
 from .resolvers import (
@@ -15,6 +23,10 @@ from .resolvers import (
     resolve_chat,
     resolve_message,
     resolve_message_delete,
+    resolve_message_read,
+    resolve_presence,
+    resolve_reaction_update,
+    resolve_typing,
 )
 
 if TYPE_CHECKING:
@@ -28,6 +40,10 @@ EVENT_MAP: dict[Opcode, Resolver] = {
     Opcode.NOTIF_CHAT: resolve_chat,
     Opcode.NOTIF_MSG_DELETE: resolve_message_delete,
     Opcode.NOTIF_ATTACH: resolve_attach,
+    Opcode.NOTIF_TYPING: resolve_typing,
+    Opcode.NOTIF_MARK: resolve_message_read,
+    Opcode.NOTIF_PRESENCE: resolve_presence,
+    Opcode.NOTIF_MSG_REACTIONS_CHANGED: resolve_reaction_update,
 }
 
 
@@ -58,21 +74,28 @@ class EventMapper:
 
         if frame.payload:
             if event_type in (EventType.MESSAGE_NEW, EventType.MESSAGE_EDIT):
-                return Message.model_validate(frame.payload).bind(
-                    self.app.api.messages
+                return bind_api_model(
+                    self.app,
+                    Message.model_validate(frame.payload),
                 )
             elif event_type == EventType.CHAT_UPDATE:
-                return Chat.model_validate(frame.payload["chat"]).bind(
-                    self.app.api.messages,
-                    self.app.api.chats,
+                return bind_api_model(
+                    self.app,
+                    Chat.model_validate(frame.payload["chat"]),
                 )
             elif event_type == EventType.MESSAGE_DELETE:
-                model = MessageDeleteEvent.model_validate(frame.payload)
-                model.chat.bind(
-                    self.app.api.messages,
-                    self.app.api.chats,
+                return bind_api_model(
+                    self.app,
+                    MessageDeleteEvent.model_validate(frame.payload),
                 )
-                return model
+            elif event_type == EventType.MESSAGE_READ:
+                return MessageReadEvent.model_validate(frame.payload)
+            elif event_type == EventType.TYPING:
+                return TypingEvent.model_validate(frame.payload)
+            elif event_type == EventType.PRESENCE:
+                return PresenceEvent.model_validate(frame.payload)
+            elif event_type == EventType.REACTION_UPDATE:
+                return ReactionUpdateEvent.model_validate(frame.payload)
             elif event_type == EventType.VIDEO_READY:
                 return VideoUploadSignal.model_validate(frame.payload)
             elif event_type == EventType.FILE_READY:

pymax/dispatch/resolvers.py

@@ -20,6 +20,22 @@ def resolve_message_delete(_: InboundFrame) -> EventType | None:
     return EventType.MESSAGE_DELETE
 
 
+def resolve_message_read(_: InboundFrame) -> EventType | None:
+    return EventType.MESSAGE_READ
+
+
+def resolve_typing(_: InboundFrame) -> EventType | None:
+    return EventType.TYPING
+
+
+def resolve_presence(_: InboundFrame) -> EventType | None:
+    return EventType.PRESENCE
+
+
+def resolve_reaction_update(_: InboundFrame) -> EventType | None:
+    return EventType.REACTION_UPDATE
+
+
 def resolve_attach(frame: InboundFrame) -> EventType | None:
     try:
         FileUploadSignal.model_validate(frame.payload)
@@ -45,6 +61,8 @@ def resolve_message(frame: InboundFrame) -> EventType | None:
 
         if model.status == MessageStatus.EDITED:
             return EventType.MESSAGE_EDIT
+        if model.status == MessageStatus.REMOVED:
+            return EventType.MESSAGE_DELETE
         else:
             return EventType.MESSAGE_NEW
     except ValidationError:

pymax/dispatch/router.py

@@ -14,6 +14,12 @@ if TYPE_CHECKING:
     from pymax.protocol import InboundFrame
     from pymax.types import Chat
     from pymax.types.domain import Message
+    from pymax.types.events import (
+        MessageReadEvent,
+        PresenceEvent,
+        ReactionUpdateEvent,
+        TypingEvent,
+    )
 
 
 _EventT = TypeVar("_EventT")
@@ -186,6 +192,34 @@ class Router(Generic[ClientT]):
         """
         return self.on(EventType.MESSAGE_DELETE, *filters)
 
+    def on_message_read(
+        self,
+        *filters: FilterCallback[MessageReadEvent],
+    ) -> HandlerDecorator[MessageReadEvent, ClientT]:
+        """Регистрирует обработчик изменения отметки прочтения."""
+        return self.on(EventType.MESSAGE_READ, *filters)
+
+    def on_typing(
+        self,
+        *filters: FilterCallback[TypingEvent],
+    ) -> HandlerDecorator[TypingEvent, ClientT]:
+        """Регистрирует обработчик набора текста."""
+        return self.on(EventType.TYPING, *filters)
+
+    def on_presence(
+        self,
+        *filters: FilterCallback[PresenceEvent],
+    ) -> HandlerDecorator[PresenceEvent, ClientT]:
+        """Регистрирует обработчик изменения присутствия пользователя."""
+        return self.on(EventType.PRESENCE, *filters)
+
+    def on_reaction_update(
+        self,
+        *filters: FilterCallback[ReactionUpdateEvent],
+    ) -> HandlerDecorator[ReactionUpdateEvent, ClientT]:
+        """Регистрирует обработчик обновления реакций сообщения."""
+        return self.on(EventType.REACTION_UPDATE, *filters)
+
     def on_chat_update(
         self,
         *filters: FilterCallback[Chat],

pymax/files/photo.py

@@ -1,6 +1,7 @@
 import mimetypes
 from collections.abc import AsyncGenerator
 from pathlib import Path
+from urllib.parse import urlsplit
 
 from .base import BaseFile
 from .static import ALLOWED_EXTENSIONS
@@ -66,12 +67,13 @@ class Photo(BaseFile):
                 raise ValueError(msg)
             return (extension[1:], ("image/" + extension[1:]).lower())
         if self.url:
-            extension = Path(self.url).suffix.lower()
+            url_path = urlsplit(self.url).path
+            extension = Path(url_path).suffix.lower()
             if extension not in ALLOWED_EXTENSIONS:
                 msg = f"Invalid photo extension: {extension}. Allowed: {ALLOWED_EXTENSIONS}"
                 raise ValueError(msg)
 
-            mime_type = mimetypes.guess_type(self.url)[0]
+            mime_type = mimetypes.guess_type(url_path)[0]
 
             if not mime_type or not mime_type.startswith("image/"):
                 msg = f"URL does not appear to be an image: {self.url}"

pymax/formatting/markdown.py

@@ -2,6 +2,10 @@ from pymax.types.domain.element import Element, ElementAttributes
 
 
 class Formatter:
+    # Characters above this value are encoded as surrogate pairs in UTF-16,
+    # occupying 2 code units instead of 1.
+    BMP_MAX = 0xFFFF
+
     MARKERS = {
         "```": "CODE",
         "**": "STRONG",
@@ -14,6 +18,10 @@ class Formatter:
 
     MARKER_ORDER = ["```", "**", "__", "~~", "`", "_", "*"]
 
+    @staticmethod
+    def _code_units_len(text: str) -> int:
+        return len(text.encode("utf-16-le")) // 2
+
     @staticmethod
     def _parse_link(
         text: str,
@@ -64,15 +72,16 @@ class Formatter:
                 label, url, next_i = parsed_link
 
                 start = clean_pos
+                utf16_label_len = Formatter._code_units_len(label)
 
                 clean_text += label
-                clean_pos += len(label)
+                clean_pos += utf16_label_len
 
                 entities.append(
                     Element(
                         type="LINK",
                         from_=start,
-                        length=len(label),
+                        length=utf16_label_len,
                         attributes=ElementAttributes(url=url),
                     )
                 )
@@ -93,9 +102,10 @@ class Formatter:
                     start = clean_pos
 
                     while i < len(text) and text[i] != "\n":
-                        clean_text += text[i]
+                        ch = text[i]
+                        clean_text += ch
                         i += 1
-                        clean_pos += 1
+                        clean_pos += 2 if ord(ch) > Formatter.BMP_MAX else 1
 
                     length = clean_pos - start
 
@@ -123,9 +133,10 @@ class Formatter:
                 start = clean_pos
 
                 while i < len(text) and text[i] != "\n":
-                    clean_text += text[i]
+                    ch = text[i]
+                    clean_text += ch
                     i += 1
-                    clean_pos += 1
+                    clean_pos += 2 if ord(ch) > Formatter.BMP_MAX else 1
 
                 length = clean_pos - start
 
@@ -151,10 +162,7 @@ class Formatter:
                     if marker == "```":
                         closing_index = text.find(marker, i + marker_len)
 
-                        if (
-                            closing_index == -1
-                            or closing_index == i + marker_len
-                        ):
+                        if closing_index == -1 or closing_index == i + marker_len:
                             clean_text += marker
                             clean_pos += marker_len
                             i += marker_len
@@ -211,10 +219,11 @@ class Formatter:
                 line_start = False
                 continue
 
-            clean_text += text[i]
-            line_start = text[i] == "\n"
+            ch = text[i]
+            clean_text += ch
+            line_start = ch == "\n"
 
             i += 1
-            clean_pos += 1
+            clean_pos += 2 if ord(ch) > Formatter.BMP_MAX else 1
 
         return clean_text, entities

pymax/infra/chat.py

@@ -339,3 +339,15 @@ class ChatMixin(IClientProtocol):
             chat_id=chat_id,
             user_id=user_id,
         )
+
+    async def join_channel(self, link: str) -> Chat:
+        """Вступает в канал по ссылке.
+
+        Args:
+            link: Полная ссылка на канал, invite-ссылка или ее часть с
+                join-токеном Max.
+
+        Returns:
+            Канал, в который вступил клиент.
+        """
+        return await self._app.api.chats.join_channel(link=link)

pymax/infra/message.py

@@ -1,5 +1,5 @@
 from pymax.api.messages.enums import ItemType
-from pymax.api.messages.service import SendAttachments
+from pymax.api.messages.service import SendAttachment, SendAttachments
 from pymax.types import (
     FileRequest,
     Message,
@@ -43,6 +43,73 @@ class MessageMixin(IClientProtocol):
             notify=notify,
         )
 
+    async def get_message(
+        self,
+        chat_id: int,
+        message_id: int,
+    ) -> Message | None:
+        """Возвращает сообщение по ID.
+
+        Args:
+            chat_id: ID чата.
+            message_id: ID сообщения.
+
+        Returns:
+            Сообщение или ``None``, если сервер его не вернул.
+        """
+        return await self._app.api.messages.get_message(
+            chat_id=chat_id,
+            message_id=message_id,
+        )
+
+    async def get_messages(
+        self,
+        chat_id: int,
+        message_ids: list[int],
+    ) -> list[Message]:
+        """Возвращает сообщения по ID.
+
+        Args:
+            chat_id: ID чата.
+            message_ids: ID сообщений.
+
+        Returns:
+            Список найденных сообщений.
+        """
+        return await self._app.api.messages.get_messages(
+            chat_id=chat_id,
+            message_ids=message_ids,
+        )
+
+    async def edit_message(
+        self,
+        chat_id: int,
+        message_id: int,
+        text: str,
+        attachment: SendAttachment | None = None,
+        attachments: SendAttachments = None,
+    ) -> Message:
+        """Редактирует текст и вложения сообщения.
+
+        Args:
+            chat_id: ID чата.
+            message_id: ID сообщения.
+            text: Новый текст сообщения с поддержкой markdown.
+            attachment: Одно новое вложение.
+            attachments: Список новых вложений. Имеет приоритет над
+                ``attachment``.
+
+        Returns:
+            Отредактированное сообщение.
+        """
+        return await self._app.api.messages.edit_message(
+            chat_id=chat_id,
+            message_id=message_id,
+            text=text,
+            attachment=attachment,
+            attachments=attachments,
+        )
+
     async def fetch_history(
         self,
         chat_id: int,
@@ -236,11 +303,15 @@ class MessageMixin(IClientProtocol):
             message_id=message_id,
         )
 
-    async def read_message(self, message_id: int, chat_id: int) -> ReadState:
+    async def read_message(self, message_id: int | str, chat_id: int) -> ReadState:
         """Отмечает сообщение как прочитанное.
 
+        У Max различается wire-формат ``message_id`` для отметки прочтения:
+        TCP-клиент ожидает ``int``, WebSocket-клиент - ``str``.
+
         Args:
-            message_id: ID сообщения.
+            message_id: ID сообщения. Передавайте ``int`` для ``Client`` и
+                ``str`` для ``WebClient``.
             chat_id: ID чата.
 
         Returns: