maxapi-python 1.1.17__py3-none-any.whl → 1.1.19__py3-none-any.whl

{maxapi_python-1.1.17.dist-info → maxapi_python-1.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.17
+Version: 1.1.19
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/ink-developer/PyMax
 Project-URL: Repository, https://github.com/ink-developer/PyMax

{maxapi_python-1.1.17.dist-info → maxapi_python-1.1.19.dist-info}/RECORD

@@ -1,31 +1,31 @@
 pymax/__init__.py,sha256=6wUKKwsyxFpWG3b7kwptOvHd-w78C-ygw42iCDBYQvc,1915
-pymax/core.py,sha256=uSmIYVBqiO-3v0wtehObnvOEJ3n_dpG62TXTKwmdFf4,13838
+pymax/core.py,sha256=QEERtU32ODmEIf1XFCDhD18a29yRW5TB97NjtusMUCg,15644
 pymax/crud.py,sha256=wmJh8MPi3L_HbYp7MJP0eXfDcnjgfkLDa9rHAmXtkow,3219
 pymax/exceptions.py,sha256=nDUNx7bM-Yjugj-qfIllcrnwLg9JpZroYqfXapjYbMQ,3178
 pymax/files.py,sha256=dRuOpvoJZWiH4xa_HVGyqQ-_Zzj-sVikElHmrPjwgs0,3166
 pymax/filters.py,sha256=4hehzyQlyxBxLiEhtSH_KQdFHx8gYaqyIOOD72EsSS0,1536
 pymax/formatter.py,sha256=OVsTwambHhXlOMd0wVECJWuB_S2wSEVKdMLCzgPcvYQ,859
 pymax/formatting.py,sha256=hhtmakfcQDzQRsAckPunnJOCKY2lFdLeIp8Yw53yY8s,2522
-pymax/interfaces.py,sha256=WWKNGT725GXuYneS9gCOAC6RNtySRs-BTU0fQLyh2OQ,3399
+pymax/interfaces.py,sha256=OqYTiTUs6HqTkx3I3CU34q-En8nLS1Rx2hRlmEq65V4,3643
 pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
 pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
-pymax/payloads.py,sha256=qaafULDGBXsQ7gNFC374wZVUwN5tzJLHwkxtAmglOzU,6292
+pymax/payloads.py,sha256=S1dJwDPanFfIdY_NlXN2epVyibmmL9bceltgLVmEtTA,6304
 pymax/types.py,sha256=RaLn9bUpkxO0SKbDMIHnoFeqV6gqOl2pKDNCa2LxTRI,32102
 pymax/mixins/__init__.py,sha256=xvjcq-lFVHCPss_t8xxXya0OJnsh-owlBqtUlrXSCcw,695
-pymax/mixins/auth.py,sha256=H4Zp3n8cwpv4Q3Mn1_Kb7Oh9DbTL7T9GcWJ6R1JN7ls,6672
+pymax/mixins/auth.py,sha256=zkMkALjvb2427g1DMcvUIKsOQgw1y8d-tEo3jlyNiWQ,6744
 pymax/mixins/channel.py,sha256=dMuJRnbqZisN8kcPFCCe1sIOOBQl2uT4P49PpZXcoKE,5206
 pymax/mixins/group.py,sha256=7oa7RpiqnlcnAsnIHOfSiujNYAzUZ9lkTy9NGW5KVUE,8654
-pymax/mixins/handler.py,sha256=AhxIRvwftkuWN435_CXede2ZVWrDde4zkMPZtwIm5IU,3892
+pymax/mixins/handler.py,sha256=TuO5bHK6qwJ-Wdh3lMg6uWaG6IwNPOUTCnMw2PkCFjA,5872
 pymax/mixins/message.py,sha256=ezU9d6r4MkYjH67gZ9SFLYPKqo4Nb6lswqDsEW5p-Bg,22329
 pymax/mixins/self.py,sha256=tDQrUdUpsCu7qGkWLtKxTfTHPHU5_r3qsn-eptHG2KY,1198
-pymax/mixins/socket.py,sha256=j6XTo_M3rNw-az2PfSW6oJ_YHg9M7cWARY4cXpMllDY,22256
+pymax/mixins/socket.py,sha256=VsQSDyzP2xvQp-V8SgeOBn3vVQfWwi0m_wMIvlzu2lY,25517
 pymax/mixins/telemetry.py,sha256=LWr68DNQkPhAjGRDYQ5lORXxC3Yw6M9E8sF0TCNISTE,3609
 pymax/mixins/user.py,sha256=5utoK7Z-7lySOg0PEO69b6h_3kjfcnV-YydTZIdNj8g,7120
 pymax/mixins/utils.py,sha256=s3FUf3i_wjn2Gbg5YY1rWZB-90ZEGrrcUuND_MqqSTE,853
-pymax/mixins/websocket.py,sha256=LaL-okzhJCyS3uWV7xsCCKnuff_rooKjAoZ8vkaintY,16817
+pymax/mixins/websocket.py,sha256=Rfn3PFfmey2u3e3xnebNeT9VoxBF9Dq20xM8ljaDiII,19286
 pymax/static/constant.py,sha256=Q1NrmaRj17Gdhk3FmUp3HIwrad1TDorq3wFdQlOCzN8,1027
 pymax/static/enum.py,sha256=c_QaLU0Ephe4SuKFIpwpmrf_HCutc34JJ6o4Ik1E6_g,4582
-maxapi_python-1.1.17.dist-info/METADATA,sha256=0gplAk5x9ujWD7fkCZu_yvwataKPPq3fMETJbwHb3HQ,6245
-maxapi_python-1.1.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-maxapi_python-1.1.17.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
-maxapi_python-1.1.17.dist-info/RECORD,,
+maxapi_python-1.1.19.dist-info/METADATA,sha256=2tRU1Um8ZR6LHzm83ze-bWs0V5FI6ru6DNYHbi4JBw8,6245
+maxapi_python-1.1.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+maxapi_python-1.1.19.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
+maxapi_python-1.1.19.dist-info/RECORD,,

pymax/core.py

@@ -7,7 +7,7 @@ import time
 import traceback
 from collections.abc import Awaitable
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any, Literal, Self
 
 from typing_extensions import override
 
@@ -29,7 +29,7 @@ if TYPE_CHECKING:
     import websockets
 
     from .filters import Filter
-    from .types import Channel, Chat, Dialog, Me, Message, User
+    from .types import Channel, Chat, Dialog, Me, Message, ReactionInfo, User
 
 
 logger = logging.getLogger(__name__)
@@ -143,6 +143,10 @@ class MaxClient(ApiMixin, WebSocketMixin):
             tuple[Callable[[Message], Any], Filter | None]
         ] = []
         self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
+        self._on_reaction_change_handlers: list[
+            tuple[Callable[[str, int, ReactionInfo], Any]]
+        ] = []
+        self._on_chat_update_handlers: list[tuple[Callable[[Chat], Any]]] = []
 
         self._ssl_context = ssl.create_default_context()
         self._ssl_context.set_ciphers("DEFAULT")
@@ -232,6 +236,97 @@ class MaxClient(ApiMixin, WebSocketMixin):
         self._background_tasks.add(task)
         return task
 
+    async def _post_login_tasks(self, sync: bool = True) -> None:
+        if sync:
+            await self._sync()
+
+        if self._on_start_handler:
+            self.logger.debug("Calling on_start handler")
+            result = self._on_start_handler()
+            if asyncio.iscoroutine(result):
+                await self._safe_execute(result, context="on_start handler")
+
+        ping_task = asyncio.create_task(self._send_interactive_ping())
+        ping_task.add_done_callback(self._log_task_exception)
+        self._background_tasks.add(ping_task)
+
+        if self._send_fake_telemetry:
+            telemetry_task = asyncio.create_task(self._start())
+            telemetry_task.add_done_callback(self._log_task_exception)
+            self._background_tasks.add(telemetry_task)
+
+    async def _cleanup_client(self):
+        for task in list(self._background_tasks):
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                self.logger.debug(
+                    "Background task raised during cancellation", exc_info=True
+                )
+            self._background_tasks.discard(task)
+
+        if self._recv_task:
+            self._recv_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._recv_task
+            self._recv_task = None
+
+        if self._outgoing_task:
+            self._outgoing_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._outgoing_task
+            self._outgoing_task = None
+
+        for fut in self._pending.values():
+            if not fut.done():
+                fut.set_exception(WebSocketNotConnectedError)
+        self._pending.clear()
+
+        if self._ws:
+            try:
+                await self._ws.close()
+            except Exception:
+                self.logger.debug("Error closing ws during cleanup", exc_info=True)
+            self._ws = None
+
+        self.is_connected = False
+        self.logger.info("Client start() cleaned up")
+
+    async def login_with_code(
+        self, temp_token: str, code: str, start: bool = False
+    ) -> None:
+        """
+        Завершает кастомный login flow: отправляет код, сохраняет токен и запускает пост-логин задачи.
+
+        Args:
+            temp_token (str): Временный токен, полученный из request_code()
+            code (str): Код, введённый пользователем
+
+        Returns:
+            str: Токен для входа
+        """
+        resp = await self._send_code(code, temp_token)
+        token = resp.get("tokenAttrs", {}).get("LOGIN", {}).get("token")
+        self._token = token
+        self._database.update_auth_token(self._device_id, token)
+        if start:
+            while True:
+                try:
+                    await self._post_login_tasks()
+                    await self._wait_forever()
+                except Exception:
+                    self.logger.exception("Error during post-login tasks")
+                finally:
+                    await self._cleanup_client()
+
+                self.logger.info("Reconnecting after post-login tasks failure")
+                await asyncio.sleep(self.reconnect_delay)
+        else:
+            self.logger.info("Login successful, token saved to database, exiting...")
+
     async def start(self) -> None:
         """
         Запускает клиент, подключается к WebSocket, авторизует
@@ -242,7 +337,7 @@ class MaxClient(ApiMixin, WebSocketMixin):
         while True:
             try:
                 self.logger.info("Client starting")
-                await self._connect(self.user_agent)
+                await self.connect(self.user_agent)
 
                 if self.registration:
                     if not self.first_name:
@@ -257,70 +352,19 @@ class MaxClient(ApiMixin, WebSocketMixin):
                 else:
                     await self._sync()
 
-                if self._on_start_handler:
-                    self.logger.debug("Calling on_start handler")
-                    result = self._on_start_handler()
-                    if asyncio.iscoroutine(result):
-                        await self._safe_execute(result, context="on_start handler")
-
-                ping_task = asyncio.create_task(self._send_interactive_ping())
-                ping_task.add_done_callback(self._log_task_exception)
-                self._background_tasks.add(ping_task)
-
-                if self._send_fake_telemetry:
-                    telemetry_task = asyncio.create_task(self._start())
-                    telemetry_task.add_done_callback(self._log_task_exception)
-                    self._background_tasks.add(telemetry_task)
+                await self._post_login_tasks(sync=False)
 
                 await self._wait_forever()
                 self.logger.info("WebSocket closed (wait_forever exited)")
 
-            except Exception:
+            except Exception as e:
                 self.logger.exception("Client start iteration failed")
+                raise e
 
             finally:
                 self.logger.debug("Cleaning up background tasks and pending futures")
 
-                for task in list(self._background_tasks):
-                    task.cancel()
-                    try:
-                        await task
-                    except asyncio.CancelledError:
-                        pass
-                    except Exception:
-                        self.logger.debug(
-                            "Background task raised during cancellation", exc_info=True
-                        )
-                    self._background_tasks.discard(task)
-
-                if self._recv_task:
-                    self._recv_task.cancel()
-                    with contextlib.suppress(asyncio.CancelledError):
-                        await self._recv_task
-                    self._recv_task = None
-
-                if self._outgoing_task:
-                    self._outgoing_task.cancel()
-                    with contextlib.suppress(asyncio.CancelledError):
-                        await self._outgoing_task
-                    self._outgoing_task = None
-
-                for fut in self._pending.values():
-                    if not fut.done():
-                        fut.set_exception(WebSocketNotConnectedError)
-                self._pending.clear()
-
-                if self._ws:
-                    try:
-                        await self._ws.close()
-                    except Exception:
-                        self.logger.debug(
-                            "Error closing ws during cleanup", exc_info=True
-                        )
-                    self._ws = None
-
-                self.is_connected = False
-                self.logger.info("Client start() cleaned up")
+                await self._cleanup_client()
 
             if not self.reconnect:
                 self.logger.info("Reconnect disabled — exiting start()")
@@ -329,6 +373,18 @@ class MaxClient(ApiMixin, WebSocketMixin):
             self.logger.info("Reconnect enabled — restarting client")
             await asyncio.sleep(self.reconnect_delay)
 
+    async def idle(self):
+        await asyncio.Event().wait()
+
+    async def __aenter__(self) -> Self:
+        self._create_safe_task(self.start(), name="start")
+        while not self.is_connected:
+            await asyncio.sleep(0.05)
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.close()
+
 
 class SocketMaxClient(SocketMixin, MaxClient):
     @override

pymax/interfaces.py

@@ -18,6 +18,8 @@ from .types import Channel, Chat, Dialog, Me, Message, User
 if TYPE_CHECKING:
     from uuid import UUID
 
+    from pymax.types import ReactionInfo
+
     from .crud import Database
 
 
@@ -69,6 +71,10 @@ class ClientProtocol(ABC):
         self._on_message_delete_handlers: list[
             tuple[Callable[[Message], Any], Filter | None]
         ] = []
+        self._on_reaction_change_handlers: list[
+            tuple[Callable[[str, int, ReactionInfo], Any]]
+        ] = []
+        self._on_chat_update_handlers: list[tuple[Callable[[Chat], Any]]] = []
         self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
         self._background_tasks: set[asyncio.Task[Any]] = set()
         self._ssl_context: ssl.SSLContext

pymax/mixins/auth.py

@@ -15,71 +15,73 @@ class AuthMixin(ClientProtocol):
     def _check_phone(self) -> bool:
         return bool(re.match(PHONE_REGEX, self.phone))
 
-    async def _request_code(
-        self, phone: str, language: str = "ru"
-    ) -> dict[str, int | str]:
-        try:
-            self.logger.info("Requesting auth code")
+    async def request_code(self, phone: str, language: str = "ru") -> str:
+        """
+        Запрашивает код аутентификации для указанного номера телефона и возвращает временный токен.
 
-            payload = RequestCodePayload(
-                phone=phone, type=AuthType.START_AUTH, language=language
-            ).model_dump(by_alias=True)
+        Note:
+            Использовать только в кастомном login flow.
 
-            data = await self._send_and_wait(
-                opcode=Opcode.AUTH_REQUEST, payload=payload
-            )
-            if data.get("payload", {}).get("error"):
-                MixinsUtils.handle_error(data)
+        Args:
+            phone (str): Номер телефона в международном формате.
+            language (str, optional): Язык для сообщения с кодом. По умолчанию "ru".
 
-            self.logger.debug(
-                "Code request response opcode=%s seq=%s",
-                data.get("opcode"),
-                data.get("seq"),
-            )
-            payload_data = data.get("payload")
-            if isinstance(payload_data, dict):
-                return payload_data
-            else:
-                self.logger.error("Invalid payload data received")
-                raise ValueError("Invalid payload data received")
-        except Exception:
-            self.logger.error("Request code failed", exc_info=True)
-            raise RuntimeError("Request code failed")
+        Returns:
+            str: Временный токен для дальнейшей аутентификации.
+        """
+        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)
+
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
+
+        self.logger.debug(
+            "Code request response opcode=%s seq=%s",
+            data.get("opcode"),
+            data.get("seq"),
+        )
+        payload_data = data.get("payload")
+        if isinstance(payload_data, dict):
+            return payload_data["token"]
+        else:
+            self.logger.error("Invalid payload data received")
+            raise ValueError("Invalid payload data received")
 
     async def _send_code(self, code: str, token: str) -> dict[str, Any]:
-        try:
-            self.logger.info("Sending verification code")
+        self.logger.info("Sending verification code")
 
-            payload = SendCodePayload(
-                token=token,
-                verify_code=code,
-                auth_token_type=AuthType.CHECK_CODE,
-            ).model_dump(by_alias=True)
+        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)
-            if data.get("payload", {}).get("error"):
-                MixinsUtils.handle_error(data)
+        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"),
-            )
-            payload_data = data.get("payload")
-            if isinstance(payload_data, dict):
-                return payload_data
-            else:
-                self.logger.error("Invalid payload data received")
-                raise ValueError("Invalid payload data received")
-        except Exception:
-            self.logger.error("Send code failed", exc_info=True)
-            raise RuntimeError("Send code failed")
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
+
+        self.logger.debug(
+            "Send code response opcode=%s seq=%s",
+            data.get("opcode"),
+            data.get("seq"),
+        )
+        payload_data = data.get("payload")
+        if isinstance(payload_data, dict):
+            return payload_data
+        else:
+            self.logger.error("Invalid payload data received")
+            raise ValueError("Invalid payload data received")
 
     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")
+        temp_token = await self.request_code(self.phone)
         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")
@@ -136,7 +138,7 @@ class AuthMixin(ClientProtocol):
     async def _register(self, first_name: str, last_name: str | None = None) -> None:
         self.logger.info("Starting registration flow")
 
-        request_code_payload = await self._request_code(self.phone)
+        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):

pymax/mixins/handler.py

@@ -2,7 +2,7 @@ from collections.abc import Awaitable, Callable
 from typing import Any
 
 from pymax.interfaces import ClientProtocol, Filter
-from pymax.types import Message
+from pymax.types import Chat, Message, ReactionInfo
 
 
 class HandlerMixin(ClientProtocol):
@@ -85,6 +85,39 @@ class HandlerMixin(ClientProtocol):
 
         return decorator
 
+    def on_reaction_change(
+        self,
+        handler: Callable[[str, int, ReactionInfo], Any | Awaitable[Any]],
+    ) -> Callable[[str, int, ReactionInfo], Any | Awaitable[Any]]:
+        """
+        Устанавливает обработчик изменения реакций на сообщения.
+
+        Args:
+            handler: Функция или coroutine с аргументами (message_id: str, chat_id: int, reaction_info: ReactionInfo).
+
+        Returns:
+            Установленный обработчик.
+        """
+        self._on_reaction_change_handlers.append((handler,))
+        self.logger.debug("on_reaction_change handler set: %r", handler)
+        return handler
+
+    def on_chat_update(
+        self, handler: Callable[[Chat], Any | Awaitable[Any]]
+    ) -> Callable[[Chat], Any | Awaitable[Any]]:
+        """
+        Устанавливает обработчик обновления информации о чате.
+
+        Args:
+            handler: Функция или coroutine с аргументом (chat: Chat).
+
+        Returns:
+            Установленный обработчик.
+        """
+        self._on_chat_update_handlers.append((handler,))
+        self.logger.debug("on_chat_update handler set: %r", handler)
+        return handler
+
     def on_start(
         self, handler: Callable[[], Any | Awaitable[Any]]
     ) -> Callable[[], Any | Awaitable[Any]]:
@@ -116,3 +149,18 @@ class HandlerMixin(ClientProtocol):
         self.logger.debug("add_on_start_handler (alias) used")
         self._on_start_handler = handler
         return handler
+
+    def add_reaction_change_handler(
+        self,
+        handler: Callable[[str, int, ReactionInfo], Any | Awaitable[Any]],
+    ) -> Callable[[str, int, ReactionInfo], Any | Awaitable[Any]]:
+        self.logger.debug("add_reaction_change_handler (alias) used")
+        self._on_reaction_change_handlers.append((handler,))
+        return handler
+
+    def add_chat_update_handler(
+        self, handler: Callable[[Chat], Any | Awaitable[Any]]
+    ) -> Callable[[Chat], Any | Awaitable[Any]]:
+        self.logger.debug("add_chat_update_handler (alias) used")
+        self._on_chat_update_handlers.append((handler,))
+        return handler

pymax/mixins/socket.py

@@ -11,7 +11,7 @@ import msgpack
 from typing_extensions import override
 
 from pymax.exceptions import Error, SocketNotConnectedError, SocketSendError
-from pymax.filters import Filter, Message
+from pymax.filters import Filter
 from pymax.interfaces import ClientProtocol
 from pymax.payloads import BaseWebSocketMessage, SyncPayload, UserAgentPayload
 from pymax.static.constant import (
@@ -19,8 +19,16 @@ from pymax.static.constant import (
     DEFAULT_TIMEOUT,
     RECV_LOOP_BACKOFF_DELAY,
 )
-from pymax.static.enum import MessageStatus, Opcode
-from pymax.types import Channel, Chat, Dialog, Me
+from pymax.static.enum import ChatType, MessageStatus, Opcode
+from pymax.types import (
+    Channel,
+    Chat,
+    Dialog,
+    Me,
+    Message,
+    ReactionCounter,
+    ReactionInfo,
+)
 
 
 class SocketMixin(ClientProtocol):
@@ -276,6 +284,67 @@ Socket connections may be unstable, SSL issues are possible.
                                         )
                             except Exception:
                                 self.logger.exception("Error in on_message_handler")
+
+                        if (
+                            data_item.get("opcode")
+                            == Opcode.NOTIF_MSG_REACTIONS_CHANGED
+                        ):
+                            try:
+                                for (
+                                    reaction_handler,
+                                ) in self._on_reaction_change_handlers:
+                                    payload = data_item.get("payload", {})
+
+                                    chat_id = payload.get("chatId")
+                                    message_id = payload.get("messageId")
+
+                                    total_count = payload.get("totalCount")
+                                    your_reaction = payload.get("yourReaction")
+                                    counters = [
+                                        ReactionCounter.from_dict(c)
+                                        for c in payload.get("counters", [])
+                                    ]
+
+                                    if (
+                                        chat_id
+                                        and message_id
+                                        and (
+                                            total_count is not None
+                                            or your_reaction
+                                            or counters
+                                        )
+                                    ):
+                                        reaction_info = ReactionInfo(
+                                            total_count=total_count,
+                                            your_reaction=your_reaction,
+                                            counters=counters,
+                                        )
+                                        result = reaction_handler(
+                                            message_id, chat_id, reaction_info
+                                        )
+                                        if asyncio.iscoroutine(result):
+                                            await result
+
+                            except Exception as e:
+                                self.logger.exception(
+                                    "Error in on_reaction_change_handler: %s", e
+                                )
+
+                        if data_item.get("opcode") == Opcode.NOTIF_CHAT:
+                            try:
+                                for (
+                                    chat_update_handler,
+                                ) in self._on_chat_update_handlers:
+                                    payload = data_item.get("payload", {})
+                                    chat = Chat.from_dict(payload.get("chat", {}))
+                                    if chat:
+                                        result = chat_update_handler(chat)
+                                        if asyncio.iscoroutine(result):
+                                            await result
+                            except Exception as e:
+                                self.logger.exception(
+                                    "Error in on_chat_update_handler: %s", e
+                                )
                 except asyncio.CancelledError:
                     self.logger.debug("Recv loop cancelled")
                     break

pymax/mixins/websocket.py

@@ -10,6 +10,7 @@ from typing_extensions import override
 from pymax.exceptions import LoginError, WebSocketNotConnectedError
 from pymax.filters import Filter
 from pymax.interfaces import ClientProtocol
+from pymax.mixins.utils import MixinsUtils
 from pymax.payloads import BaseWebSocketMessage, SyncPayload, UserAgentPayload
 from pymax.static.constant import (
     DEFAULT_PING_INTERVAL,
@@ -18,7 +19,15 @@ from pymax.static.constant import (
     WEBSOCKET_ORIGIN,
 )
 from pymax.static.enum import ChatType, MessageStatus, Opcode
-from pymax.types import Channel, Chat, Dialog, Me, Message
+from pymax.types import (
+    Channel,
+    Chat,
+    Dialog,
+    Me,
+    Message,
+    ReactionCounter,
+    ReactionInfo,
+)
 
 
 class WebSocketMixin(ClientProtocol):
@@ -59,45 +68,54 @@ class WebSocketMixin(ClientProtocol):
                 self.logger.warning("Interactive ping failed", exc_info=True)
             await asyncio.sleep(DEFAULT_PING_INTERVAL)
 
-    async def _connect(self, user_agent: UserAgentPayload) -> dict[str, Any]:
-        try:
-            self.logger.info("Connecting to WebSocket %s", self.uri)
-            self._ws = await websockets.connect(
-                self.uri,
-                origin=WEBSOCKET_ORIGIN,
-                user_agent_header=user_agent.header_user_agent,
-                proxy=self.proxy,
-            )
-            self.is_connected = True
-            self._incoming = asyncio.Queue()
-            self._outgoing = asyncio.Queue()
-            self._pending = {}
-            self._recv_task = asyncio.create_task(self._recv_loop())
-            self._outgoing_task = asyncio.create_task(self._outgoing_loop())
-            self.logger.info("WebSocket connected, starting handshake")
-            return await self._handshake(user_agent)
-        except Exception as e:
-            self.logger.error("Failed to connect: %s", e, exc_info=True)
-            raise ConnectionError(f"Failed to connect: {e}")
+    async def connect(
+        self, user_agent: UserAgentPayload | None = None
+    ) -> dict[str, Any] | None:
+        """
+        Устанавливает соединение WebSocket с сервером и выполняет handshake.
+        """
+        if user_agent is None:
+            user_agent = UserAgentPayload()
+
+        self.logger.info("Connecting to WebSocket %s", self.uri)
+
+        if self._ws is not None or self.is_connected:
+            self.logger.warning("WebSocket already connected")
+            return
+
+        self._ws = await websockets.connect(
+            self.uri,
+            origin=WEBSOCKET_ORIGIN,
+            user_agent_header=user_agent.header_user_agent,
+            proxy=self.proxy,
+        )
+        self.is_connected = True
+        self._incoming = asyncio.Queue()
+        self._outgoing = asyncio.Queue()
+        self._pending = {}
+        self._recv_task = asyncio.create_task(self._recv_loop())
+        self._outgoing_task = asyncio.create_task(self._outgoing_loop())
+        self.logger.info("WebSocket connected, starting handshake")
+        return await self._handshake(user_agent)
 
     async def _handshake(self, user_agent: UserAgentPayload) -> dict[str, Any]:
-        try:
-            self.logger.debug(
-                "Sending handshake with user_agent keys=%s",
-                user_agent.model_dump().keys(),
-            )
-            resp = await self._send_and_wait(
-                opcode=Opcode.SESSION_INIT,
-                payload={
-                    "deviceId": str(self._device_id),
-                    "userAgent": user_agent,
-                },
-            )
-            self.logger.info("Handshake completed")
-            return resp
-        except Exception as e:
-            self.logger.error("Handshake failed: %s", e, exc_info=True)
-            raise ConnectionError(f"Handshake failed: {e}")
+        self.logger.debug(
+            "Sending handshake with user_agent keys=%s",
+            user_agent.model_dump().keys(),
+        )
+        resp = await self._send_and_wait(
+            opcode=Opcode.SESSION_INIT,
+            payload={
+                "deviceId": str(self._device_id),
+                "userAgent": user_agent,  # TODO: вынести в статик мб
+            },
+        )
+
+        if resp.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(resp)
+
+        self.logger.info("Handshake completed")
+        return resp
 
     async def _process_message_handler(
         self,
@@ -130,7 +148,6 @@ class WebSocketMixin(ClientProtocol):
                 except Exception:
                     self.logger.warning("JSON parse error", exc_info=True)
                     continue
-
                 seq = data.get("seq")
                 fut = self._pending.get(seq) if isinstance(seq, int) else None
 
@@ -161,9 +178,10 @@ class WebSocketMixin(ClientProtocol):
                     except Exception:
                         self.logger.exception("Error handling file upload notification")
 
-                    if (
-                        data.get("opcode") == Opcode.NOTIF_MESSAGE.value
-                        and self._on_message_handlers
+                    if data.get("opcode") == Opcode.NOTIF_MESSAGE.value and (
+                        self._on_message_handlers
+                        or self._on_message_edit_handlers
+                        or self._on_message_delete_handlers
                     ):
                         try:
                             for handler, filter in self._on_message_handlers:
@@ -197,6 +215,62 @@ class WebSocketMixin(ClientProtocol):
                         except Exception:
                             self.logger.exception("Error in on_message_handler")
 
+                    if data.get("opcode") == Opcode.NOTIF_MSG_REACTIONS_CHANGED:
+                        try:
+                            for (
+                                reaction_handler,
+                            ) in self._on_reaction_change_handlers:
+                                payload = data.get("payload", {})
+
+                                chat_id = payload.get("chatId")
+                                message_id = payload.get("messageId")
+
+                                total_count = payload.get("totalCount")
+                                your_reaction = payload.get("yourReaction")
+                                counters = [
+                                    ReactionCounter.from_dict(c)
+                                    for c in payload.get("counters", [])
+                                ]
+
+                                if (
+                                    chat_id
+                                    and message_id
+                                    and (
+                                        total_count is not None
+                                        or your_reaction
+                                        or counters
+                                    )
+                                ):
+                                    reaction_info = ReactionInfo(
+                                        total_count=total_count,
+                                        your_reaction=your_reaction,
+                                        counters=counters,
+                                    )
+                                    result = reaction_handler(
+                                        message_id, chat_id, reaction_info
+                                    )
+                                    if asyncio.iscoroutine(result):
+                                        await result
+
+                        except Exception as e:
+                            self.logger.exception(
+                                "Error in on_reaction_change_handler: %s", e
+                            )
+
+                    if data.get("opcode") == Opcode.NOTIF_CHAT:
+                        try:
+                            for (chat_update_handler,) in self._on_chat_update_handlers:
+                                payload = data.get("payload", {})
+                                chat = Chat.from_dict(payload.get("chat", {}))
+                                if chat:
+                                    result = chat_update_handler(chat)
+                                    if asyncio.iscoroutine(result):
+                                        await result
+                        except Exception as e:
+                            self.logger.exception(
+                                "Error in on_chat_update_handler: %s", e
+                            )
+
             except websockets.exceptions.ConnectionClosed:
                 self.logger.info("WebSocket connection closed; exiting recv loop")
                 for fut in self._pending.values():
@@ -371,28 +445,12 @@ class WebSocketMixin(ClientProtocol):
             drafts_sync=0,
             chats_count=40,
         ).model_dump(by_alias=True)
-
         try:
             data = await self._send_and_wait(opcode=Opcode.LOGIN, payload=payload)
             raw_payload = data.get("payload", {})
 
             if error := raw_payload.get("error"):
-                self.logger.error("Sync error: %s", error)
-
-                if error == "login.token":
-                    if self._ws:
-                        await self._ws.close()
-                    self.is_connected = False
-                    self._ws = None
-                    self._recv_task = None
-                    raise LoginError(
-                        raw_payload.get("error", "unknown"),
-                        raw_payload.get("message", "No message provided"),
-                        raw_payload.get("title", "Login Error"),
-                        raw_payload.get("localizedMessage"),
-                    )
-
-                return
+                MixinsUtils.handle_error(data)
 
             for raw_chat in raw_payload.get("chats", []):
                 try:

pymax/payloads.py

@@ -1,4 +1,4 @@
-from typing import Any, Final, Literal
+from typing import Any, Literal
 
 from pydantic import AliasChoices, BaseModel, Field
 
@@ -30,7 +30,7 @@ class CamelModel(BaseModel):
 
 
 class BaseWebSocketMessage(BaseModel):
-    ver: Final[int] = 11
+    ver: Literal[10, 11] = 11
     cmd: int
     seq: int
     opcode: int
@@ -195,14 +195,14 @@ class ChangeGroupProfilePayload(CamelModel):
 
 
 class GetGroupMembersPayload(CamelModel):
-    type: Final[str] = "MEMBER"
+    type: Literal["MEMBER"] = "MEMBER"
     marker: int
     chat_id: int
     count: int
 
 
 class SearchGroupMembersPayload(CamelModel):
-    type: Final[str] = "MEMBER"
+    type: Literal["MEMBER"] = "MEMBER"
     query: str
     chat_id: int