maxapi-python 1.1.14__py3-none-any.whl → 1.1.15__py3-none-any.whl

{maxapi_python-1.1.14.dist-info → maxapi_python-1.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.14
+Version: 1.1.15
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/ink-developer/PyMax
 Project-URL: Repository, https://github.com/ink-developer/PyMax
@@ -145,7 +145,7 @@ if __name__ == "__main__":
 
 ## Документация
 
-[WIP](https://ink-developer.github.io/)
+[WIP](https://ink-developer.github.io/PyMax)
 
 ## Лицензия
 

{maxapi_python-1.1.14.dist-info → maxapi_python-1.1.15.dist-info}/RECORD

@@ -1,30 +1,30 @@
 pymax/__init__.py,sha256=jXY_nQKTdCOqXqJWNkyNIudoxfQO5p8wNmZYbuO1Rgs,980
-pymax/core.py,sha256=EpMTja4oUc5BqFzEQiFOdrCruE3XbRg08cR_IettiWI,6567
+pymax/core.py,sha256=Yx8pLJ6s8MfxxaQrw5nbSBaYP5m9yZz51O78bUmK32I,8495
 pymax/crud.py,sha256=wmJh8MPi3L_HbYp7MJP0eXfDcnjgfkLDa9rHAmXtkow,3219
 pymax/exceptions.py,sha256=PWEjx7d70410XMvyVVyQUwR88CTgm8MUQ4RyInTut_M,2046
-pymax/files.py,sha256=NpS7iGA_8EX65u8Tuo0gIWg0c9RnGSOX0HhV6stCtSo,2775
+pymax/files.py,sha256=oKWylKZUPlChWIo2PUHxoq4dcEbg4hAD6ITZCkiN6Xg,3086
 pymax/filters.py,sha256=4hehzyQlyxBxLiEhtSH_KQdFHx8gYaqyIOOD72EsSS0,1536
 pymax/formatting.py,sha256=hhtmakfcQDzQRsAckPunnJOCKY2lFdLeIp8Yw53yY8s,2522
-pymax/interfaces.py,sha256=mRJiAiMjinPbAlHdLplyiS-zSGOdnB1Q8wEANyDrvtk,2477
+pymax/interfaces.py,sha256=onU6yxkU7sUjSeZWlHflONzZiWIspmXYS5Byeuvscvc,3288
 pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
 pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
-pymax/payloads.py,sha256=p2a4cIPuxrdvv82JBztn1tZDAtBExGi-6gZlqVhabaI,5892
+pymax/payloads.py,sha256=BwrZKVwsoBzMLWlskARMsk4xQ8bpnizoPbv_P4ez01Q,6190
 pymax/types.py,sha256=mM2cbdwcevketJ-O1F_jeNe7WvYpooV0F1ojbELDdvE,31141
 pymax/utils.py,sha256=r6Gm-fol6d4LdcdC12j6kQQNi1ywg7WVe24kwPh919A,1455
 pymax/mixins/__init__.py,sha256=xvjcq-lFVHCPss_t8xxXya0OJnsh-owlBqtUlrXSCcw,695
-pymax/mixins/auth.py,sha256=6b83Bd3rn3qQvhFU1GYAFUAXA6faT1S1p2eGqUeJR5E,3764
+pymax/mixins/auth.py,sha256=KlvVjdK3Hj7LeiCCWpGbQ_oPsww6KXQ_L_SxWD-yW3k,6526
 pymax/mixins/channel.py,sha256=2oSLjZp0qm4lKAoFKGivhldajTv0F59_ozfukw7OLTI,4478
 pymax/mixins/group.py,sha256=RAluoZUIh0KCKy37R0efjCMm0kptEjDyjjkDF7c97No,10533
 pymax/mixins/handler.py,sha256=xlfZ9UX1iFaq7gh4E9hxPtGRwj-O2hiqx-C98IxTvQE,3877
-pymax/mixins/message.py,sha256=lHbZI9_dHWZk1wyCW-lpy_S1kkzfisNbfblhVQJZON0,21159
+pymax/mixins/message.py,sha256=-ixtb1TrNrNs3kZUe4fYdPVW3I5WdHiao9w-r_CfO8w,24369
 pymax/mixins/self.py,sha256=TU1lWct5z9rNSsB4aVFial7UME3sfffTWlRAR2jpan8,1196
-pymax/mixins/socket.py,sha256=098W0YQ8A-_iSIgNj6nNtyydZk4eagXyOYcbl3ls0bI,19156
+pymax/mixins/socket.py,sha256=OYhzOOvFgMOW4sR0wGPbObcFeoESd4pOyJAoIWSx6kU,23025
 pymax/mixins/telemetry.py,sha256=kxsecLhDYeRGX5YviyXo4zJKQyjoyPkmPa_-vDrqMQQ,3625
 pymax/mixins/user.py,sha256=CgFrcvpCefEB4bbuxLdcxW3W_ZZs5gupq74S45cU6Es,5538
-pymax/mixins/websocket.py,sha256=LRiJr1LEUK-MLZ9Jx6ZKIRjfngW_kfheIawRKGUR46c,12357
+pymax/mixins/websocket.py,sha256=c0cxyR2QKmv87JIcr4ZIgz-M7Oa5-FgyE5Ex0i5fOYw,16541
 pymax/static/constant.py,sha256=Q1NrmaRj17Gdhk3FmUp3HIwrad1TDorq3wFdQlOCzN8,1027
-pymax/static/enum.py,sha256=IK2xxZQa1YzXKBwSjw-H-LIt1EOhcqfiA7C9JVLjygQ,4454
-maxapi_python-1.1.14.dist-info/METADATA,sha256=S7RmW8BvXL7d_OKDE97bUpHbBN5ykFyXlkX8UkO-RDU,6047
-maxapi_python-1.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-maxapi_python-1.1.14.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
-maxapi_python-1.1.14.dist-info/RECORD,,
+pymax/static/enum.py,sha256=9DgJ8BNwLrqxTqQjpdq1vC8YYgFDlL3VFDOfgHsWQqY,4480
+maxapi_python-1.1.15.dist-info/METADATA,sha256=lt3zV8IXZTKOT-v21Bw90vYl1uRkLtbZTmayergCpV8,6052
+maxapi_python-1.1.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+maxapi_python-1.1.15.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
+maxapi_python-1.1.15.dist-info/RECORD,,

pymax/core.py

@@ -4,6 +4,7 @@ import socket
 import ssl
 import time
 from pathlib import Path
+from typing import Literal
 
 from typing_extensions import override
 
@@ -36,6 +37,12 @@ class MaxClient(ApiMixin, WebSocketMixin):
             процесс логина по номеру телефона.
         host (str, optional): Хост API сервера. По умолчанию Constants.HOST.value.
         port (int, optional): Порт API сервера. По умолчанию Constants.PORT.value.
+        registration (bool, optional): Флаг регистрации нового пользователя. По умолчанию False.
+        first_name (str, optional): Имя пользователя для регистрации. Требуется, если registration=True.
+        last_name (str | None, optional): Фамилия пользователя для регистрации.
+        send_fake_telemetry (bool, optional): Флаг отправки фейковой телеметрии. По умолчанию True.
+        proxy (str | Literal[True] | None, optional): Прокси для подключения к WebSocket.
+            (См. https://websockets.readthedocs.io/en/stable/topics/proxies.html).
 
     Raises:
         InvalidPhoneError: Если формат номера телефона неверный.
@@ -50,7 +57,11 @@ class MaxClient(ApiMixin, WebSocketMixin):
         send_fake_telemetry: bool = True,
         host: str = HOST,
         port: int = PORT,
+        proxy: str | Literal[True] | None = None,
         work_dir: str = ".",
+        registration: bool = False,
+        first_name: str = "",
+        last_name: str | None = None,
         logger: logging.Logger | None = None,
     ) -> None:
         logger = logger or logging.getLogger(f"{__name__}.MaxClient")
@@ -62,12 +73,22 @@ class MaxClient(ApiMixin, WebSocketMixin):
             raise InvalidPhoneError(self.phone)
         self.host: str = host
         self.port: int = port
+        self.registration: bool = registration
+        self.first_name: str = first_name
+        self.last_name: str | None = last_name
+        self.proxy: str | Literal[True] | None = proxy
         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._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._device_id = 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
         self.user_agent = headers
         self._send_fake_telemetry: bool = send_fake_telemetry
@@ -111,6 +132,12 @@ class MaxClient(ApiMixin, WebSocketMixin):
                     await self._recv_task
                 except asyncio.CancelledError:
                     self.logger.debug("recv_task cancelled")
+            if self._outgoing_task:
+                self._outgoing_task.cancel()
+                try:
+                    await self._outgoing_task
+                except asyncio.CancelledError:
+                    self.logger.debug("outgoing_task cancelled")
             if self._ws:
                 await self._ws.close()
             self.is_connected = False
@@ -127,6 +154,11 @@ class MaxClient(ApiMixin, WebSocketMixin):
             self.logger.info("Client starting")
             await self._connect(self.user_agent)
 
+            if self.registration:
+                if not self.first_name:
+                    raise ValueError("First name is required for registration")
+                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(self._device_id, self._token)
 

pymax/files.py

@@ -9,9 +9,7 @@ from typing_extensions import override
 
 
 class BaseFile(ABC):
-    def __init__(
-        self, url: str | None = None, path: str | None = None
-    ) -> None:
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
         self.url = url
         self.path = path
 
@@ -47,9 +45,7 @@ class Photo(BaseFile):
         ".bmp",
     }  # FIXME: костыль ✅
 
-    def __init__(
-        self, url: str | None = None, path: str | None = None
-    ) -> None:
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
         super().__init__(url, path)
 
     def validate_photo(self) -> tuple[str, str] | None:
@@ -71,9 +67,7 @@ class Photo(BaseFile):
             mime_type = mimetypes.guess_type(self.url)[0]
 
             if not mime_type or not mime_type.startswith("image/"):
-                raise ValueError(
-                    f"URL does not appear to be an image: {self.url}"
-                )
+                raise ValueError(f"URL does not appear to be an image: {self.url}")
 
             return (extension[1:], mime_type)
         return None
@@ -90,6 +84,18 @@ class Video(BaseFile):
 
 
 class File(BaseFile):
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
+        self.file_name: str = ""
+        if path:
+            self.file_name = Path(path).name
+        elif url:
+            self.file_name = Path(url).name
+
+        if not self.file_name:
+            raise ValueError("Either url or path must be provided.")
+
+        super().__init__(url, path)
+
     @override
     async def read(self) -> bytes:
         return await super().read()

pymax/interfaces.py

@@ -5,10 +5,12 @@ from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
 from logging import Logger
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 import websockets
 
+from pymax.static.constant import DEFAULT_USER_AGENT
+
 from .filters import Filter
 from .payloads import UserAgentPayload
 from .static.constant import DEFAULT_TIMEOUT
@@ -37,6 +39,10 @@ class ClientProtocol(ABC):
         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._work_dir: str
         self._database_path: Path
         self._ws: websockets.ClientConnection | None = None
@@ -44,7 +50,14 @@ class ClientProtocol(ABC):
         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.user_agent = DEFAULT_USER_AGENT
         self._session_id: int
         self._action_id: int = 0
         self._current_screen: str = "chats_list_tab"
@@ -57,9 +70,7 @@ class ClientProtocol(ABC):
         self._on_message_delete_handlers: list[
             tuple[Callable[[Message], Any], Filter | None]
         ] = []
-        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = (
-            None
-        )
+        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
@@ -77,3 +88,14 @@ class ClientProtocol(ABC):
     @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

pymax/mixins/auth.py

@@ -1,15 +1,15 @@
 import asyncio
 import re
+import sys
 from typing import Any
 
 from pymax.interfaces import ClientProtocol
-from pymax.payloads import RequestCodePayload, SendCodePayload
+from pymax.payloads import RegisterPayload, RequestCodePayload, SendCodePayload
 from pymax.static.constant import PHONE_REGEX
 from pymax.static.enum import AuthType, Opcode
 
 
 class AuthMixin(ClientProtocol):
-
     def __init__(self, token: str | None = None, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self._token = token
@@ -55,9 +55,7 @@ class AuthMixin(ClientProtocol):
                 auth_token_type=AuthType.CHECK_CODE,
             ).model_dump(by_alias=True)
 
-            data = await self._send_and_wait(
-                opcode=Opcode.AUTH, payload=payload
-            )
+            data = await self._send_and_wait(opcode=Opcode.AUTH, payload=payload)
             self.logger.debug(
                 "Send code response opcode=%s seq=%s",
                 data.get("opcode"),
@@ -75,13 +73,15 @@ class AuthMixin(ClientProtocol):
 
     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, "Введите код: ")
+        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")
@@ -97,3 +97,66 @@ class AuthMixin(ClientProtocol):
         self._token = token
         self._database.update_auth_token(self._device_id, self._token)
         self.logger.info("Login successful, token saved to database")
+
+    async def _submit_reg_info(
+        self, first_name: str, last_name: str | None, token: str
+    ) -> dict[str, Any]:
+        try:
+            self.logger.info("Submitting registration info")
+
+            payload = RegisterPayload(
+                first_name=first_name,
+                last_name=last_name,
+                token=token,
+            ).model_dump(by_alias=True)
+
+            data = await self._send_and_wait(
+                opcode=Opcode.AUTH_CONFIRM, payload=payload
+            )
+            self.logger.debug(
+                "Registration info response opcode=%s seq=%s",
+                data.get("opcode"),
+                data.get("seq"),
+            )
+            payload_data = data.get("payload")
+            if isinstance(payload_data, dict):
+                return payload_data
+            else:
+                self.logger.error("Invalid payload data received")
+                raise ValueError("Invalid payload data received")
+        except Exception:
+            self.logger.error("Submit registration info failed", exc_info=True)
+            raise RuntimeError("Submit registration info failed")
+
+    async def _register(self, first_name: str, last_name: str | None = None) -> None:
+        self.logger.info("Starting registration flow")
+
+        request_code_payload = await self._request_code(self.phone)
+        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")
+
+        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")
+
+        registration_response = await self._send_code(code, temp_token)
+        token: str | None = (
+            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")
+
+        data = await self._submit_reg_info(first_name, last_name, token)
+        self._token = data.get("token")
+        if not self._token:
+            self.logger.critical("Failed to register, token not received")
+            raise ValueError("Failed to register, token not received")
+
+        self._database.update_auth_token(self._device_id, self._token)
+        self.logger.info("Registration successful, token saved to database")

pymax/mixins/message.py

@@ -1,13 +1,15 @@
+import asyncio
 import time
 
 import aiohttp
 from aiohttp import ClientSession
 
-from pymax.files import Photo
+from pymax.files import File, Photo
 from pymax.formatting import Formatting
 from pymax.interfaces import ClientProtocol
 from pymax.payloads import (
     AddReactionPayload,
+    AttachFilePayload,
     AttachPhotoPayload,
     DeleteMessagePayload,
     EditMessagePayload,
@@ -22,8 +24,9 @@ from pymax.payloads import (
     ReplyLink,
     SendMessagePayload,
     SendMessagePayloadMessage,
-    UploadPhotoPayload,
+    UploadPayload,
 )
+from pymax.static.constant import DEFAULT_TIMEOUT
 from pymax.static.enum import AttachType, Opcode
 from pymax.types import (
     Attach,
@@ -35,10 +38,70 @@ from pymax.types import (
 
 
 class MessageMixin(ClientProtocol):
+    async def _upload_file(self, file: File) -> None | Attach:
+        try:
+            self.logger.info("Uploading file")
+            payload = UploadPayload().model_dump(by_alias=True)
+            data = await self._send_and_wait(
+                opcode=Opcode.FILE_UPLOAD,
+                payload=payload,
+            )
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Upload file error: %s", error)
+                return None
+
+            url = data.get("payload", {}).get("info", [None])[0].get("url", None)
+            file_id = data.get("payload", {}).get("info", [None])[0].get("fileId", None)
+            if not url or not file_id:
+                self.logger.error("No upload URL or file ID received")
+                return None
+
+            file_bytes = await file.read()
+
+            headers = {
+                "Content-Disposition": f"attachment; filename={file.file_name}",
+                "Content-Range": f"0-{len(file_bytes) - 1}/{len(file_bytes)}",
+            }
+
+            loop = asyncio.get_running_loop()
+            fut: asyncio.Future[dict] = loop.create_future()
+            try:
+                self._file_upload_waiters[int(file_id)] = fut
+            except Exception:
+                self.logger.exception("Failed to register file upload waiter")
+
+            async with (
+                ClientSession() as session,
+                session.post(
+                    url=url,
+                    headers=headers,
+                    data=file_bytes,
+                ) as response,
+            ):
+                if response.status != 200:
+                    self.logger.error(f"Upload failed with status {response.status}")
+                    # cleanup waiter
+                    self._file_upload_waiters.pop(int(file_id), None)
+                    return None
+
+                try:
+                    await asyncio.wait_for(fut, timeout=DEFAULT_TIMEOUT)
+                    return Attach(_type=AttachType.FILE, file_id=file_id)
+                except asyncio.TimeoutError:
+                    self.logger.error(
+                        "Timed out waiting for file processing notification for fileId=%s",
+                        file_id,
+                    )
+                    self._file_upload_waiters.pop(int(file_id), None)
+                    return None
+        except Exception as e:
+            self.logger.exception("Upload file failed: %s", str(e))
+            return None
+
     async def _upload_photo(self, photo: Photo) -> None | Attach:
         try:
             self.logger.info("Uploading photo")
-            payload = UploadPhotoPayload().model_dump(by_alias=True)
+            payload = UploadPayload().model_dump(by_alias=True)
 
             data = await self._send_and_wait(
                 opcode=Opcode.PHOTO_UPLOAD,
@@ -74,9 +137,7 @@ class MessageMixin(ClientProtocol):
                 ) as response,
             ):
                 if response.status != 200:
-                    self.logger.error(
-                        f"Upload failed with status {response.status}"
-                    )
+                    self.logger.error(f"Upload failed with status {response.status}")
                     return None
 
                 result = await response.json()
@@ -99,52 +160,61 @@ class MessageMixin(ClientProtocol):
             self.logger.exception("Upload photo failed: %s", str(e))
             return None
 
+    async def _upload_attachment(self, attach: Photo | File) -> dict | None:
+        if isinstance(attach, Photo):
+            uploaded = await self._upload_photo(attach)
+            if uploaded and uploaded.photo_token:
+                return AttachPhotoPayload(photo_token=uploaded.photo_token).model_dump(
+                    by_alias=True
+                )
+        elif isinstance(attach, File):
+            uploaded = await self._upload_file(attach)
+            if uploaded and uploaded.file_id:
+                return AttachFilePayload(file_id=uploaded.file_id).model_dump(
+                    by_alias=True
+                )
+        self.logger.error(f"Attachment upload failed for {attach}")
+        return None
+
     async def send_message(
         self,
         text: str,
         chat_id: int,
         notify: bool,
-        photo: Photo | None = None,
-        photos: list[Photo] | None = None,
+        attachment: Photo | File | None = None,
+        attachments: list[Photo | File] | None = None,
         reply_to: int | None = None,
+        use_queue: bool = False,
     ) -> Message | None:
         """
         Отправляет сообщение в чат.
         """
         try:
-            self.logger.info(
-                "Sending message to chat_id=%s notify=%s", chat_id, notify
-            )
-            if photos and photo:
-                self.logger.warning(
-                    "Both photo and photos provided; using photos"
-                )
-                photo = None
+            self.logger.info("Sending message to chat_id=%s notify=%s", chat_id, notify)
+            if attachments and attachment:
+                self.logger.warning("Both photo and photos provided; using photos")
+                attachment = None
             attaches = []
-            if photo:
-                self.logger.info("Uploading photo for message")
-                attach = await self._upload_photo(photo)
-                if not attach or not attach.photo_token:
-                    self.logger.error("Photo upload failed, message not sent")
+            if attachment:
+                self.logger.info("Uploading attachment for message")
+                result = await self._upload_attachment(attachment)
+                if not result:
+                    self.logger.error("Attachment upload failed, message not sent")
                     return None
-                attaches = [
-                    AttachPhotoPayload(
-                        photo_token=attach.photo_token
-                    ).model_dump(by_alias=True)
-                ]
-            elif photos:
-                self.logger.info("Uploading multiple photos for message")
-                for p in photos:
-                    attach = await self._upload_photo(p)
-                    if attach and attach.photo_token:
-                        attaches.append(
-                            AttachPhotoPayload(
-                                photo_token=attach.photo_token
-                            ).model_dump(by_alias=True)
-                        )
+                attaches.append(result)
+
+            elif attachments:
+                self.logger.info("Uploading multiple attachments for message")
+                for p in attachments:
+                    result = await self._upload_attachment(p)
+                    if result:
+                        attaches.append(result)
+                    else:
+                        self.logger.error("One of attachments upload failed")
+
                 if not attaches:
                     self.logger.error(
-                        "All photo uploads failed, message not sent"
+                        "All attachments uploads failed, message not sent"
                     )
                     return None
 
@@ -165,28 +235,27 @@ class MessageMixin(ClientProtocol):
                     cid=int(time.time() * 1000),
                     elements=elements,
                     attaches=attaches,
-                    link=(
-                        ReplyLink(message_id=str(reply_to))
-                        if reply_to
-                        else None
-                    ),
+                    link=(ReplyLink(message_id=str(reply_to)) if reply_to else None),
                 ),
                 notify=notify,
             ).model_dump(by_alias=True)
 
-            data = await self._send_and_wait(
-                opcode=Opcode.MSG_SEND, payload=payload
-            )
-            if error := data.get("payload", {}).get("error"):
-                self.logger.error("Send message error: %s", error)
+            if use_queue:
+                await self._queue_message(opcode=Opcode.MSG_SEND, payload=payload)
+                self.logger.debug("Message queued for sending")
                 return None
-            msg = (
-                Message.from_dict(data["payload"])
-                if data.get("payload")
-                else None
-            )
-            self.logger.debug("send_message result: %r", msg)
-            return msg
+            else:
+                data = await self._send_and_wait(
+                    opcode=Opcode.MSG_SEND, payload=payload
+                )
+                if error := data.get("payload", {}).get("error"):
+                    self.logger.error("Send message error: %s", error)
+                    return None
+                msg = (
+                    Message.from_dict(data["payload"]) 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
@@ -196,47 +265,39 @@ class MessageMixin(ClientProtocol):
         chat_id: int,
         message_id: int,
         text: str,
-        photo: Photo | None = None,
-        photos: list[Photo] | None = None,
+        attachment: Photo | None = None,
+        attachments: list[Photo] | None = None,
+        use_queue: bool = False,
     ) -> Message | None:
-        """
-        Редактирует сообщение.
-        """
         try:
             self.logger.info(
                 "Editing message chat_id=%s message_id=%s", chat_id, message_id
             )
 
-            if photos and photo:
-                self.logger.warning(
-                    "Both photo and photos provided; using photos"
-                )
-                photo = None
+            if attachments and attachment:
+                self.logger.warning("Both photo and photos provided; using photos")
+                attachment = None
             attaches = []
-            if photo:
-                self.logger.info("Uploading photo for message")
-                attach = await self._upload_photo(photo)
-                if not attach or not attach.photo_token:
-                    self.logger.error("Photo upload failed, message not sent")
+            if attachment:
+                self.logger.info("Uploading attachment for message")
+                result = await self._upload_attachment(attachment)
+                if not result:
+                    self.logger.error("Attachment upload failed, message not sent")
                     return None
-                attaches = [
-                    AttachPhotoPayload(
-                        photo_token=attach.photo_token
-                    ).model_dump(by_alias=True)
-                ]
-            elif photos:
-                self.logger.info("Uploading multiple photos for message")
-                for p in photos:
-                    attach = await self._upload_photo(p)
-                    if attach and attach.photo_token:
-                        attaches.append(
-                            AttachPhotoPayload(
-                                photo_token=attach.photo_token
-                            ).model_dump(by_alias=True)
-                        )
+                attaches.append(result)
+
+            elif attachments:
+                self.logger.info("Uploading multiple attachments for message")
+                for p in attachment:
+                    result = await self._upload_attachment(p)
+                    if result:
+                        attaches.append(result)
+                    else:
+                        self.logger.error("One of attachments upload failed")
+
                 if not attaches:
                     self.logger.error(
-                        "All photo uploads failed, message not sent"
+                        "All attachments uploads failed, message not sent"
                     )
                     return None
 
@@ -257,24 +318,32 @@ class MessageMixin(ClientProtocol):
                 elements=elements,
                 attaches=attaches,
             ).model_dump(by_alias=True)
-            data = await self._send_and_wait(
-                opcode=Opcode.MSG_EDIT, payload=payload
-            )
-            if error := data.get("payload", {}).get("error"):
-                self.logger.error("Edit message error: %s", error)
-            msg = (
-                Message.from_dict(data["payload"])
-                if data.get("payload")
-                else None
-            )
-            self.logger.debug("edit_message result: %r", msg)
-            return msg
+
+            if use_queue:
+                await self._queue_message(opcode=Opcode.MSG_EDIT, payload=payload)
+                self.logger.debug("Edit message queued for sending")
+                return None
+            else:
+                data = await self._send_and_wait(
+                    opcode=Opcode.MSG_EDIT, payload=payload
+                )
+                if error := data.get("payload", {}).get("error"):
+                    self.logger.error("Edit message error: %s", error)
+                msg = (
+                    Message.from_dict(data["payload"]) 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
+        self,
+        chat_id: int,
+        message_ids: list[int],
+        for_me: bool,
+        use_queue: bool = False,
     ) -> bool:
         """
         Удаляет сообщения.
@@ -291,14 +360,19 @@ class MessageMixin(ClientProtocol):
                 chat_id=chat_id, message_ids=message_ids, for_me=for_me
             ).model_dump(by_alias=True)
 
-            data = await self._send_and_wait(
-                opcode=Opcode.MSG_DELETE, 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
+            if use_queue:
+                await self._queue_message(opcode=Opcode.MSG_DELETE, payload=payload)
+                self.logger.debug("Delete message queued for sending")
+                return True
+            else:
+                data = await self._send_and_wait(
+                    opcode=Opcode.MSG_DELETE, 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
@@ -324,9 +398,7 @@ class MessageMixin(ClientProtocol):
                 pin_message_id=message_id,
             ).model_dump(by_alias=True)
 
-            data = await self._send_and_wait(
-                opcode=Opcode.CHAT_UPDATE, payload=payload
-            )
+            data = await self._send_and_wait(opcode=Opcode.CHAT_UPDATE, payload=payload)
             if error := data.get("payload", {}).get("error"):
                 self.logger.error("Pin message error: %s", error)
                 return False
@@ -376,8 +448,7 @@ class MessageMixin(ClientProtocol):
                 return None
 
             messages = [
-                Message.from_dict(msg)
-                for msg in data["payload"].get("messages", [])
+                Message.from_dict(msg) for msg in data["payload"].get("messages", [])
             ]
             self.logger.debug("History fetched: %d messages", len(messages))
             return messages
@@ -405,9 +476,7 @@ class MessageMixin(ClientProtocol):
             url (str): Ссылка на видео
         """
         try:
-            self.logger.info(
-                "Getting video_id=%s message_id=%s", video_id, message_id
-            )
+            self.logger.info("Getting video_id=%s message_id=%s", video_id, message_id)
 
             if self.is_connected and self._socket is not None:
                 payload = GetVideoPayload(
@@ -420,18 +489,14 @@ class MessageMixin(ClientProtocol):
                     video_id=video_id,
                 ).model_dump(by_alias=True)
 
-            data = await self._send_and_wait(
-                opcode=Opcode.VIDEO_PLAY, payload=payload
-            )
+            data = await self._send_and_wait(opcode=Opcode.VIDEO_PLAY, payload=payload)
 
             if error := data.get("payload", {}).get("error"):
                 self.logger.error("Get video error: %s", error)
                 return None
 
             video = (
-                VideoRequest.from_dict(data["payload"])
-                if data.get("payload")
-                else None
+                VideoRequest.from_dict(data["payload"]) if data.get("payload") else None
             )
             self.logger.debug("result: %r", video)
             return video
@@ -458,9 +523,7 @@ class MessageMixin(ClientProtocol):
             url (str): Ссылка на скачивание файла
         """
         try:
-            self.logger.info(
-                "Getting file_id=%s message_id=%s", file_id, message_id
-            )
+            self.logger.info("Getting file_id=%s message_id=%s", file_id, message_id)
             if self.is_connected and self._socket is not None:
                 payload = GetFilePayload(
                     chat_id=chat_id, message_id=message_id, file_id=file_id
@@ -480,9 +543,7 @@ class MessageMixin(ClientProtocol):
                 return None
 
             file = (
-                FileRequest.from_dict(data["payload"])
-                if data.get("payload")
-                else None
+                FileRequest.from_dict(data["payload"]) if data.get("payload") else None
             )
             self.logger.debug(" result: %r", file)
             return file

pymax/mixins/socket.py

@@ -2,6 +2,7 @@ import asyncio
 import socket
 import ssl
 import sys
+import time
 from collections.abc import Callable
 from typing import Any
 
@@ -116,8 +117,10 @@ Socket connections may be unstable, SSL issues are possible.
             self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
             self.is_connected = True
             self._incoming = asyncio.Queue()
+            self._outgoing = asyncio.Queue()
             self._pending = {}
             self._recv_task = asyncio.create_task(self._recv_loop())
+            self._outgoing_task = asyncio.create_task(self._outgoing_loop())
             self.logger.info("Socket connected, starting handshake")
             return await self._handshake(user_agent)
         except Exception as e:
@@ -431,6 +434,96 @@ Socket connections may be unstable, SSL issues are possible.
         finally:
             self._pending.pop(msg["seq"], None)
 
+    async def _outgoing_loop(self) -> None:
+        while self.is_connected:
+            try:
+                if self._outgoing is None:
+                    await asyncio.sleep(0.1)
+                    continue
+                
+                if self._circuit_breaker:
+                    if time.time() - self._last_error_time > 60:
+                        self._circuit_breaker = False
+                        self._error_count = 0
+                        self.logger.info("Circuit breaker reset (socket)")
+                    else:
+                        await asyncio.sleep(5)
+                        continue
+                
+                message = await self._outgoing.get() # TODO: persistent msg q mb?
+                if not message:
+                    continue
+                
+                retry_count = message.get("retry_count", 0)
+                max_retries = message.get("max_retries", 3)
+                
+                try:
+                    await self._send_and_wait(
+                        opcode=message["opcode"],
+                        payload=message["payload"],
+                        cmd=message.get("cmd", 0),
+                        timeout=message.get("timeout", 10.0)
+                    )
+                    self.logger.debug("Message sent successfully from queue (socket)")
+                    self._error_count = max(0, self._error_count - 1)
+                except Exception as e:
+                    self._error_count += 1
+                    self._last_error_time = time.time()
+                    
+                    if self._error_count > 10: # TODO: export to constant
+                        self._circuit_breaker = True
+                        self.logger.warning("Circuit breaker activated due to %d consecutive errors (socket)", self._error_count)
+                        await self._outgoing.put(message)
+                        continue
+                    
+                    retry_delay = self._get_retry_delay(e, retry_count)
+                    self.logger.warning("Failed to send message from queue (socket): %s (delay: %ds)", e, retry_delay)
+                    
+                    if retry_count < max_retries:
+                        message["retry_count"] = retry_count + 1
+                        await asyncio.sleep(retry_delay)
+                        await self._outgoing.put(message)
+                    else:
+                        self.logger.error("Message failed after %d retries, dropping (socket)", max_retries)
+                        
+            except Exception:
+                self.logger.exception("Error in outgoing loop (socket)")
+                await asyncio.sleep(1)
+
+    def _get_retry_delay(self, error: Exception, retry_count: int) -> float: # TODO: tune delays later
+        if isinstance(error, (ConnectionError, OSError, ssl.SSLError)):
+            return 1.0
+        elif isinstance(error, TimeoutError):
+            return 5.0
+        elif isinstance(error, SocketNotConnectedError):
+            return 2.0
+        else:
+            return 2 ** retry_count
+
+    async def _queue_message(
+        self,
+        opcode: int,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = 10.0,
+        max_retries: int = 3,
+    ) -> None:
+        if self._outgoing is None:
+            self.logger.warning("Outgoing queue not initialized (socket)")
+            return
+            
+        message = {
+            "opcode": opcode,
+            "payload": payload,
+            "cmd": cmd,
+            "timeout": timeout,
+            "retry_count": 0,
+            "max_retries": max_retries,
+        }
+        
+        await self._outgoing.put(message)
+        self.logger.debug("Message queued for sending (socket)")
+
     async def _sync(self) -> None:
         try:
             self.logger.info("Starting initial sync (socket)")

pymax/mixins/websocket.py

@@ -1,5 +1,6 @@
 import asyncio
 import json
+import time
 from collections.abc import Callable
 from typing import Any
 
@@ -21,7 +22,6 @@ from pymax.types import Channel, Chat, Dialog, Me, Message
 
 
 class WebSocketMixin(ClientProtocol):
-
     def __init__(self, token: str | None = None, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self._token = token
@@ -29,9 +29,7 @@ class WebSocketMixin(ClientProtocol):
     @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"
-            )
+            self.logger.critical("WebSocket not connected when access attempted")
             raise WebSocketNotConnectedError
         return self._ws
 
@@ -71,12 +69,15 @@ class WebSocketMixin(ClientProtocol):
             self._ws = await websockets.connect(
                 self.uri,
                 origin=WEBSOCKET_ORIGIN,
-                user_agent_header=user_agent.headerUserAgent,
+                user_agent_header=user_agent.header_user_agent,
+                proxy=self.proxy,
             )
             self.is_connected = True
             self._incoming = asyncio.Queue()
+            self._outgoing = asyncio.Queue()
             self._pending = {}
             self._recv_task = asyncio.create_task(self._recv_loop())
+            self._outgoing_task = asyncio.create_task(self._outgoing_loop())
             self.logger.info("WebSocket connected, starting handshake")
             return await self._handshake(user_agent)
         except Exception as e:
@@ -141,9 +142,7 @@ class WebSocketMixin(ClientProtocol):
 
                 if fut and not fut.done():
                     fut.set_result(data)
-                    self.logger.debug(
-                        "Matched response for pending seq=%s", seq
-                    )
+                    self.logger.debug("Matched response for pending seq=%s", seq)
                 else:
                     if self._incoming is not None:
                         try:
@@ -154,6 +153,20 @@ class WebSocketMixin(ClientProtocol):
                                 data.get("seq"),
                             )
 
+                    try:  # TODO: переделать, временное решение
+                        if data.get("opcode") == Opcode.NOTIF_ATTACH:
+                            file_id = data.get("payload", {}).get("fileId", None)
+                            if isinstance(file_id, int):
+                                fut = self._file_upload_waiters.pop(file_id, None)
+                                if fut and not fut.done():
+                                    fut.set_result(data)
+                                    self.logger.debug(
+                                        "Fulfilled file upload waiter for fileId=%s",
+                                        file_id,
+                                    )
+                    except Exception:
+                        self.logger.exception("Error handling file upload notification")
+
                     if (
                         data.get("opcode") == Opcode.NOTIF_MESSAGE.value
                         and self._on_message_handlers
@@ -168,23 +181,17 @@ class WebSocketMixin(ClientProtocol):
                                             for (
                                                 edit_handler,
                                                 edit_filter,
-                                            ) in (
-                                                self._on_message_edit_handlers
-                                            ):
+                                            ) in self._on_message_edit_handlers:
                                                 await self._process_message_handler(
                                                     edit_handler,
                                                     edit_filter,
                                                     msg,
                                                 )
-                                        elif (
-                                            msg.status == MessageStatus.REMOVED
-                                        ):
+                                        elif msg.status == MessageStatus.REMOVED:
                                             for (
                                                 remove_handler,
                                                 remove_filter,
-                                            ) in (
-                                                self._on_message_delete_handlers
-                                            ):
+                                            ) in self._on_message_delete_handlers:
                                                 await self._process_message_handler(
                                                     remove_handler,
                                                     remove_filter,
@@ -194,19 +201,13 @@ class WebSocketMixin(ClientProtocol):
                                         handler, filter, msg
                                     )
                         except Exception:
-                            self.logger.exception(
-                                "Error in on_message_handler"
-                            )
+                            self.logger.exception("Error in on_message_handler")
 
             except websockets.exceptions.ConnectionClosed:
-                self.logger.info(
-                    "WebSocket connection closed; exiting recv loop"
-                )
+                self.logger.info("WebSocket connection closed; exiting recv loop")
                 break
             except Exception:
-                self.logger.exception(
-                    "Error in recv_loop; backing off briefly"
-                )
+                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:
@@ -218,6 +219,30 @@ class WebSocketMixin(ClientProtocol):
             self.logger.exception("Error retrieving task exception: %s", e)
             pass
 
+    async def _queue_message(
+        self,
+        opcode: int,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = DEFAULT_TIMEOUT,
+        max_retries: int = 3,
+    ) -> None:
+        if self._outgoing is None:
+            self.logger.warning("Outgoing queue not initialized")
+            return
+
+        message = {
+            "opcode": opcode,
+            "payload": payload,
+            "cmd": cmd,
+            "timeout": timeout,
+            "retry_count": 0,
+            "max_retries": max_retries,
+        }
+
+        await self._outgoing.put(message)
+        self.logger.debug("Message queued for sending")
+
     @override
     async def _send_and_wait(
         self,
@@ -255,6 +280,81 @@ class WebSocketMixin(ClientProtocol):
         finally:
             self._pending.pop(msg["seq"], None)
 
+    async def _outgoing_loop(self) -> None:
+        while self.is_connected:
+            try:
+                if self._outgoing is None:
+                    await asyncio.sleep(0.1)
+                    continue
+
+                if self._circuit_breaker:
+                    if time.time() - self._last_error_time > 60:
+                        self._circuit_breaker = False
+                        self._error_count = 0
+                        self.logger.info("Circuit breaker reset")
+                    else:
+                        await asyncio.sleep(5)
+                        continue
+
+                message = await self._outgoing.get()  # TODO: persistent msg q mb?
+                if not message:
+                    continue
+
+                retry_count = message.get("retry_count", 0)
+                max_retries = message.get("max_retries", 3)
+
+                try:
+                    await self._send_and_wait(
+                        opcode=message["opcode"],
+                        payload=message["payload"],
+                        cmd=message.get("cmd", 0),
+                        timeout=message.get("timeout", DEFAULT_TIMEOUT),
+                    )
+                    self.logger.debug("Message sent successfully from queue")
+                    self._error_count = max(0, self._error_count - 1)
+                except Exception as e:
+                    self._error_count += 1
+                    self._last_error_time = time.time()
+
+                    if self._error_count > 10:
+                        self._circuit_breaker = True
+                        self.logger.warning(
+                            "Circuit breaker activated due to %d consecutive errors",
+                            self._error_count,
+                        )
+                        await self._outgoing.put(message)
+                        continue
+
+                    retry_delay = self._get_retry_delay(e, retry_count)
+                    self.logger.warning(
+                        "Failed to send message from queue: %s (delay: %ds)",
+                        e,
+                        retry_delay,
+                    )
+
+                    if retry_count < max_retries:
+                        message["retry_count"] = retry_count + 1
+                        await asyncio.sleep(retry_delay)
+                        await self._outgoing.put(message)
+                    else:
+                        self.logger.error(
+                            "Message failed after %d retries, dropping", max_retries
+                        )
+
+            except Exception:
+                self.logger.exception("Error in outgoing loop")
+                await asyncio.sleep(1)
+
+    def _get_retry_delay(self, error: Exception, retry_count: int) -> float:
+        if isinstance(error, (ConnectionError, OSError)):
+            return 1.0
+        elif isinstance(error, TimeoutError):
+            return 5.0
+        elif isinstance(error, WebSocketNotConnectedError):
+            return 2.0
+        else:
+            return 2**retry_count
+
     async def _sync(self) -> None:
         self.logger.info("Starting initial sync")
 
@@ -269,9 +369,7 @@ class WebSocketMixin(ClientProtocol):
         ).model_dump(by_alias=True)
 
         try:
-            data = await self._send_and_wait(
-                opcode=Opcode.LOGIN, payload=payload
-            )
+            data = await self._send_and_wait(opcode=Opcode.LOGIN, payload=payload)
             raw_payload = data.get("payload", {})
 
             if error := raw_payload.get("error"):

pymax/payloads.py

@@ -64,7 +64,7 @@ class ReplyLink(CamelModel):
     message_id: str
 
 
-class UploadPhotoPayload(CamelModel):
+class UploadPayload(CamelModel):
     count: int = 1
 
 
@@ -73,6 +73,11 @@ class AttachPhotoPayload(CamelModel):
     photo_token: str
 
 
+class AttachFilePayload(CamelModel):
+    type: AttachType = Field(default=AttachType.FILE, alias="_type")
+    file_id: int
+
+
 class MessageElement(CamelModel):
     type: str
     from_: int = Field(..., alias="from")
@@ -83,7 +88,7 @@ class SendMessagePayloadMessage(CamelModel):
     text: str
     cid: int
     elements: list[MessageElement]
-    attaches: list[AttachPhotoPayload]
+    attaches: list[AttachPhotoPayload | AttachFilePayload]
     link: ReplyLink | None = None
 
 
@@ -263,14 +268,14 @@ class RemoveReactionPayload(CamelModel):
     message_id: str
 
 
-class UserAgentPayload(BaseModel):
-    deviceType: str = Field(default=DEFAULT_DEVICE_TYPE)
+class UserAgentPayload(CamelModel):
+    device_type: str = Field(default=DEFAULT_DEVICE_TYPE)
     locale: str = Field(default=DEFAULT_LOCALE)
-    deviceLocale: str = Field(default=DEFAULT_DEVICE_LOCALE)
-    osVersion: str = Field(default=DEFAULT_OS_VERSION)
-    deviceName: str = Field(default=DEFAULT_DEVICE_NAME)
-    headerUserAgent: str = Field(default=DEFAULT_USER_AGENT)
-    appVersion: str = Field(default=DEFAULT_APP_VERSION)
+    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)
 
@@ -278,3 +283,10 @@ class UserAgentPayload(BaseModel):
 class ReworkInviteLinkPayload(CamelModel):
     revoke_private_link: bool = True
     chat_id: int
+
+
+class RegisterPayload(CamelModel):
+    last_name: str | None = None
+    first_name: str
+    token: str
+    token_type: AuthType = AuthType.REGISTER

pymax/static/enum.py

@@ -170,6 +170,7 @@ class ElementType(StrEnum):
 class AuthType(StrEnum):
     START_AUTH = "START_AUTH"
     CHECK_CODE = "CHECK_CODE"
+    REGISTER = "REGISTER"
 
 
 class AccessType(StrEnum):