maxapi-python 0.1.0__py3-none-any.whl

maxapi_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: maxapi-python
+Version: 0.1.0
+Summary: Python wrapper для API мессенджера Max
+Author-email: noxzion <negroid2281488ilikrilex@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/noxzion/PyMax
+Project-URL: Repository, https://github.com/noxzion/PyMax
+Project-URL: Issues, https://github.com/noxzion/PyMax/issues
+Keywords: max,messenger,api,wrapper,websocket
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: build>=1.3.0
+Requires-Dist: pydocstring>=0.2.1
+Requires-Dist: sqlmodel>=0.0.24
+Requires-Dist: websockets>=11.0
+Dynamic: license-file
+
+## MApi - Python api wrapper для Max'a
+
+## Установка
+
+> [!IMPORTANT]
+> Нужно иметь git для установки из репозитория
+
+```bash
+pip install git+https://github.com/noxzion/PyMax
+```
+
+Или (без git)
+```bash
+pip install maxapi-python
+```
+
+## Пример использования:
+
+```python
+import asyncio
+
+from mapi import MaxClient, Message
+
+
+phone = "+1234567890"
+client = MaxClient(phone=phone, work_dir="cache")
+
+
+async def main() -> None:
+    await client.start()
+
+    for chat in client.chats:
+        print(chat.title)
+
+        message = await client.send_message("Hello from MaxClient!", chat.id, notify=True)
+
+        await asyncio.sleep(5)
+        message = await client.edit_message(chat.id, message.id, "Hello from MaxClient! (edited)")
+        await asyncio.sleep(5)
+
+        await client.delete_message(chat.id, [message.id], for_me=False)
+
+    for dialog in client.dialogs:
+        print(dialog.last_message.text)
+
+    for channel in client.channels:
+        print(channel.title)
+
+    await client.close()
+
+
+@client.on_message
+async def handle_message(message: Message) -> None:
+    print(str(message.sender) + ": " + message.text)
+
+
+@client.on_start
+async def handle_start() -> None:
+    print("Client started successfully!")
+    history = await client.fetch_history(chat_id=0)
+    if history:
+        for message in history:
+            user_id = message.sender
+            user = await client.get_user(user_id)
+
+            if user:
+                print(f"{user.names[0].name}: {message.text}")
+
+
+if __name__ == "__main__":
+    asyncio.run(client.start())
+```
+
+## Разработка
+
+Сборка пакета:
+
+```bash
+python scripts/build.py
+```
+
+## Лицензия
+
+[MIT](LICENSE)
+
+## Авторы
+
+- [noxzion](https://github.com/noxzion) - исходный код пакета
+- [ink](https://github.com/ink-developer) - вскрытие API и документация

maxapi_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+maxapi_python-0.1.0.dist-info/licenses/LICENSE,sha256=Ud-0SKeXO_yA02Bb1nMDnEaSGwz2OqNlfGQbk0IzqPI,1085
+pymax/__init__.py,sha256=I-ZUVKBfHN-MPkLUbLPxflsvnHSFsyXdW3TmbN2_zz0,950
+pymax/core.py,sha256=DI3yjlCvSipilWMescXluLbP-sDwoOD092K67dJqR38,25132
+pymax/crud.py,sha256=Cn7Psw-gGN0607nqWOLlIorP_wowYWrLomlsof0gLkI,3311
+pymax/exceptions.py,sha256=tiD_JD-MYSb4qFyKov-KWOm0zlD1p_gG6nf1fV-0-SY,702
+pymax/models.py,sha256=7sWAmVuJjM7SPnDkpYEi8CARbTpUKbXqtWKMQdwd0w0,209
+pymax/static.py,sha256=ZIPPAyr3__gtkwSgS_-hXk_oNkcVKs55tY8pSzOrSlY,1711
+pymax/types.py,sha256=6EofkAY_oUnDkNh-cC9Uk05GjKgl6ThBy3_8Hjownz4,11541
+maxapi_python-0.1.0.dist-info/METADATA,sha256=DOVISXKymoucnNKgU1z84wPCLA1Mcwx9rzpxBPAuKCQ,2808
+maxapi_python-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maxapi_python-0.1.0.dist-info/top_level.txt,sha256=bdAekZwlWiYDxQTWsAUa-yjplJDWDeWEmyhRO3R8qV4,6
+maxapi_python-0.1.0.dist-info/RECORD,,

maxapi_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

maxapi_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 noxzion
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

maxapi_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pymax

pymax/__init__.py

@@ -0,0 +1,55 @@
+"""
+Python wrapper для API мессенджера Max
+"""
+
+from .core import (
+    InvalidPhoneError,
+    MaxClient,
+    WebSocketNotConnectedError,
+)
+from .static import (
+    AccessType,
+    AuthType,
+    ChatType,
+    Constants,
+    DeviceType,
+    ElementType,
+    MessageStatus,
+    MessageType,
+    Opcode,
+)
+from .types import (
+    Channel,
+    Chat,
+    Dialog,
+    Element,
+    Message,
+    User,
+)
+
+__author__ = "noxzion"
+
+__all__ = [
+    # Перечисления и константы
+    "AccessType",
+    "AuthType",
+    # Типы данных
+    "Channel",
+    "Chat",
+    "ChatType",
+    "Constants",
+    "DeviceType",
+    "Dialog",
+    "Element",
+    "ElementType",
+    # Исключения
+    "InvalidPhoneError",
+    # Клиент
+    "MaxClient",
+    "Message",
+    "MessageStatus",
+    "MessageType",
+    "Opcode",
+    "User",
+    "WebSocketNotConnectedError",
+]

pymax/core.py

@@ -0,0 +1,600 @@
+import asyncio
+import json
+import logging
+import re
+import time
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Any
+
+import websockets
+
+from .crud import Database
+from .exceptions import InvalidPhoneError, WebSocketNotConnectedError
+from .static import AuthType, ChatType, Constants, Opcode
+from .types import Channel, Chat, Dialog, Message, User
+
+logger = logging.getLogger(__name__)
+
+
+class MaxClient:
+    """
+    Основной клиент для работы с WebSocket API сервиса Max.
+
+
+    Args:
+        phone (str): Номер телефона для авторизации.
+        uri (str, optional): URI WebSocket сервера. По умолчанию Constants.WEBSOCKET_URI.value.
+        work_dir (str, optional): Рабочая директория для хранения базы данных. По умолчанию ".".
+        logger (logging.Logger | None): Пользовательский логгер. Если не передан — используется
+            логгер модуля с именем f"{__name__}.MaxClient".
+
+    Raises:
+        InvalidPhoneError: Если формат номера телефона неверный.
+    """
+
+    def __init__(
+        self,
+        phone: str,
+        uri: str = Constants.WEBSOCKET_URI.value,
+        work_dir: str = ".",
+        logger: logging.Logger | None = None,
+    ) -> None:
+        self.uri: str = uri
+        self.is_connected: bool = False
+        self.phone: str = phone
+        self.chats: list[Chat] = []
+        self.dialogs: list[Dialog] = []
+        self.channels: list[Channel] = []
+        self._users: dict[int, User] = {}
+        if not self._check_phone():
+            raise InvalidPhoneError(self.phone)
+        self._work_dir: str = work_dir
+        self._database_path: Path = Path(work_dir) / "session.db"
+        self._database_path.parent.mkdir(parents=True, exist_ok=True)
+        self._database_path.touch(exist_ok=True)
+        self._database = Database(self._work_dir)
+        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._device_id = self._database.get_device_id()
+        self._token = self._database.get_auth_token()
+        self.user_agent = Constants.DEFAULT_USER_AGENT.value
+        self._on_message_handler: Callable[[Message], Any] | None = None
+        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
+        self._background_tasks: set[asyncio.Task[Any]] = set()
+        self.logger = logger or logging.getLogger(f"{__name__}.MaxClient")
+        self._setup_logger()
+
+        self.logger.debug("Initialized MaxClient uri=%s work_dir=%s", self.uri, self._work_dir)
+
+    def _setup_logger(self) -> None:
+        self.logger.setLevel(logging.INFO)
+
+        if not logger.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter("%(asctime)s [%(levelname)s] %(name)s: %(message)s")
+            handler.setFormatter(formatter)
+            logger.addHandler(handler)
+
+    @property
+    def ws(self) -> websockets.ClientConnection:
+        if self._ws is None or not self.is_connected:
+            self.logger.critical("WebSocket not connected when access attempted")
+            raise WebSocketNotConnectedError
+        return self._ws
+
+    def on_message(
+        self, handler: Callable[[Message], Any | Awaitable[Any]]
+    ) -> Callable[[Message], Any | Awaitable[Any]]:
+        """
+        Устанавливает обработчик входящих сообщений.
+
+        Args:
+            handler: Функция или coroutine, принимающая объект Message.
+
+        Returns:
+            Установленный обработчик.
+        """
+        self._on_message_handler = handler
+        self.logger.debug("on_message handler set: %r", handler)
+        return handler
+
+    def on_start(
+        self, handler: Callable[[], Any | Awaitable[Any]]
+    ) -> Callable[[], Any | Awaitable[Any]]:
+        """
+        Устанавливает обработчик, вызываемый при старте клиента.
+
+        Args:
+            handler: Функция или coroutine без аргументов.
+
+        Returns:
+            Установленный обработчик.
+        """
+        self._on_start_handler = handler
+        self.logger.debug("on_start handler set: %r", handler)
+        return handler
+
+    def add_message_handler(
+        self, handler: Callable[[Message], Any | Awaitable[Any]]
+    ) -> Callable[[Message], Any | Awaitable[Any]]:
+        self.logger.debug("add_message_handler (alias) used")
+        self._on_message_handler = handler
+        return handler
+
+    def add_on_start_handler(
+        self, handler: Callable[[], Any | Awaitable[Any]]
+    ) -> Callable[[], Any | Awaitable[Any]]:
+        self.logger.debug("add_on_start_handler (alias) used")
+        self._on_start_handler = handler
+        return handler
+
+    def _check_phone(self) -> bool:
+        return bool(re.match(Constants.PHONE_REGEX.value, self.phone))
+
+    def _make_message(self, opcode: int, payload: dict[str, Any], cmd: int = 0) -> dict[str, Any]:
+        self._seq += 1
+        msg = {
+            "ver": 11,
+            "cmd": cmd,
+            "seq": self._seq,
+            "opcode": opcode,
+            "payload": payload,
+        }
+        self.logger.debug("make_message opcode=%s cmd=%s seq=%s", opcode, cmd, self._seq)
+        return msg
+
+    async def _send_interactive_ping(self) -> None:
+        while self.is_connected:
+            try:
+                await self._send_and_wait(
+                    opcode=1,
+                    payload={"interactive": True},
+                    cmd=0,
+                )
+                self.logger.debug("Interactive ping sent successfully")
+            except Exception:
+                self.logger.warning("Interactive ping failed", exc_info=True)
+            await asyncio.sleep(30)
+
+    async def _connect(self, user_agent: dict[str, Any]) -> dict[str, Any]:
+        try:
+            self.logger.info("Connecting to WebSocket %s", self.uri)
+            self._ws = await websockets.connect(self.uri)
+            self.is_connected = True
+            self._incoming = asyncio.Queue()
+            self._pending = {}
+            self._recv_task = asyncio.create_task(self._recv_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 _handshake(self, user_agent: dict[str, Any]) -> dict[str, Any]:
+        try:
+            self.logger.debug("Sending handshake with user_agent keys=%s", list(user_agent.keys()))
+            resp = await self._send_and_wait(
+                opcode=Opcode.HANDSHAKE,
+                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}")
+
+    async def _request_code(self, phone: str, language: str = "ru") -> dict[str, int | str]:
+        try:
+            self.logger.info("Requesting auth code")
+            payload = {
+                "phone": phone,
+                "type": AuthType.START_AUTH.value,
+                "language": language,
+            }
+            data = await self._send_and_wait(opcode=Opcode.REQUEST_CODE, payload=payload)
+            self.logger.debug(
+                "Code request response opcode=%s seq=%s", data.get("opcode"), data.get("seq")
+            )
+            return data.get("payload")
+        except Exception:
+            self.logger.error("Request code failed", exc_info=True)
+            raise RuntimeError("Request code failed")
+
+    async def _send_code(self, code: str, token: str) -> dict[str, Any]:
+        try:
+            self.logger.info("Sending verification code")
+            payload = {
+                "token": token,
+                "verifyCode": code,
+                "authTokenType": AuthType.CHECK_CODE.value,
+            }
+            data = await self._send_and_wait(opcode=Opcode.SEND_CODE, payload=payload)
+            self.logger.debug(
+                "Send code response opcode=%s seq=%s", data.get("opcode"), data.get("seq")
+            )
+            return data.get("payload")
+        except Exception:
+            self.logger.error("Send code failed", exc_info=True)
+            raise RuntimeError("Send code failed")
+
+    async def _recv_loop(self) -> None:
+        if self._ws is None:
+            self.logger.warning("Recv loop started without websocket instance")
+            return
+
+        self.logger.debug("Receive loop started")
+        while True:
+            try:
+                raw = await self._ws.recv()
+                try:
+                    data = json.loads(raw)
+                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
+
+                if fut and not fut.done():
+                    fut.set_result(data)
+                    self.logger.debug("Matched response for pending seq=%s", seq)
+                else:
+                    if self._incoming is not None:
+                        try:
+                            self._incoming.put_nowait(data)
+                        except asyncio.QueueFull:
+                            self.logger.warning(
+                                "Incoming queue full; dropping message seq=%s", data.get("seq")
+                            )
+
+                    if data.get("opcode") == Opcode.NEW_MESSAGE and self._on_message_handler:
+                        try:
+                            payload = data.get("payload", {})
+                            msg = Message.from_dict(payload.get("message"))
+                            if msg:
+                                result = self._on_message_handler(msg)
+                                if asyncio.iscoroutine(result):
+                                    task = asyncio.create_task(result)
+                                    self._background_tasks.add(task)
+                                    task.add_done_callback(
+                                        lambda t: self._background_tasks.discard(t)
+                                        or self._log_task_exception(t)
+                                    )
+                        except Exception:
+                            self.logger.exception("Error in on_message_handler")
+
+            except websockets.exceptions.ConnectionClosed:
+                self.logger.info("WebSocket connection closed; exiting recv loop")
+                break
+            except Exception:
+                self.logger.exception("Error in recv_loop; backing off briefly")
+                await asyncio.sleep(0.5)
+
+    def _log_task_exception(self, task: asyncio.Task[Any]) -> None:
+        try:
+            exc = task.exception()
+            if exc:
+                self.logger.exception("Background task exception: %s", exc)
+        except Exception:
+            # ignore inspection failures
+            pass
+
+    async def _send_and_wait(
+        self,
+        opcode: int,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = Constants.DEFAULT_TIMEOUT.value,
+    ) -> dict[str, Any]:
+        # Проверка соединения — с логированием критичности
+        ws = self.ws  # вызовет исключение и CRITICAL-лог, если не подключены
+
+        msg = self._make_message(opcode, payload, cmd)
+        loop = asyncio.get_running_loop()
+        fut: asyncio.Future[dict[str, Any]] = loop.create_future()
+        self._pending[msg["seq"]] = fut
+
+        try:
+            self.logger.debug("Sending frame opcode=%s cmd=%s seq=%s", opcode, cmd, msg["seq"])
+            await ws.send(json.dumps(msg))
+            data = await asyncio.wait_for(fut, timeout=timeout)
+            self.logger.debug(
+                "Received frame for seq=%s opcode=%s", data.get("seq"), data.get("opcode")
+            )
+            return data
+        except Exception:
+            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)
+
+    async def _sync(self) -> None:
+        try:
+            self.logger.info("Starting initial sync")
+            payload = {
+                "interactive": True,
+                "token": self._token,
+                "chatsSync": 0,
+                "contactsSync": 0,
+                "presenceSync": 0,
+                "draftsSync": 0,
+                "chatsCount": 40,
+            }
+            data = await self._send_and_wait(opcode=19, payload=payload)
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Sync error: %s", error)
+                return
+
+            for raw_chat in data.get("payload", {}).get("chats", []):
+                try:
+                    if raw_chat.get("type") == ChatType.DIALOG.value:
+                        self.dialogs.append(Dialog.from_dict(raw_chat))
+                    elif raw_chat.get("type") == ChatType.CHAT.value:
+                        self.chats.append(Chat.from_dict(raw_chat))
+                    elif raw_chat.get("type") == ChatType.CHANNEL.value:
+                        self.channels.append(Channel.from_dict(raw_chat))
+                except Exception:
+                    self.logger.exception("Error parsing chat entry")
+            self.logger.info(
+                "Sync completed: dialogs=%d chats=%d channels=%d",
+                len(self.dialogs),
+                len(self.chats),
+                len(self.channels),
+            )
+        except Exception:
+            self.logger.exception("Sync failed")
+
+    async def send_message(self, text: str, chat_id: int, notify: bool) -> Message | None:
+        """
+        Отправляет сообщение в чат.
+        """
+        try:
+            self.logger.info("Sending message to chat_id=%s notify=%s", chat_id, notify)
+            payload = {
+                "chatId": chat_id,
+                "message": {
+                    "text": text,
+                    "cid": int(time.time() * 1000),
+                    "elements": [],
+                    "attaches": [],
+                },
+                "notify": notify,
+            }
+            data = await self._send_and_wait(opcode=Opcode.SEND_MESSAGE, payload=payload)
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Send message error: %s", error)
+            msg = Message.from_dict(data["payload"]["message"]) if data.get("payload") else None
+            self.logger.debug("send_message result: %r", msg)
+            return msg
+        except Exception:
+            self.logger.exception("Send message failed")
+            return None
+
+    async def edit_message(self, chat_id: int, message_id: int, text: str) -> Message | None:
+        """
+        Редактирует сообщение.
+        """
+        try:
+            self.logger.info("Editing message chat_id=%s message_id=%s", chat_id, message_id)
+            payload = {
+                "chatId": chat_id,
+                "messageId": message_id,
+                "text": text,
+                "elements": [],
+                "attaches": [],
+            }
+            data = await self._send_and_wait(opcode=Opcode.EDIT_MESSAGE, payload=payload)
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Edit message error: %s", error)
+            msg = Message.from_dict(data["payload"]["message"]) if data.get("payload") else None
+            self.logger.debug("edit_message result: %r", msg)
+            return msg
+        except Exception:
+            self.logger.exception("Edit message failed")
+            return None
+
+    async def delete_message(self, chat_id: int, message_ids: list[int], for_me: bool) -> bool:
+        """
+        Удаляет сообщения.
+        """
+        try:
+            self.logger.info(
+                "Deleting messages chat_id=%s ids=%s for_me=%s", chat_id, message_ids, for_me
+            )
+            payload = {"chatId": chat_id, "messageIds": message_ids, "forMe": for_me}
+            data = await self._send_and_wait(opcode=Opcode.DELETE_MESSAGE, payload=payload)
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Delete message error: %s", error)
+                return False
+            self.logger.debug("delete_message success")
+            return True
+        except Exception:
+            self.logger.exception("Delete message failed")
+            return False
+
+    async def close(self) -> None:
+        try:
+            self.logger.info("Closing client")
+            if self._recv_task:
+                self._recv_task.cancel()
+                try:
+                    await self._recv_task
+                except asyncio.CancelledError:
+                    self.logger.debug("recv_task cancelled")
+            if self._ws:
+                await self._ws.close()
+            self.is_connected = False
+            self.logger.info("Client closed")
+        except Exception:
+            self.logger.exception("Error closing client")
+
+    def get_cached_user(self, user_id: int) -> User | None:
+        """
+        Получает юзера из кеша по его ID
+
+        Args:
+            user_id (int): ID пользователя.
+
+        Returns:
+            User | None: Объект User или None при ошибке.
+        """
+        user = self._users.get(user_id)
+        self.logger.debug("get_cached_user id=%s hit=%s", user_id, bool(user))
+        return user
+
+    async def get_users(self, user_ids: list[int]) -> list[User]:
+        """
+        Получает информацию о пользователях по их ID (с кешем).
+        """
+        self.logger.debug("get_users ids=%s", user_ids)
+        cached = {uid: self._users[uid] for uid in user_ids if uid in self._users}
+        missing_ids = [uid for uid in user_ids if uid not in self._users]
+
+        if missing_ids:
+            self.logger.debug("Fetching missing users: %s", missing_ids)
+            fetched_users = await self.fetch_users(missing_ids)
+            if fetched_users:
+                for user in fetched_users:
+                    self._users[user.id] = user
+                    cached[user.id] = user
+
+        ordered = [cached[uid] for uid in user_ids if uid in cached]
+        self.logger.debug("get_users result_count=%d", len(ordered))
+        return ordered
+
+    async def get_user(self, user_id: int) -> User | None:
+        """
+        Получает информацию о пользователе по его ID (с кешем).
+        """
+        self.logger.debug("get_user id=%s", user_id)
+        if user_id in self._users:
+            return self._users[user_id]
+
+        users = await self.fetch_users([user_id])
+        if users:
+            self._users[user_id] = users[0]
+            return users[0]
+        return None
+
+    async def fetch_users(self, user_ids: list[int]) -> None | list[User]:
+        """
+        Получает информацию о пользователях по их ID.
+        """
+        try:
+            self.logger.info("Fetching users count=%d", len(user_ids))
+            payload = {"contactIds": user_ids}
+
+            data = await self._send_and_wait(opcode=Opcode.GET_CONTACTS_INFO, payload=payload)
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Fetch users error: %s", error)
+                return None
+
+            users = [User.from_dict(u) for u in data["payload"].get("contacts", [])]
+            for user in users:
+                self._users[user.id] = user
+
+            self.logger.debug("Fetched users: %d", len(users))
+            return users
+        except Exception:
+            self.logger.exception("Fetch users failed")
+            return []
+
+    async def fetch_history(
+        self,
+        chat_id: int,
+        from_time: int | None = None,
+        forward: int = 0,
+        backward: int = 200,
+    ) -> list[Message] | None:
+        """
+        Получает историю сообщений чата.
+        """
+        if from_time is None:
+            from_time = int(time.time() * 1000)
+
+        try:
+            self.logger.info(
+                "Fetching history chat_id=%s from=%s forward=%s backward=%s",
+                chat_id,
+                from_time,
+                forward,
+                backward,
+            )
+            payload = {
+                "chatId": chat_id,
+                "from": from_time,
+                "forward": forward,
+                "backward": backward,
+                "getMessages": True,
+            }
+
+            data = await self._send_and_wait(opcode=Opcode.FETCH_HISTORY, payload=payload)
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Fetch history error: %s", error)
+                return None
+            messages = [Message.from_dict(msg) for msg in data["payload"].get("messages", [])]
+            self.logger.debug("History fetched: %d messages", len(messages))
+            return messages
+        except Exception:
+            self.logger.exception("Fetch history failed")
+            return None
+
+    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")
+        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")
+
+        code = await asyncio.to_thread(input, "Введите код: ")
+        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)
+        token: str | None = login_resp.get("tokenAttrs", {}).get("LOGIN", {}).get("token")
+        if not token:
+            self.logger.critical("Failed to login, token not received")
+            raise ValueError("Failed to login, token not received")
+
+        self._token = token
+        self._database.update_auth_token(self._device_id, self._token)
+        self.logger.info("Login successful, token saved to database")
+
+    async def start(self) -> None:
+        """
+        Запускает клиент, подключается к WebSocket, авторизует
+        пользователя (если нужно) и запускает фоновый цикл.
+        """
+        try:
+            self.logger.info("Client starting")
+            await self._connect(self.user_agent)
+            if self._token is None:
+                await self._login()
+            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 result
+
+            if self._ws:
+                ping_task = asyncio.create_task(self._send_interactive_ping())
+                self._background_tasks.add(ping_task)
+                ping_task.add_done_callback(
+                    lambda t: self._background_tasks.discard(t) or self._log_task_exception(t)
+                )
+
+                try:
+                    await self._ws.wait_closed()
+                except asyncio.CancelledError:
+                    self.logger.debug("wait_closed cancelled")
+        except Exception:
+            self.logger.exception("Client start failed")

pymax/crud.py

@@ -0,0 +1,99 @@
+from uuid import UUID
+
+from sqlalchemy.engine.base import Engine
+from sqlmodel import Session, SQLModel, create_engine, select
+
+from .models import Auth
+from .static import DeviceType
+
+
+class Database:
+    def __init__(self, workdir: str) -> None:
+        self.workdir = workdir
+        self.engine = self.get_engine(workdir)
+        self.create_all()
+        self._ensure_single_auth()
+
+        self.workdir = workdir
+        self.engine = self.get_engine(workdir)
+        self.create_all()
+        self._ensure_single_auth()
+
+    def create_all(self) -> None:
+        SQLModel.metadata.create_all(self.engine)
+
+    def get_engine(self, workdir: str) -> Engine:
+        return create_engine(f"sqlite:///{workdir}/session.db")
+
+    def get_session(self) -> Session:
+        return Session(bind=self.engine)
+
+    def get_auth_token(self) -> str | None:
+        with self.get_session() as session:
+            return session.exec(select(Auth.token)).first()
+
+    def get_device_id(self) -> UUID:
+        with self.get_session() as session:
+            device_id = session.exec(select(Auth.device_id)).first()
+            if device_id is None:
+                auth = Auth()
+                session.add(auth)
+                session.commit()
+                session.refresh(auth)
+                return auth.device_id
+            return device_id
+
+    def insert_auth(self, auth: Auth) -> Auth:
+        with self.get_session() as session:
+            session.add(auth)
+            session.commit()
+            session.refresh(auth)
+            return auth
+
+    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:
+                auth.token = token
+                session.add(auth)
+                session.commit()
+                session.refresh(auth)
+                return
+
+            existing = session.exec(select(Auth)).first()
+            if existing:
+                existing.device_id = device_id
+                existing.token = token
+                session.add(existing)
+                session.commit()
+                session.refresh(existing)
+                return
+
+            new_auth = Auth(device_id=device_id, token=token)
+            session.add(new_auth)
+            session.commit()
+            session.refresh(new_auth)
+
+    def update(self, auth: Auth) -> Auth:
+        with self.get_session() as session:
+            session.add(auth)
+            session.commit()
+            session.refresh(auth)
+            return auth
+
+    def _ensure_single_auth(self) -> None:
+        with self.get_session() as session:
+            rows = session.exec(select(Auth)).all()
+            if not rows:
+                # Create default Auth with device type from enum
+                auth = Auth(device_type=DeviceType.WEB.value)
+                session.add(auth)
+                session.commit()
+                session.refresh(auth)
+                return
+
+            if len(rows) > 1:
+                keeper = rows[0]
+                for extra in rows[1:]:
+                    session.delete(extra)
+                session.commit()

pymax/exceptions.py

@@ -0,0 +1,20 @@
+class InvalidPhoneError(Exception):
+    """
+    Исключение, вызываемое при неверном формате номера телефона.
+
+    Args:
+        phone (str): Некорректный номер телефона.
+    """
+
+    def __init__(self, phone: str) -> None:
+        super().__init__(f"Invalid phone number format: {phone}")
+
+
+class WebSocketNotConnectedError(Exception):
+    """
+    Исключение, вызываемое при попытке обращения к WebSocket,
+    если соединение не установлено.
+    """
+
+    def __init__(self) -> None:
+        super().__init__("WebSocket is not connected")

pymax/models.py

@@ -0,0 +1,8 @@
+from uuid import UUID, uuid4
+
+from sqlmodel import Field, SQLModel
+
+
+class Auth(SQLModel, table=True):
+    token: str | None = None
+    device_id: UUID = Field(default_factory=uuid4, primary_key=True)

pymax/static.py

@@ -0,0 +1,86 @@
+from enum import Enum, IntEnum
+
+
+class Opcode(IntEnum):
+    PING = 1
+    STATS = 5
+    HANDSHAKE = 6
+    PROFILE = 16
+    REQUEST_CODE = 17
+    SEND_CODE = 18
+    SYNC = 19
+    UNKNOWN_26 = 26
+    SYNC_STICKERS_EMOJIS = 27
+    GET_EMOJIS_BY_ID = 28
+    GET_CONTACTS_INFO = 32
+    GET_LAST_SEEN = 35
+    GET_CHATS_DATA = 48
+    FETCH_HISTORY = 49
+
+    GET_HISTORY = 79
+
+    SEND_MESSAGE = 64
+    EDIT_MESSAGE = 67
+    DELETE_MESSAGE = 68
+
+    NEW_MESSAGE = 128
+
+
+class ChatType(str, Enum):
+    DIALOG = "DIALOG"
+    CHAT = "CHAT"
+    CHANNEL = "CHANNEL"
+
+
+class MessageType(str, Enum):
+    TEXT = "TEXT"
+    SYSTEM = "SYSTEM"
+    SERVICE = "SERVICE"
+
+
+class MessageStatus(str, Enum):
+    SENT = "SENT"
+    DELIVERED = "DELIVERED"
+    READ = "READ"
+    ERROR = "ERROR"
+
+
+class ElementType(str, Enum):
+    TEXT = "text"
+    MENTION = "mention"
+    LINK = "link"
+    EMOJI = "emoji"
+
+
+class AuthType(str, Enum):
+    START_AUTH = "START_AUTH"
+    CHECK_CODE = "CHECK_CODE"
+
+
+class AccessType(str, Enum):
+    PUBLIC = "PUBLIC"
+    PRIVATE = "PRIVATE"
+    SECRET = "SECRET"
+
+
+class DeviceType(str, Enum):
+    WEB = "WEB"
+    ANDROID = "ANDROID"
+    IOS = "IOS"
+
+
+class Constants(Enum):
+    PHONE_REGEX = r"^\+?\d{10,15}$"
+    WEBSOCKET_URI = "wss://ws-api.oneme.ru/websocket"
+    DEFAULT_TIMEOUT = 10.0
+    DEFAULT_USER_AGENT = {
+        "deviceType": "WEB",
+        "locale": "ru",
+        "deviceLocale": "ru",
+        "osVersion": "Linux",
+        "deviceName": "Chrome",
+        "headerUserAgent": "Mozilla/5.0 ...",
+        "appVersion": "25.8.5",
+        "screen": "1080x1920 1.0x",
+        "timezone": "Europe/Moscow",
+    }

pymax/types.py

@@ -0,0 +1,327 @@
+from typing import Any
+
+from .static import AccessType, ChatType, ElementType, MessageStatus, MessageType
+
+
+class Element:
+    def __init__(self, type: ElementType | str, length: int, from_: int | None = None) -> None:
+        self.type = type
+        self.length = length
+        self.from_ = from_
+
+    @classmethod
+    def from_dict(cls, data: dict[Any, Any]) -> "Element":
+        return cls(type=data["type"], length=data["length"], from_=data.get("from"))
+
+    def __repr__(self) -> str:
+        return f"Element(type={self.type!r}, length={self.length!r}, from_={self.from_!r})"
+
+    def __str__(self) -> str:
+        return f"{self.type}({self.length})"
+
+
+class Message:
+    def __init__(
+        self,
+        sender: int | None,
+        elements: list[Element] | None,
+        reaction_info: dict[str, Any] | None,
+        options: int | None,
+        id: int,
+        time: int,
+        text: str,
+        status: MessageStatus | str | None,
+        type: MessageType | str,
+        attaches: list[Any],
+    ) -> None:
+        self.sender = sender
+        self.elements = elements
+        self.options = options
+        self.id = id
+        self.time = time
+        self.text = text
+        self.type = type
+        self.attaches = attaches
+        self.status = status
+        self.reactionInfo = reaction_info
+
+    @classmethod
+    def from_dict(cls, data: dict[Any, Any]) -> "Message":
+        return cls(
+            sender=data.get("sender"),
+            elements=[Element.from_dict(e) for e in data.get("elements", [])],
+            options=data.get("options"),
+            id=data["id"],
+            time=data["time"],
+            text=data["text"],
+            type=data["type"],
+            attaches=data.get("attaches", []),
+            status=data.get("status"),
+            reaction_info=data.get("reactionInfo"),
+        )
+
+    def __repr__(self) -> str:
+        return (
+            f"Message(id={self.id!r}, sender={self.sender!r}, text={self.text!r}, "
+            f"type={self.type!r}, status={self.status!r}, elements={self.elements!r})"
+        )
+
+    def __str__(self) -> str:
+        return f"Message {self.id} from {self.sender}: {self.text}"
+
+
+class Dialog:
+    def __init__(
+        self,
+        cid: int | None,
+        owner: int,
+        has_bots: bool | None,
+        join_time: int,
+        created: int,
+        last_message: Message | None,
+        type: ChatType | str,
+        last_fire_delayed_error_time: int,
+        last_delayed_update_time: int,
+        prev_message_id: str | None,
+        options: dict[str, bool],
+        modified: int,
+        last_event_time: int,
+        id: int,
+        status: str,
+        participants: dict[str, int],
+    ) -> None:
+        self.cid = cid
+        self.owner = owner
+        self.has_bots = has_bots
+        self.join_time = join_time
+        self.created = created
+        self.last_message = last_message
+        self.type = type
+        self.last_fire_delayed_error_time = last_fire_delayed_error_time
+        self.last_delayed_update_time = last_delayed_update_time
+        self.prev_message_id = prev_message_id
+        self.options = options
+        self.modified = modified
+        self.last_event_time = last_event_time
+        self.id = id
+        self.status = status
+        self.participants = participants
+
+    @classmethod
+    def from_dict(cls, data: dict[Any, Any]) -> "Dialog":
+        return cls(
+            cid=data.get("cid"),
+            owner=data["owner"],
+            has_bots=data.get("hasBots"),
+            join_time=data["joinTime"],
+            created=data["created"],
+            last_message=Message.from_dict(data["lastMessage"])
+            if data.get("lastMessage")
+            else None,
+            type=ChatType(data["type"]),
+            last_fire_delayed_error_time=data["lastFireDelayedErrorTime"],
+            last_delayed_update_time=data["lastDelayedUpdateTime"],
+            prev_message_id=data.get("prevMessageId"),
+            options=data.get("options", {}),
+            modified=data["modified"],
+            last_event_time=data["lastEventTime"],
+            id=data["id"],
+            status=data["status"],
+            participants=data["participants"],
+        )
+
+    def __repr__(self) -> str:
+        return f"Dialog(id={self.id!r}, owner={self.owner!r}, type={self.type!r}, last_message={self.last_message!r})"
+
+    def __str__(self) -> str:
+        return f"Dialog {self.id} ({self.type})"
+
+
+class Chat:
+    def __init__(
+        self,
+        participants_count: int,
+        access: AccessType | str,
+        invited_by: int | None,
+        link: str | None,
+        chat_type: ChatType | str,
+        title: str | None,
+        last_fire_delayed_error_time: int,
+        last_delayed_update_time: int,
+        options: dict[str, bool],
+        base_raw_icon_url: str | None,
+        base_icon_url: str | None,
+        description: str | None,
+        modified: int,
+        id_: int,
+        admin_participants: dict[int, dict[Any, Any]],
+        participants: dict[int, int],
+        owner: int,
+        join_time: int,
+        created: int,
+        last_message: Message | None,
+        prev_message_id: str | None,
+        last_event_time: int,
+        messages_count: int,
+        admins: list[int],
+        restrictions: int | None,
+        status: str,
+        cid: int,
+    ) -> None:
+        self.participants_count = participants_count
+        self.access = access
+        self.invited_by = invited_by
+        self.link = link
+        self.type = chat_type
+        self.title = title
+        self.last_fire_delayed_error_time = last_fire_delayed_error_time
+        self.last_delayed_update_time = last_delayed_update_time
+        self.options = options
+        self.base_raw_icon_url = base_raw_icon_url
+        self.base_icon_url = base_icon_url
+        self.description = description
+        self.modified = modified
+        self.id = id_
+        self.admin_participants = admin_participants
+        self.participants = participants
+        self.owner = owner
+        self.join_time = join_time
+        self.created = created
+        self.last_message = last_message
+        self.prev_message_id = prev_message_id
+        self.last_event_time = last_event_time
+        self.messages_count = messages_count
+        self.admins = admins
+        self.restrictions = restrictions
+        self.status = status
+        self.cid = cid
+
+    @classmethod
+    def from_dict(cls, data: dict[Any, Any]) -> "Chat":
+        raw_admins = data.get("adminParticipants", {}) or {}
+        admin_participants: dict[int, dict[Any, Any]] = {int(k): v for k, v in raw_admins.items()}
+        raw_participants = data.get("participants", {}) or {}
+        participants: dict[int, int] = {int(k): v for k, v in raw_participants.items()}
+        last_msg = Message.from_dict(data["lastMessage"]) if data.get("lastMessage") else None
+        return cls(
+            participants_count=data.get("participantsCount", 0),
+            access=AccessType(data.get("access", AccessType.PUBLIC.value)),
+            invited_by=data.get("invitedBy"),
+            link=data.get("link"),
+            base_raw_icon_url=data.get("baseRawIconUrl"),
+            base_icon_url=data.get("baseIconUrl"),
+            description=data.get("description"),
+            chat_type=ChatType(data.get("type", ChatType.CHAT.value)),
+            title=data.get("title"),
+            last_fire_delayed_error_time=data.get("lastFireDelayedErrorTime", 0),
+            last_delayed_update_time=data.get("lastDelayedUpdateTime", 0),
+            options=data.get("options", {}),
+            modified=data.get("modified", 0),
+            id_=data.get("id", 0),
+            admin_participants=admin_participants,
+            participants=participants,
+            owner=data.get("owner", 0),
+            join_time=data.get("joinTime", 0),
+            created=data.get("created", 0),
+            last_message=last_msg,
+            prev_message_id=data.get("prevMessageId"),
+            last_event_time=data.get("lastEventTime", 0),
+            messages_count=data.get("messagesCount", 0),
+            admins=data.get("admins", []),
+            restrictions=data.get("restrictions"),
+            status=data.get("status", ""),
+            cid=data.get("cid", 0),
+        )
+
+    def __repr__(self) -> str:
+        return f"Chat(id={self.id!r}, title={self.title!r}, type={self.type!r})"
+
+    def __str__(self) -> str:
+        return f"{self.title} ({self.type})"
+
+
+class Channel(Chat):
+    def __repr__(self) -> str:
+        return f"Channel(id={self.id!r}, title={self.title!r})"
+
+    def __str__(self) -> str:
+        return f"Channel: {self.title}"
+
+
+class Names:
+    def __init__(self, name: str, first_name: str, last_name: str | None, type: str) -> None:
+        self.name = name
+        self.first_name = first_name
+        self.last_name = last_name
+        self.type = type
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Names":
+        return cls(
+            name=data["name"],
+            first_name=data["firstName"],
+            last_name=data.get("lastName"),
+            type=data["type"],
+        )
+
+    def __repr__(self) -> str:
+        return f"Names(name={self.name!r}, first_name={self.first_name!r}, last_name={self.last_name!r}, type={self.type!r})"
+
+    def __str__(self) -> str:
+        return self.name
+
+
+class User:
+    def __init__(
+        self,
+        account_status: int,
+        update_time: int,
+        id: int,
+        names: list[Names],
+        options: list[str] | None = None,
+        base_url: str | None = None,
+        base_raw_url: str | None = None,
+        photo_id: int | None = None,
+        description: str | None = None,
+        gender: int | None = None,
+        link: str | None = None,
+        web_app: str | None = None,
+        menu_button: dict[str, Any] | None = None,
+    ) -> None:
+        self.account_status = account_status
+        self.update_time = update_time
+        self.id = id
+        self.names = names
+        self.options = options or []
+        self.base_url = base_url
+        self.base_raw_url = base_raw_url
+        self.photo_id = photo_id
+        self.description = description
+        self.gender = gender
+        self.link = link
+        self.web_app = web_app
+        self.menu_button = menu_button
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "User":
+        return cls(
+            account_status=data["accountStatus"],
+            update_time=data["updateTime"],
+            id=data["id"],
+            names=[Names.from_dict(n) for n in data.get("names", [])],
+            options=data.get("options"),
+            base_url=data.get("baseUrl"),
+            base_raw_url=data.get("baseRawUrl"),
+            photo_id=data.get("photoId"),
+            description=data.get("description"),
+            gender=data.get("gender"),
+            link=data.get("link"),
+            web_app=data.get("webApp"),
+            menu_button=data.get("menuButton"),
+        )
+
+    def __repr__(self) -> str:
+        return f"User(id={self.id!r}, names={self.names!r}, status={self.account_status!r})"
+
+    def __str__(self) -> str:
+        return f"User {self.id}: {', '.join(str(n) for n in self.names)}"