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

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/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:

pymax/logging.py

@@ -85,6 +85,8 @@ def configure_logging(
            configure_logging("DEBUG", use_colors=False)
     """
     stream = stream or sys.stderr
+    if stream is None:
+        raise RuntimeError("No logging stream is available")
 
     if use_colors is None:
         use_colors = hasattr(stream, "isatty") and stream.isatty()

pymax/protocol/tcp/compression.py

@@ -1,7 +1,5 @@
 class Lz4BlockCompression:
-    def decompress(
-        self, src: bytes, max_output: int = 5 * 1024 * 1024
-    ) -> bytes:
+    def decompress(self, src: bytes, max_output: int = 5 * 1024 * 1024) -> bytes:
         dst = bytearray()
         pos = 0
 

pymax/protocol/tcp/framing.py

@@ -31,9 +31,7 @@ class TcpPacketFramer:
         if len(data) < self.HEADER_SIZE:
             return None
 
-        ver, cmd, seq, opcode, packed_len = self.HEADER_STRUCT.unpack_from(
-            data, 0
-        )
+        ver, cmd, seq, opcode, packed_len = self.HEADER_STRUCT.unpack_from(data, 0)
         flags = (packed_len >> 24) & 0xFF
         payload_len = packed_len & 0x00FFFFFF
 

pymax/protocol/ws/protocol.py

@@ -20,14 +20,8 @@ class WsProtocol(BaseProtocol):
             data = json.loads(raw)
             return InboundFrame.model_validate(data)
         except json.JSONDecodeError:
-            logger.debug(
-                "failed to decode websocket frame json", exc_info=True
-            )
-            return InboundFrame(
-                opcode=0, cmd=0, seq=None, payload=None, raw=None
-            )
+            logger.debug("failed to decode websocket frame json", exc_info=True)
+            return InboundFrame(opcode=0, cmd=0, seq=None, payload=None, raw=None)
         except ValidationError:
             logger.debug("failed to validate websocket frame", exc_info=True)
-            return InboundFrame(
-                opcode=0, cmd=0, seq=None, payload=None, raw=None
-            )
+            return InboundFrame(opcode=0, cmd=0, seq=None, payload=None, raw=None)

pymax/session/protocol.py

@@ -8,11 +8,7 @@ class StoreProtocol(Protocol):
     async def save_session(self, session_info: SessionInfo) -> None: ...
     async def update_token(self, old_token: str, new_token: str) -> None: ...
     async def load_session(self) -> SessionInfo | None: ...
-    async def load_session_by_device_id(
-        self, device_id: str
-    ) -> SessionInfo | None: ...
-    async def load_session_by_phone(
-        self, phone: str
-    ) -> SessionInfo | None: ...
+    async def load_session_by_device_id(self, device_id: str) -> SessionInfo | None: ...
+    async def load_session_by_phone(self, phone: str) -> SessionInfo | None: ...
     async def delete_session(self, token: str) -> None: ...
     async def close(self) -> None: ...

pymax/session/store.py

@@ -55,24 +55,12 @@ class SessionStore:
             )
             """
         )
-        await self._ensure_column(
-            conn, "mt_instance_id", "TEXT NOT NULL DEFAULT ''"
-        )
-        await self._ensure_column(
-            conn, "chats_sync", "INTEGER NOT NULL DEFAULT -1"
-        )
-        await self._ensure_column(
-            conn, "contacts_sync", "INTEGER NOT NULL DEFAULT -1"
-        )
-        await self._ensure_column(
-            conn, "drafts_sync", "INTEGER NOT NULL DEFAULT -1"
-        )
-        await self._ensure_column(
-            conn, "presence_sync", "INTEGER NOT NULL DEFAULT -1"
-        )
-        await self._ensure_column(
-            conn, "config_hash", "TEXT NOT NULL DEFAULT ''"
-        )
+        await self._ensure_column(conn, "mt_instance_id", "TEXT NOT NULL DEFAULT ''")
+        await self._ensure_column(conn, "chats_sync", "INTEGER NOT NULL DEFAULT -1")
+        await self._ensure_column(conn, "contacts_sync", "INTEGER NOT NULL DEFAULT -1")
+        await self._ensure_column(conn, "drafts_sync", "INTEGER NOT NULL DEFAULT -1")
+        await self._ensure_column(conn, "presence_sync", "INTEGER NOT NULL DEFAULT -1")
+        await self._ensure_column(conn, "config_hash", "TEXT NOT NULL DEFAULT ''")
         await conn.execute(
             """
             UPDATE sessions
@@ -93,9 +81,7 @@ class SessionStore:
             columns = {row["name"] for row in await cursor.fetchall()}
 
         if name not in columns:
-            await conn.execute(
-                f"ALTER TABLE sessions ADD COLUMN {name} {definition}"
-            )
+            await conn.execute(f"ALTER TABLE sessions ADD COLUMN {name} {definition}")
 
     async def save_session(self, session_info: SessionInfo) -> None:
         conn = await self._get_connection()
@@ -158,9 +144,7 @@ class SessionStore:
         )
         return self._row_to_session(row)
 
-    async def load_session_by_device_id(
-        self, device_id: str
-    ) -> SessionInfo | None:
+    async def load_session_by_device_id(self, device_id: str) -> SessionInfo | None:
         conn = await self._get_connection()
         logger.debug("loading session by device_id=%s", device_id)
         async with conn.execute(

pymax/telemetry/navigation.py

@@ -155,9 +155,7 @@ class NavigationPlanner:
             self.current_screen = self.history.pop()
             return self.current_screen
 
-        next_screen = self._weighted_choice(
-            self.rules.graph[self.current_screen]
-        )
+        next_screen = self._weighted_choice(self.rules.graph[self.current_screen])
         if next_screen != self.current_screen:
             self.history.append(self.current_screen)
             if len(self.history) > 4:

pymax/telemetry/service.py

@@ -82,20 +82,14 @@ class TelemetryService:
     async def _run(self) -> None:
         try:
             await asyncio.sleep(self._between(self._timing.startup_delay))
-            await self._send_events(
-                [self._payloads.login(self._user_id, self._session_id)]
-            )
+            await self._send_events([self._payloads.login(self._user_id, self._session_id)])
 
             while True:
                 self._session_id += 1
-                events = await self._collect_session_events(
-                    self._planner.new_profile()
-                )
+                events = await self._collect_session_events(self._planner.new_profile())
                 await self._send_events(events)
                 self._planner.reset_to_background()
-                await asyncio.sleep(
-                    self._between(self._timing.session_idle_delay)
-                )
+                await asyncio.sleep(self._between(self._timing.session_idle_delay))
 
         except asyncio.CancelledError:
             raise
@@ -163,9 +157,7 @@ class TelemetryService:
         except Exception:
             logger.debug("telemetry send failed", exc_info=True)
 
-    def _nav_event(
-        self, screen_from: Screen, screen_to: Screen
-    ) -> TelemetryEvent:
+    def _nav_event(self, screen_from: Screen, screen_to: Screen) -> TelemetryEvent:
         event = self._payloads.navigation(
             user_id=self._user_id,
             session_id=self._session_id,
@@ -212,11 +204,7 @@ class TelemetryService:
 
     @property
     def _ready(self) -> bool:
-        return (
-            self.app.started
-            and self.app.me is not None
-            and self.app.connection.is_open
-        )
+        return self.app.started and self.app.me is not None and self.app.connection.is_open
 
     @property
     def _user_id(self) -> int:

pymax/transport/tcp.py

@@ -10,9 +10,7 @@ logger = get_logger(__name__)
 
 
 class TCPTransport(Transport):
-    def __init__(
-        self, host: str, port: int, proxy: str | None, use_ssl: bool = True
-    ) -> None:
+    def __init__(self, host: str, port: int, proxy: str | None, use_ssl: bool = True) -> None:
         self._host = host
         self._port = port
         self._proxy = proxy