maxapi-python 1.1.21__py3-none-any.whl → 1.2.2__py3-none-any.whl

{maxapi_python-1.1.21.dist-info → maxapi_python-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.21
+Version: 1.2.2
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/ink-developer/PyMax
 Project-URL: Repository, https://github.com/ink-developer/PyMax
@@ -16,8 +16,16 @@ Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: aiohttp>=3.12.15
 Requires-Dist: lz4>=4.4.4
 Requires-Dist: msgpack>=1.1.1
+Requires-Dist: qrcode>=8.2
 Requires-Dist: sqlmodel>=0.0.24
 Requires-Dist: websockets>=15.0
+Provides-Extra: test
+Requires-Dist: flake8; extra == 'test'
+Requires-Dist: mypy; extra == 'test'
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'test'
+Requires-Dist: pytest-cov>=5.0.0; extra == 'test'
+Requires-Dist: pytest-timeout>=2.1.0; extra == 'test'
+Requires-Dist: pytest>=8.0.0; extra == 'test'
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -35,6 +43,7 @@ Description-Content-Type: text/markdown
     <img src="https://img.shields.io/badge/packaging-uv-D7FF64.svg" alt="Packaging">
 </p>
 
+
 ---
 > ⚠️ **Дисклеймер**
 >
@@ -75,6 +84,41 @@ uv add -U maxapi-python
 
 ## Быстрый старт
 
+### Аутентификация (`device_type`)
+
+> [!IMPORTANT]
+> Параметр `device_type` в `UserAgentPayload` **критически важен** для выбора способа авторизации:
+
+**Вход по номеру телефона (DESKTOP):**
+
+```python
+from pymax import MaxClient
+from pymax.payloads import UserAgentPayload
+
+ua = UserAgentPayload(device_type="DESKTOP", app_version="25.12.13")
+
+client = MaxClient(
+    phone="+79111111111",
+    work_dir="cache",
+    headers=ua,
+)
+```
+
+**Вход через QR-код (WEB)** — токен совместим с веб-версией Max:
+
+```python
+from pymax import MaxClient
+from pymax.payloads import UserAgentPayload
+
+ua = UserAgentPayload(device_type="WEB", app_version="25.12.13")
+
+client = MaxClient(
+    phone="+7911111111",
+    work_dir="cache",
+    headers=ua,
+)
+```
+
 ### Базовый пример использования
 
 ```python

{maxapi_python-1.1.21.dist-info → maxapi_python-1.2.2.dist-info}/RECORD

@@ -1,32 +1,32 @@
 pymax/__init__.py,sha256=6wUKKwsyxFpWG3b7kwptOvHd-w78C-ygw42iCDBYQvc,1915
-pymax/core.py,sha256=aF-nGQG92KV9ZBIXWTxl2mpyfXgmZ2OQq2-OnouB2O4,19720
-pymax/crud.py,sha256=uphxDTCj1tGCrQ1lE2osLIZY7WLWbS-pkG46i2pU8Z0,3075
+pymax/core.py,sha256=OXGNaQ0pDaf6Ofr1Fb9m7vh5ffpbiMyvUMM0EfwlnIQ,14907
+pymax/crud.py,sha256=YC92TyhA2mr1tJCcfd-tvh8umtXKgqJfgiLo7nXUl3Q,3076
 pymax/exceptions.py,sha256=nDUNx7bM-Yjugj-qfIllcrnwLg9JpZroYqfXapjYbMQ,3178
 pymax/files.py,sha256=AvFIr34Desq2p4CNWXIngRqeyTBKMT98VmcnI-zvUU0,3462
 pymax/filters.py,sha256=gSHPJ1Vi37HKPxf0jRRv9Q3iGwhiQjw1MGrCaouqHzs,4325
 pymax/formatter.py,sha256=RJ_5VbY7Li8UM3xL1AvcXo8v1iYnY8GvDDkreaFqtnY,860
-pymax/formatting.py,sha256=hhtmakfcQDzQRsAckPunnJOCKY2lFdLeIp8Yw53yY8s,2522
-pymax/interfaces.py,sha256=2wdS5BfguU9zH3yLSGBWtSq0_SWwcSVLHSd1Z4ZIS2g,4003
+pymax/formatting.py,sha256=XRtuXJGweuNZevJFdPxksDftIrfuMGEA-AOUc_v6IhQ,2484
+pymax/interfaces.py,sha256=wKF1z1QRw8LcjvM9rzSHWXTK6gPb6sDt2UGiQLvyMf8,8790
 pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
 pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
-pymax/payloads.py,sha256=-GEJVXXlmJiFSTX4ToVNzmSZSrvSRe-BLOwYyRxGkWY,7280
+pymax/payloads.py,sha256=GuTLK6HYe_bLW3ardgpKeZ98f79j349tD_6B6EwkGww,7879
 pymax/types.py,sha256=_ARcVXLGHyiGAJKYPd6EU9QDKzz4VwS6kjTu3YEH_u4,35523
 pymax/mixins/__init__.py,sha256=5sXJME34S1EssuDETaN4DLRH7vhMw_Q3Jmay9myAIZM,775
-pymax/mixins/auth.py,sha256=zErX2vItVwHV8rAKWXX74dEEYSlECr2oYmnzEzw86eM,9661
+pymax/mixins/auth.py,sha256=e90vIpEOwAjUxgYMYaG7R6jR_5t9rKsei_mTBQUirL4,14716
 pymax/mixins/channel.py,sha256=W52YnBay1sUYXxF9oAWsz44ZUh_s45jSvKmAyjTbULM,5357
 pymax/mixins/group.py,sha256=LqI1QHmZlmtuQ0-4H1MrNeBV-O9SMDMfHT9f4B_2poE,15189
 pymax/mixins/handler.py,sha256=ETnI8fA386LYJGjWtUhhWzQHREUA78di1aO1oWwtscA,12523
 pymax/mixins/message.py,sha256=AznKKmTMxdzsYl8IecT43RjWpGvlQM85GzSNGFbI8BA,33279
 pymax/mixins/scheduler.py,sha256=rcMfgfZnzu5V6MkcCg6uRgbi-jkc7UyqOjemulydWbc,964
 pymax/mixins/self.py,sha256=Be5L64eNYylGM-NmoxFpQZv1ohsC1Dx_Cs3Om__V96s,6976
-pymax/mixins/socket.py,sha256=9_TtTzB1mXH2U-odtwvOEXViUOCzPXBgTEXbMckhiq4,23122
+pymax/mixins/socket.py,sha256=tdHgd1NwWoEZhHCDd74XLOHFKUq-rladxhXV8Z_-APU,22860
 pymax/mixins/telemetry.py,sha256=LWr68DNQkPhAjGRDYQ5lORXxC3Yw6M9E8sF0TCNISTE,3609
 pymax/mixins/user.py,sha256=RSZd4t-aq8P2k3cVzNVWBkUf-_xTWILrBzwxLRgk1pw,9450
 pymax/mixins/utils.py,sha256=s3FUf3i_wjn2Gbg5YY1rWZB-90ZEGrrcUuND_MqqSTE,853
-pymax/mixins/websocket.py,sha256=m2swhSHIcFG6iABAik_oWxIpHfr0sxZ74I6VRU-iVO8,17809
-pymax/static/constant.py,sha256=BjSb2G6CTN6Idpo5GeLa-07YodnLNycYDmI7nOk0YGs,1111
-pymax/static/enum.py,sha256=Lf_qHbA2e2oK7X2uuiXInvaV1ql6hX-4wypFnokaazM,4584
-maxapi_python-1.1.21.dist-info/METADATA,sha256=_VPALryggwzxWHAcYKsKSb4rP094y1PmLEFKIOFolRs,5560
-maxapi_python-1.1.21.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-maxapi_python-1.1.21.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
-maxapi_python-1.1.21.dist-info/RECORD,,
+pymax/mixins/websocket.py,sha256=GpdboEVWzyN1qLTcsgKZym6TlPnklcQuNeXJ5YKwg8c,17724
+pymax/static/constant.py,sha256=nM0svv3VpsVxK-RqoADn9qsTdQvB-IYv0Sgv-bQcWs4,1116
+pymax/static/enum.py,sha256=Hk0e6zSbGOJC_9Aw7gNXX3hcavnjzQfDyr8vjW22cFo,4648
+maxapi_python-1.2.2.dist-info/METADATA,sha256=rgiQKdSqYAO743n6jWOy0F76jZyjaGMY7A6qUlHlk64,6753
+maxapi_python-1.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+maxapi_python-1.2.2.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
+maxapi_python-1.2.2.dist-info/RECORD,,

pymax/core.py

@@ -6,21 +6,19 @@ import logging
 import socket
 import ssl
 import time
-import traceback
 from collections.abc import Awaitable
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 from uuid import UUID
 
-from typing_extensions import Self, override
+from typing_extensions import override
 
 from .crud import Database
 from .exceptions import (
     InvalidPhoneError,
     SocketNotConnectedError,
-    WebSocketNotConnectedError,
 )
-from .formatter import ColoredFormatter
+from .interfaces import BaseClient
 from .mixins import ApiMixin, SocketMixin, WebSocketMixin
 from .payloads import UserAgentPayload
 from .static.constant import (
@@ -43,7 +41,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-class MaxClient(ApiMixin, WebSocketMixin):
+class MaxClient(ApiMixin, WebSocketMixin, BaseClient):
     """
     Основной клиент для работы с WebSocket API сервиса Max.
 
@@ -139,9 +137,7 @@ class MaxClient(ApiMixin, WebSocketMixin):
         self._circuit_breaker: bool = False
         self._last_error_time: float = 0.0
 
-        self._device_id = (
-            device_id if device_id is not None else self._database.get_device_id()
-        )
+        self._device_id = device_id if device_id is not None else self._database.get_device_id()
         self._file_upload_waiters: dict[int, asyncio.Future[dict[str, Any]]] = {}
 
         self._token = self._database.get_auth_token() or token
@@ -161,16 +157,11 @@ class MaxClient(ApiMixin, WebSocketMixin):
             tuple[Callable[[Message], Any], BaseFilter[Message] | 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._on_raw_receive_handlers: list[
-            Callable[[dict[str, Any]], Any | Awaitable[Any]]
-        ] = []
-        self._scheduled_tasks: list[
-            tuple[Callable[[], Any | Awaitable[Any]], float]
-        ] = []
+        self._on_stop_handler: Callable[[], Any | Awaitable[Any]] | None = None
+        self._on_reaction_change_handlers: list[Callable[[str, int, ReactionInfo], Any]] = []
+        self._on_chat_update_handlers: list[Callable[[Chat], Any | Awaitable[Any]]] = []
+        self._on_raw_receive_handlers: list[Callable[[dict[str, Any]], Any | Awaitable[Any]]] = []
+        self._scheduled_tasks: list[tuple[Callable[[], Any | Awaitable[Any]], float]] = []
 
         self._ssl_context = ssl.create_default_context()
         self._ssl_context.set_ciphers("DEFAULT")
@@ -188,36 +179,12 @@ class MaxClient(ApiMixin, WebSocketMixin):
             self._work_dir,
         )
 
-    def _setup_logger(self) -> None:
-        if not self.logger.handlers:
-            if not self.logger.level:
-                self.logger.setLevel(logging.INFO)
-            handler = logging.StreamHandler()
-            formatter = ColoredFormatter(
-                "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-                datefmt="%Y-%m-%d %H:%M:%S",
-            )
-            handler.setFormatter(formatter)
-            self.logger.addHandler(handler)
-
     async def _wait_forever(self) -> None:
         try:
             await self.ws.wait_closed()
         except asyncio.CancelledError:
             self.logger.debug("wait_closed cancelled")
 
-    async def _safe_execute(self, coro, *, context: str = "unknown") -> Any:
-        """
-        Безопасно выполняет пользовательскую корутину.
-        Логирует traceback, но не роняет event loop.
-        """
-        try:
-            return await coro
-        except Exception as e:
-            self.logger.error(
-                f"Unhandled exception in {context}: {e}\n{traceback.format_exc()}"
-            )
-
     async def close(self) -> None:
         """
         Закрывает клиент и освобождает ресурсы.
@@ -245,26 +212,6 @@ class MaxClient(ApiMixin, WebSocketMixin):
         except Exception:
             self.logger.exception("Error closing client")
 
-    @override
-    def _create_safe_task(
-        self, coro: Awaitable[Any], *, name: str | None = None
-    ) -> asyncio.Task[Any | None]:
-        async def runner():
-            try:
-                return await coro
-            except asyncio.CancelledError:
-                raise
-            except Exception as e:
-                tb = traceback.format_exc()
-                self.logger.error(
-                    f"Unhandled exception in task {name or coro}: {e}\n{tb}"
-                )
-                raise
-
-        task = asyncio.create_task(runner(), name=name)
-        self._background_tasks.add(task)
-        return task
-
     async def _post_login_tasks(self, sync: bool = True) -> None:
         if sync:
             await self._sync()
@@ -288,49 +235,7 @@ class MaxClient(ApiMixin, WebSocketMixin):
             if asyncio.iscoroutine(result):
                 await self._safe_execute(result, context="on_start handler")
 
-    async def _cleanup_client(self) -> None:
-        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:
+    async def login_with_code(self, temp_token: str, code: str, start: bool = False) -> None:
         """
         Завершает кастомный login flow: отправляет код, сохраняет токен и запускает пост-логин задачи.
 
@@ -348,7 +253,7 @@ class MaxClient(ApiMixin, WebSocketMixin):
         if not token:
             raise ValueError("Login response did not contain tokenAttrs.LOGIN.token")
         self._token = token
-        self._database.update_auth_token(str(self._device_id), token)
+        self._database.update_auth_token(self._device_id, token)
         if start:
             while True:
                 try:
@@ -385,12 +290,12 @@ class MaxClient(ApiMixin, WebSocketMixin):
                     await self._register(self.first_name, self.last_name)
 
                 if self._token and self._database.get_auth_token() is None:
-                    self._database.update_auth_token(str(self._device_id), self._token)
+                    self._database.update_auth_token(self._device_id, self._token)
 
                 if self._token is None:
                     await self._login()
-                else:
-                    await self._sync()
+
+                await self._sync(self.user_agent)
 
                 await self._post_login_tasks(sync=False)
 
@@ -412,43 +317,6 @@ class MaxClient(ApiMixin, WebSocketMixin):
             self.logger.info("Reconnect enabled — restarting client")
             await asyncio.sleep(self.reconnect_delay)
 
-    async def idle(self):
-        """
-        Поддерживает клиента в «ожидающем» состоянии до закрытия клиента или иного прерывающего события.
-
-        :return: Никогда не возвращает значение; функция блокирует выполнение.
-        :rtype: None
-        """
-        await asyncio.Event().wait()
-
-    def inspect(self) -> None:
-        """
-        Выводит в лог текущий статус клиента для отладки.
-        """
-        self.logger.info("Pymax")
-        self.logger.info("---------")
-        self.logger.info(f"Connected: {self.is_connected}")
-        if self.me is not None:
-            self.logger.info(f"Me: {self.me.names[0].first_name} ({self.me.id})")
-        else:
-            self.logger.info("Me: N/A")
-        self.logger.info(f"Dialogs: {len(self.dialogs)}")
-        self.logger.info(f"Chats: {len(self.chats)}")
-        self.logger.info(f"Channels: {len(self.channels)}")
-        self.logger.info(f"Users cached: {len(self._users)}")
-        self.logger.info(f"Background tasks: {len(self._background_tasks)}")
-        self.logger.info(f"Scheduled tasks: {len(self._scheduled_tasks)}")
-        self.logger.info("---------")
-
-    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
@@ -463,12 +331,6 @@ class SocketMaxClient(SocketMixin, MaxClient):
 
     @override
     async def _cleanup_client(self):
-        """
-        Socket-specific cleanup: cancel background tasks, set pending futures
-        exceptions to SocketNotConnectedError, and close socket.
-        """
-        from .exceptions import SocketNotConnectedError
-
         for task in list(self._background_tasks):
             task.cancel()
             try:

pymax/crud.py

@@ -48,7 +48,7 @@ class Database:
             session.refresh(auth)
             return auth
 
-    def update_auth_token(self, device_id: str, token: str) -> None:
+    def update_auth_token(self, device_id: UUID, token: str) -> None:
         with self.get_session() as session:
             auth = session.exec(select(Auth).where(Auth.device_id == device_id)).first()
             if auth:

pymax/formatting.py

@@ -46,14 +46,12 @@ class Formatting:
 
             if inner_text is not None and fmt_type is not None:
                 next_pos = match.end()
-                has_newline = (
-                    next_pos < len(text) and text[next_pos] == "\n"
-                ) or (next_pos == len(text))
+                has_newline = (next_pos < len(text) and text[next_pos] == "\n") or (
+                    next_pos == len(text)
+                )
 
                 length = len(inner_text) + (1 if has_newline else 0)
-                elements.append(
-                    Element(type=fmt_type, from_=current_pos, length=length)
-                )
+                elements.append(Element(type=fmt_type, from_=current_pos, length=length))
 
                 clean_parts.append(inner_text)
                 if has_newline:

pymax/interfaces.py

@@ -1,11 +1,19 @@
 import asyncio
+import contextlib
+import logging
 import socket
 import ssl
+import traceback
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
 from logging import Logger
 from typing import TYPE_CHECKING, Any, Literal
 
+from typing_extensions import Self
+
+from pymax.exceptions import WebSocketNotConnectedError
+from pymax.formatter import ColoredFormatter
+
 from .payloads import UserAgentPayload
 from .static.constant import DEFAULT_TIMEOUT
 from .static.enum import Opcode
@@ -75,16 +83,10 @@ class ClientProtocol(ABC):
         self._on_message_delete_handlers: list[
             tuple[Callable[[Message], Any], BaseFilter[Message] | None]
         ] = []
-        self._on_reaction_change_handlers: list[
-            Callable[[str, int, ReactionInfo], Any]
-        ] = []
+        self._on_reaction_change_handlers: list[Callable[[str, int, ReactionInfo], Any]] = []
         self._on_chat_update_handlers: list[Callable[[Chat], Any | Awaitable[Any]]] = []
-        self._on_raw_receive_handlers: list[
-            Callable[[dict[str, Any]], Any | Awaitable[Any]]
-        ] = []
-        self._scheduled_tasks: list[
-            tuple[Callable[[], Any | Awaitable[Any]], float]
-        ] = []
+        self._on_raw_receive_handlers: list[Callable[[dict[str, Any]], Any | Awaitable[Any]]] = []
+        self._scheduled_tasks: list[tuple[Callable[[], Any | Awaitable[Any]], float]] = []
         self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
         self._background_tasks: set[asyncio.Task[Any]] = set()
         self._ssl_context: ssl.SSLContext
@@ -120,3 +122,135 @@ class ClientProtocol(ABC):
         self, coro: Awaitable[Any], name: str | None = None
     ) -> asyncio.Task[Any]:
         pass
+
+
+class BaseClient(ClientProtocol):
+    def _setup_logger(self) -> None:
+        if not self.logger.handlers:
+            if not self.logger.level:
+                self.logger.setLevel(logging.INFO)
+            handler = logging.StreamHandler()
+            formatter = ColoredFormatter(
+                "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
+            )
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+
+    async def _safe_execute(self, coro, *, context: str = "unknown") -> Any:
+        try:
+            return await coro
+        except Exception as e:
+            self.logger.error(f"Unhandled exception in {context}: {e}\n{traceback.format_exc()}")
+
+    def _create_safe_task(
+        self, coro: Awaitable[Any], name: str | None = None
+    ) -> asyncio.Task[Any | None]:
+        async def runner():
+            try:
+                return await coro
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                tb = traceback.format_exc()
+                self.logger.error(f"Unhandled exception in task {name or coro}: {e}\n{tb}")
+                raise
+
+        task = asyncio.create_task(runner(), name=name)
+        self._background_tasks.add(task)
+        return task
+
+    async def _cleanup_client(self) -> None:
+        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 idle(self):
+        """
+        Поддерживает клиента в «ожидающем» состоянии до закрытия клиента или иного прерывающего события.
+
+        :return: Никогда не возвращает значение; функция блокирует выполнение.
+        :rtype: None
+        """
+        await asyncio.Event().wait()
+
+    def inspect(self) -> None:
+        """
+        Выводит в лог текущий статус клиента для отладки.
+        """
+        self.logger.info("Pymax")
+        self.logger.info("---------")
+        self.logger.info(f"Connected: {self.is_connected}")
+        if self.me is not None:
+            self.logger.info(f"Me: {self.me.names[0].first_name} ({self.me.id})")
+        else:
+            self.logger.info("Me: N/A")
+        self.logger.info(f"Dialogs: {len(self.dialogs)}")
+        self.logger.info(f"Chats: {len(self.chats)}")
+        self.logger.info(f"Channels: {len(self.channels)}")
+        self.logger.info(f"Users cached: {len(self._users)}")
+        self.logger.info(f"Background tasks: {len(self._background_tasks)}")
+        self.logger.info(f"Scheduled tasks: {len(self._scheduled_tasks)}")
+        self.logger.info("---------")
+
+    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()
+
+    @abstractmethod
+    async def login_with_code(self, temp_token: str, code: str, start: bool = False) -> None:
+        pass
+
+    @abstractmethod
+    async def _post_login_tasks(self, sync: bool = True) -> None:
+        pass
+
+    @abstractmethod
+    async def _wait_forever(self) -> None:
+        pass
+
+    @abstractmethod
+    async def start(self) -> None:
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass

pymax/mixins/auth.py

@@ -1,14 +1,17 @@
 import asyncio
+import datetime
 import re
 import sys
 from typing import Any
 
+import qrcode
+
 from pymax.exceptions import Error
 from pymax.interfaces import ClientProtocol
 from pymax.mixins.utils import MixinsUtils
 from pymax.payloads import RegisterPayload, RequestCodePayload, SendCodePayload
 from pymax.static.constant import PHONE_REGEX
-from pymax.static.enum import AuthType, Opcode
+from pymax.static.enum import AuthType, DeviceType, Opcode
 
 
 class AuthMixin(ClientProtocol):
@@ -130,21 +133,67 @@ class AuthMixin(ClientProtocol):
             self.logger.error("Invalid payload data received")
             raise ValueError("Invalid payload data received")
 
+    def _print_qr(self, qr_link: str) -> None:
+        qr = qrcode.QRCode(
+            version=1,
+            error_correction=qrcode.ERROR_CORRECT_L,
+            box_size=1,
+            border=1,
+        )
+        qr.add_data(qr_link)
+        qr.make(fit=True)
+
+        qr.print_ascii()
+
+    async def _request_qr_login(self) -> dict[str, Any]:
+        self.logger.info("Requesting QR login data")
+
+        data = await self._send_and_wait(opcode=Opcode.GET_QR, payload={})
+
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
+
+        self.logger.debug(
+            "QR login data 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")
+
+    def _validate_version(self, version: str, min_version: str) -> bool:
+        def version_tuple(v: str) -> tuple[int, ...]:
+            return tuple(map(int, (v.split("."))))
+
+        return version_tuple(version) >= version_tuple(min_version)
+
     async def _login(self) -> None:
         self.logger.info("Starting login flow")
 
-        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")
+        if self.user_agent.device_type == DeviceType.WEB.value and self._ws:
+            if not self._validate_version(self.user_agent.app_version, "25.12.13"):
+                self.logger.error("Your app version is too old")
+                raise ValueError("Your app version is too old")
 
-        print("Введите код: ", end="", flush=True)
-        code = await asyncio.to_thread(lambda: sys.stdin.readline().strip())
-        if len(code) != 6 or not code.isdigit():
-            self.logger.error("Invalid code format entered")
-            raise ValueError("Invalid code format")
+            login_resp = await self._login_by_qr()
+        else:
+            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")
+
+            print("Введите код: ", end="", flush=True)
+            code = await asyncio.to_thread(lambda: sys.stdin.readline().strip())
+            if len(code) != 6 or not code.isdigit():
+                self.logger.error("Invalid code format entered")
+                raise ValueError("Invalid code format")
+
+            login_resp = await self._send_code(code, temp_token)
 
-        login_resp = await self._send_code(code, temp_token)
         token = login_resp.get("tokenAttrs", {}).get("LOGIN", {}).get("token", "")
 
         if not token:
@@ -152,9 +201,108 @@ class AuthMixin(ClientProtocol):
             raise ValueError("Failed to login, token not received")
 
         self._token = token
-        self._database.update_auth_token(str(self._device_id), self._token)
+        self._database.update_auth_token((self._device_id), self._token)
         self.logger.info("Login successful, token saved to database")
 
+    async def _poll_qr_login(self, track_id: str, poll_interval: int) -> bool:
+        self.logger.info("Polling for QR login confirmation")
+
+        while True:
+            data = await self._send_and_wait(
+                opcode=Opcode.GET_QR_STATUS,
+                payload={"trackId": track_id},
+            )
+
+            payload = data.get("payload", {})
+
+            if payload.get("error"):
+                MixinsUtils.handle_error(data)
+            status = payload.get("status")
+
+            if not status:
+                self.logger.warning("No status in QR login response")
+                continue
+
+            if status.get("loginAvailable"):
+                self.logger.info("QR login confirmed")
+                return True
+            else:
+                exp_at = status.get("expiresAt")
+                if (
+                    exp_at
+                    and isinstance(exp_at, (int, float))
+                    and exp_at < datetime.datetime.now().timestamp() * 1000
+                ):
+                    self.logger.warning("QR code expired")
+                    return False
+
+            await asyncio.sleep(poll_interval / 1000)
+
+    async def _get_qr_login_data(self, track_id: str) -> dict[str, Any]:
+        self.logger.info("Getting QR login data")
+
+        data = await self._send_and_wait(
+            opcode=Opcode.LOGIN_BY_QR,
+            payload={"trackId": track_id},
+        )
+
+        self.logger.debug(
+            "QR login data 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_by_qr(self) -> dict[str, Any]:
+        data = await self._request_qr_login()
+
+        poll_interval = data.get("pollingInterval")
+        link = data.get("qrLink")
+        track_id = data.get("trackId")
+        expires_at = data.get("expiresAt")
+
+        if not poll_interval or not link or not track_id or not expires_at:
+            self.logger.critical("Invalid QR login data received")
+            raise ValueError("Invalid QR login data received")
+
+        self.logger.info("Starting QR login flow")
+        self._print_qr(link)
+
+        poll_qr_task = asyncio.create_task(self._poll_qr_login(track_id, poll_interval))
+
+        while True:
+            now_ms = datetime.datetime.now().timestamp() * 1000
+
+            done, pending = await asyncio.wait(
+                [poll_qr_task],
+                timeout=1,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+
+            if now_ms >= expires_at:
+                poll_qr_task.cancel()
+                self.logger.error("QR code expired before confirmation")
+                raise RuntimeError("QR code expired before confirmation")
+
+            if poll_qr_task in done:
+                exc = poll_qr_task.exception()
+                if exc is not None:
+                    raise exc
+                elif poll_qr_task.result():
+                    self.logger.info("QR login successful")
+
+                    data = await self._get_qr_login_data(track_id)
+                    return data
+
+                else:
+                    self.logger.error("QR login failed or expired")
+                    raise RuntimeError("QR login failed or expired")
+
     async def _submit_reg_info(
         self, first_name: str, last_name: str | None, token: str
     ) -> dict[str, Any]:
@@ -167,9 +315,7 @@ class AuthMixin(ClientProtocol):
                 token=token,
             ).model_dump(by_alias=True)
 
-            data = await self._send_and_wait(
-                opcode=Opcode.AUTH_CONFIRM, payload=payload
-            )
+            data = await self._send_and_wait(opcode=Opcode.AUTH_CONFIRM, payload=payload)
             if data.get("payload", {}).get("error"):
                 MixinsUtils.handle_error(data)
 
@@ -203,11 +349,7 @@ class AuthMixin(ClientProtocol):
             raise ValueError("Invalid code format")
 
         registration_response = await self._send_code(code, temp_token)
-        token = (
-            registration_response.get("tokenAttrs", {})
-            .get("REGISTER", {})
-            .get("token", "")
-        )
+        token = registration_response.get("tokenAttrs", {}).get("REGISTER", {}).get("token", "")
         if not token:
             self.logger.critical("Failed to register, token not received")
             raise ValueError("Failed to register, token not received")

pymax/mixins/socket.py

@@ -92,7 +92,7 @@ class SocketMixin(ClientProtocol):
         payload_len_b = payload_len.to_bytes(4, "big")
         return ver_b + cmd_b + seq_b + opcode_b + payload_len_b + payload_bytes
 
-    async def connect(self, user_agent: UserAgentPayload) -> dict[str, Any]:
+    async def connect(self, user_agent: UserAgentPayload | None = None) -> dict[str, Any]:
         """
         Устанавливает соединение с сервером и выполняет handshake.
 
@@ -101,6 +101,8 @@ class SocketMixin(ClientProtocol):
         :return: Результат handshake.
         :rtype: dict[str, Any] | None
         """
+        if user_agent is None:
+            user_agent = UserAgentPayload()
         if sys.version_info[:2] == (3, 12):
             self.logger.warning(
                 """
@@ -115,9 +117,7 @@ Socket connections may be unstable, SSL issues are possible.
         raw_sock = await loop.run_in_executor(
             None, lambda: socket.create_connection((self.host, self.port))
         )
-        self._socket = self._ssl_context.wrap_socket(
-            raw_sock, server_hostname=self.host
-        )
+        self._socket = self._ssl_context.wrap_socket(raw_sock, server_hostname=self.host)
         self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
         self.is_connected = True
         self._incoming = asyncio.Queue()
@@ -159,9 +159,7 @@ Socket connections may be unstable, SSL issues are possible.
     async def _parse_header(
         self, loop: asyncio.AbstractEventLoop, sock: socket.socket
     ) -> bytes | None:
-        header = await loop.run_in_executor(
-            None, lambda: self._recv_exactly(sock=sock, n=10)
-        )
+        header = await loop.run_in_executor(None, lambda: self._recv_exactly(sock=sock, n=10))
         if not header or len(header) < 10:
             self.logger.info("Socket connection closed; exiting recv loop")
             self.is_connected = False
@@ -182,9 +180,7 @@ Socket connections may be unstable, SSL issues are possible.
 
         while remaining > 0:
             min_read = min(remaining, 8192)
-            chunk = await loop.run_in_executor(
-                None, lambda: self._recv_exactly(sock, min_read)
-            )
+            chunk = await loop.run_in_executor(None, lambda: self._recv_exactly(sock, min_read))
             if not chunk:
                 self.logger.error("Connection closed while reading payload")
                 break
@@ -245,9 +241,7 @@ Socket connections may be unstable, SSL issues are possible.
                 fut = self._file_upload_waiters.pop(id_, None)
                 if fut and not fut.done():
                     fut.set_result(data)
-                    self.logger.debug(
-                        "Fulfilled file upload waiter for %s=%s", key, id_
-                    )
+                    self.logger.debug("Fulfilled file upload waiter for %s=%s", key, id_)
 
     async def _handle_message_notifications(self, data: dict) -> None:
         if data.get("opcode") != Opcode.NOTIF_MESSAGE.value:
@@ -337,38 +331,35 @@ Socket connections may be unstable, SSL issues are possible.
         sock = self._socket
         loop = asyncio.get_running_loop()
 
-        try:
-            while True:
-                try:
-                    header = await self._parse_header(loop, sock)
+        while True:
+            try:
+                header = await self._parse_header(loop, sock)
 
-                    if not header:
-                        break
+                if not header:
+                    break
 
-                    datas = await self._recv_data(loop, header, sock)
+                datas = await self._recv_data(loop, header, sock)
 
-                    if not datas:
-                        continue
+                if not datas:
+                    continue
 
-                    for data_item in datas:
-                        seq = data_item.get("seq")
+                for data_item in datas:
+                    seq = data_item.get("seq")
 
-                        if self._handle_pending(seq, data_item):
-                            continue
+                    if self._handle_pending(seq, data_item):
+                        continue
 
-                        if self._incoming is not None:
-                            await self._handle_incoming_queue(data_item)
+                    if self._incoming is not None:
+                        await self._handle_incoming_queue(data_item)
 
-                        await self._dispatch_incoming(data_item)
+                    await self._dispatch_incoming(data_item)
 
-                except asyncio.CancelledError:
-                    self.logger.debug("Recv loop cancelled")
-                    break
-                except Exception:
-                    self.logger.exception("Error in recv_loop; backing off briefly")
-                    await asyncio.sleep(RECV_LOOP_BACKOFF_DELAY)
-        finally:
-            self.logger.warning("<<< Recv loop exited (socket)")
+            except asyncio.CancelledError:
+                self.logger.debug("Recv loop cancelled")
+                raise
+            except Exception:
+                self.logger.exception("Error in recv_loop; backing off briefly")
+                await asyncio.sleep(RECV_LOOP_BACKOFF_DELAY)
 
     def _log_task_exception(self, fut: asyncio.Future[Any]) -> None:
         try:
@@ -418,9 +409,7 @@ Socket connections may be unstable, SSL issues are possible.
             opcode=opcode.value,
             payload=payload,
         ).model_dump(by_alias=True)
-        self.logger.debug(
-            "make_message opcode=%s cmd=%s seq=%s", opcode, cmd, self._seq
-        )
+        self.logger.debug("make_message opcode=%s cmd=%s seq=%s", opcode, cmd, self._seq)
         return msg
 
     @override
@@ -472,9 +461,7 @@ Socket connections may be unstable, SSL issues are possible.
                 raise exc from conn_err
             raise SocketNotConnectedError from conn_err
         except Exception as exc:
-            self.logger.exception(
-                "Send and wait failed (opcode=%s, seq=%s)", opcode, msg["seq"]
-            )
+            self.logger.exception("Send and wait failed (opcode=%s, seq=%s)", opcode, msg["seq"])
             raise SocketSendError from exc
 
         finally:

pymax/mixins/websocket.py

@@ -50,9 +50,7 @@ class WebSocketMixin(ClientProtocol):
             payload=payload,
         ).model_dump(by_alias=True)
 
-        self.logger.debug(
-            "make_message opcode=%s cmd=%s seq=%s", opcode, cmd, self._seq
-        )
+        self.logger.debug("make_message opcode=%s cmd=%s seq=%s", opcode, cmd, self._seq)
         return msg
 
     async def _send_interactive_ping(self) -> None:
@@ -68,9 +66,7 @@ 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 | None = None
-    ) -> dict[str, Any] | None:
+    async def connect(self, user_agent: UserAgentPayload | None = None) -> dict[str, Any] | None:
         """
         Устанавливает соединение WebSocket с сервером и выполняет handshake.
 
@@ -173,9 +169,7 @@ class WebSocketMixin(ClientProtocol):
                 fut = self._file_upload_waiters.pop(id_, None)
                 if fut and not fut.done():
                     fut.set_result(data)
-                    self.logger.debug(
-                        "Fulfilled file upload waiter for %s=%s", key, id_
-                    )
+                    self.logger.debug("Fulfilled file upload waiter for %s=%s", key, id_)
 
     async def _handle_message_notifications(self, data: dict) -> None:
         if data.get("opcode") != Opcode.NOTIF_MESSAGE.value:
@@ -359,9 +353,7 @@ class WebSocketMixin(ClientProtocol):
             )
             return data
         except Exception:
-            self.logger.exception(
-                "Send and wait failed (opcode=%s, seq=%s)", opcode, msg["seq"]
-            )
+            self.logger.exception("Send and wait failed (opcode=%s, seq=%s)", opcode, msg["seq"])
             raise RuntimeError("Send and wait failed")
         finally:
             self._pending.pop(msg["seq"], None)
@@ -442,7 +434,7 @@ class WebSocketMixin(ClientProtocol):
         else:
             return float(2**retry_count)
 
-    async def _sync(self) -> None:
+    async def _sync(self, user_agent: UserAgentPayload) -> None:
         self.logger.info("Starting initial sync")
 
         payload = SyncPayload(
@@ -453,6 +445,7 @@ class WebSocketMixin(ClientProtocol):
             presence_sync=0,
             drafts_sync=0,
             chats_count=40,
+            user_agent=user_agent,
         ).model_dump(by_alias=True)
         try:
             data = await self._send_and_wait(opcode=Opcode.LOGIN, payload=payload)
@@ -473,9 +466,7 @@ class WebSocketMixin(ClientProtocol):
                     self.logger.exception("Error parsing chat entry")
 
             if raw_payload.get("profile", {}).get("contact"):
-                self.me = Me.from_dict(
-                    raw_payload.get("profile", {}).get("contact", {})
-                )
+                self.me = Me.from_dict(raw_payload.get("profile", {}).get("contact", {}))
 
             self.logger.info(
                 "Sync completed: dialogs=%d chats=%d channels=%d",

pymax/payloads.py

@@ -39,6 +39,20 @@ class BaseWebSocketMessage(BaseModel):
     payload: dict[str, Any]
 
 
+class UserAgentPayload(CamelModel):
+    device_type: str = Field(default=DEFAULT_DEVICE_TYPE)
+    locale: str = Field(default=DEFAULT_LOCALE)
+    device_locale: str = Field(default=DEFAULT_DEVICE_LOCALE)
+    os_version: str = Field(default=DEFAULT_OS_VERSION)
+    device_name: str = Field(default=DEFAULT_DEVICE_NAME)
+    header_user_agent: str = Field(default=DEFAULT_USER_AGENT)
+    app_version: str = Field(default=DEFAULT_APP_VERSION)
+    screen: str = Field(default=DEFAULT_SCREEN)
+    timezone: str = Field(default=DEFAULT_TIMEZONE)
+    client_session_id: int = Field(default=DEFAULT_CLIENT_SESSION_ID)
+    build_number: int = Field(default=DEFAULT_BUILD_NUMBER)
+
+
 class RequestCodePayload(CamelModel):
     phone: str
     type: AuthType = AuthType.START_AUTH
@@ -59,6 +73,21 @@ class SyncPayload(CamelModel):
     presence_sync: int = 0
     drafts_sync: int = 0
     chats_count: int = 40
+    user_agent: UserAgentPayload = Field(
+        default_factory=lambda: UserAgentPayload(
+            device_type=DEFAULT_DEVICE_TYPE,
+            locale=DEFAULT_LOCALE,
+            device_locale=DEFAULT_DEVICE_LOCALE,
+            os_version=DEFAULT_OS_VERSION,
+            device_name=DEFAULT_DEVICE_NAME,
+            header_user_agent=DEFAULT_USER_AGENT,
+            app_version=DEFAULT_APP_VERSION,
+            screen=DEFAULT_SCREEN,
+            timezone=DEFAULT_TIMEZONE,
+            client_session_id=DEFAULT_CLIENT_SESSION_ID,
+            build_number=DEFAULT_BUILD_NUMBER,
+        ),
+    )
 
 
 class ReplyLink(CamelModel):
@@ -276,20 +305,6 @@ class RemoveReactionPayload(CamelModel):
     message_id: str
 
 
-class UserAgentPayload(CamelModel):
-    device_type: str = Field(default=DEFAULT_DEVICE_TYPE)
-    locale: str = Field(default=DEFAULT_LOCALE)
-    device_locale: str = Field(default=DEFAULT_DEVICE_LOCALE)
-    os_version: str = Field(default=DEFAULT_OS_VERSION)
-    device_name: str = Field(default=DEFAULT_DEVICE_NAME)
-    header_user_agent: str = Field(default=DEFAULT_USER_AGENT)
-    app_version: str = Field(default=DEFAULT_APP_VERSION)
-    screen: str = Field(default=DEFAULT_SCREEN)
-    timezone: str = Field(default=DEFAULT_TIMEZONE)
-    client_session_id: int = Field(default=DEFAULT_CLIENT_SESSION_ID)
-    build_number: int = Field(default=DEFAULT_BUILD_NUMBER)
-
-
 class ReworkInviteLinkPayload(CamelModel):
     revoke_private_link: bool = True
     chat_id: int

pymax/static/constant.py

@@ -9,11 +9,11 @@ WEBSOCKET_ORIGIN: Final[Origin] = Origin("https://web.max.ru")
 HOST: Final[str] = "api.oneme.ru"
 PORT: Final[int] = 443
 DEFAULT_TIMEOUT: Final[float] = 20.0
-DEFAULT_DEVICE_TYPE: Final[str] = "WEB"
+DEFAULT_DEVICE_TYPE: Final[str] = "DESKTOP"
 DEFAULT_LOCALE: Final[str] = "ru"
 DEFAULT_DEVICE_LOCALE: Final[str] = "ru"
 DEFAULT_DEVICE_NAME: Final[str] = "Chrome"
-DEFAULT_APP_VERSION: Final[str] = "25.12.1"
+DEFAULT_APP_VERSION: Final[str] = "25.12.13"
 DEFAULT_SCREEN: Final[str] = "1080x1920 1.0x"
 DEFAULT_OS_VERSION: Final[str] = "Linux"
 DEFAULT_USER_AGENT: Final[str] = (

pymax/static/enum.py

@@ -141,6 +141,10 @@ class Opcode(int, Enum):
     FOLDERS_DELETE = 276
     NOTIF_FOLDERS = 277
 
+    GET_QR = 288
+    GET_QR_STATUS = 289
+    LOGIN_BY_QR = 291
+
 
 class ChatType(str, Enum):
     DIALOG = "DIALOG"