maxapi-python 1.1.21__tar.gz → 1.2.1__tar.gz

{maxapi_python-1.1.21 → maxapi_python-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.21
+Version: 1.2.1
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/ink-developer/PyMax
 Project-URL: Repository, https://github.com/ink-developer/PyMax
@@ -16,6 +16,7 @@ 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
 Description-Content-Type: text/markdown
@@ -35,6 +36,12 @@ Description-Content-Type: text/markdown
     <img src="https://img.shields.io/badge/packaging-uv-D7FF64.svg" alt="Packaging">
 </p>
 
+> [!IMPORTANT]
+> (20.12.25) Из за резкого изменения апи большая часть библиотеки не работает.
+Смотрите [новость](https://t.me/pymax_news/111)
+> 
+> P.s добавил логин по qr в dev/1.2.1
+
 ---
 > ⚠️ **Дисклеймер**
 >

{maxapi_python-1.1.21 → maxapi_python-1.2.1}/README.md

@@ -13,6 +13,12 @@
     <img src="https://img.shields.io/badge/packaging-uv-D7FF64.svg" alt="Packaging">
 </p>
 
+> [!IMPORTANT]
+> (20.12.25) Из за резкого изменения апи большая часть библиотеки не работает.
+Смотрите [новость](https://t.me/pymax_news/111)
+> 
+> P.s добавил логин по qr в dev/1.2.1
+
 ---
 > ⚠️ **Дисклеймер**
 >

{maxapi_python-1.1.21 → maxapi_python-1.2.1}/examples/example.py

@@ -44,9 +44,7 @@ async def handle_start() -> None:
     messages = []
     from_time = int(time() * 1000)
     while len(messages) < max_messages:
-        r = await client.fetch_history(
-            chat_id=chat_id, from_time=from_time, backward=30
-        )
+        r = await client.fetch_history(chat_id=chat_id, from_time=from_time, backward=30)
         if not r:
             break
         from_time = r[0].time
@@ -131,9 +129,7 @@ async def handle_start() -> None:
 
 @client.on_message()
 async def handle_message(message: Message) -> None:
-    print(
-        f"New message in chat {message.chat_id} from {message.sender}: {message.text}"
-    )
+    print(f"New message in chat {message.chat_id} from {message.sender}: {message.text}")
     # if message.link and message.link.message.attaches:
     #     for attach in message.link.message.attaches:
     #         print(f"Link attach type: {attach.type}")

maxapi_python-1.2.1/examples/test.py

@@ -0,0 +1,20 @@
+import asyncio
+
+from pymax import MaxClient
+from pymax.payloads import UserAgentPayload
+
+ua = UserAgentPayload(device_type="WEB")
+
+client = MaxClient(
+    phone="+79911111111",
+    work_dir="cache",
+    headers=ua,
+)
+
+
+@client.on_start
+async def on_start() -> None:
+    print(f"MaxClient started as {client.me.names[0].first_name}!")
+
+
+asyncio.run(client.start())

{maxapi_python-1.1.21 → maxapi_python-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "maxapi-python"
-version = "1.1.21"
+version = "1.2.1"
 description = "Python wrapper для API мессенджера Max"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -18,6 +18,7 @@ dependencies = [
   "lz4>=4.4.4",
   "aiohttp>=3.12.15",
   "aiofiles>=24.1.0",
+  "qrcode>=8.2",
 ]
 
 [project.urls]

{maxapi_python-1.1.21 → maxapi_python-1.2.1}/src/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()
 
                 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:

{maxapi_python-1.1.21 → maxapi_python-1.2.1}/src/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:

{maxapi_python-1.1.21 → maxapi_python-1.2.1}/src/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:

maxapi_python-1.2.1/src/pymax/interfaces.py

@@ -0,0 +1,256 @@
+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
+from .types import Channel, Chat, Dialog, Me, Message, User
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from uuid import UUID
+
+    import websockets
+
+    from pymax import AttachType
+    from pymax.types import ReactionInfo
+
+    from .crud import Database
+    from .filters import BaseFilter
+
+
+class ClientProtocol(ABC):
+    def __init__(self, logger: Logger) -> None:
+        super().__init__()
+        self.logger = logger
+        self._users: dict[int, User] = {}
+        self.chats: list[Chat] = []
+        self._database: Database
+        self._device_id: UUID
+        self.uri: str
+        self.is_connected: bool = False
+        self.phone: str
+        self.dialogs: list[Dialog] = []
+        self.channels: list[Channel] = []
+        self.me: Me | None = None
+        self.host: str
+        self.port: int
+        self.proxy: str | Literal[True] | None
+        self.registration: bool
+        self.first_name: str
+        self.last_name: str | None
+        self._token: str | None
+        self._work_dir: str
+        self.reconnect: bool
+        self._database_path: Path
+        self._ws: websockets.ClientConnection | None = None
+        self._seq: int = 0
+        self._pending: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._recv_task: asyncio.Task[Any] | None = None
+        self._incoming: asyncio.Queue[dict[str, Any]] | None = None
+        self._file_upload_waiters: dict[
+            int,
+            asyncio.Future[dict[str, Any]],
+        ] = {}
+        self.user_agent = UserAgentPayload()
+        self._outgoing: asyncio.Queue[dict[str, Any]] | None = None
+        self._outgoing_task: asyncio.Task[Any] | None = None
+        self._error_count: int = 0
+        self._circuit_breaker: bool = False
+        self._last_error_time: float = 0.0
+        self._session_id: int
+        self._action_id: int = 0
+        self._current_screen: str = "chats_list_tab"
+        self._on_message_handlers: list[
+            tuple[Callable[[Message], Any], BaseFilter[Message] | None]
+        ] = []
+        self._on_message_edit_handlers: list[
+            tuple[Callable[[Message], Any], BaseFilter[Message] | None]
+        ] = []
+        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_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_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
+        self._background_tasks: set[asyncio.Task[Any]] = set()
+        self._ssl_context: ssl.SSLContext
+        self._socket: socket.socket | None = None
+
+    @abstractmethod
+    async def _send_and_wait(
+        self,
+        opcode: Opcode,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> dict[str, Any]:
+        pass
+
+    @abstractmethod
+    async def _get_chat(self, chat_id: int) -> Chat | None:
+        pass
+
+    @abstractmethod
+    async def _queue_message(
+        self,
+        opcode: int,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = DEFAULT_TIMEOUT,
+        max_retries: int = 3,
+    ) -> Message | None:
+        pass
+
+    @abstractmethod
+    def _create_safe_task(
+        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