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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.13
+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.15.dist-info/RECORD

@@ -0,0 +1,30 @@
+pymax/__init__.py,sha256=jXY_nQKTdCOqXqJWNkyNIudoxfQO5p8wNmZYbuO1Rgs,980
+pymax/core.py,sha256=Yx8pLJ6s8MfxxaQrw5nbSBaYP5m9yZz51O78bUmK32I,8495
+pymax/crud.py,sha256=wmJh8MPi3L_HbYp7MJP0eXfDcnjgfkLDa9rHAmXtkow,3219
+pymax/exceptions.py,sha256=PWEjx7d70410XMvyVVyQUwR88CTgm8MUQ4RyInTut_M,2046
+pymax/files.py,sha256=oKWylKZUPlChWIo2PUHxoq4dcEbg4hAD6ITZCkiN6Xg,3086
+pymax/filters.py,sha256=4hehzyQlyxBxLiEhtSH_KQdFHx8gYaqyIOOD72EsSS0,1536
+pymax/formatting.py,sha256=hhtmakfcQDzQRsAckPunnJOCKY2lFdLeIp8Yw53yY8s,2522
+pymax/interfaces.py,sha256=onU6yxkU7sUjSeZWlHflONzZiWIspmXYS5Byeuvscvc,3288
+pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
+pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
+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=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=-ixtb1TrNrNs3kZUe4fYdPVW3I5WdHiao9w-r_CfO8w,24369
+pymax/mixins/self.py,sha256=TU1lWct5z9rNSsB4aVFial7UME3sfffTWlRAR2jpan8,1196
+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=c0cxyR2QKmv87JIcr4ZIgz-M7Oa5-FgyE5Ex0i5fOYw,16541
+pymax/static/constant.py,sha256=Q1NrmaRj17Gdhk3FmUp3HIwrad1TDorq3wFdQlOCzN8,1027
+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/__init__.py

@@ -3,16 +3,18 @@ Python wrapper для API мессенджера Max
 """
 
 from .core import (
-    InvalidPhoneError,
     MaxClient,
     SocketMaxClient,
+)
+from .exceptions import (
+    InvalidPhoneError,
+    LoginError,
     WebSocketNotConnectedError,
 )
-from .static import (
+from .static.enum import (
     AccessType,
     AuthType,
     ChatType,
-    Constants,
     DeviceType,
     ElementType,
     MessageStatus,
@@ -38,13 +40,14 @@ __all__ = [
     "Channel",
     "Chat",
     "ChatType",
-    "Constants",
     "DeviceType",
     "Dialog",
     "Element",
     "ElementType",
     # Исключения
     "InvalidPhoneError",
+    "LoginError",
+    "WebSocketNotConnectedError",
     # Клиент
     "MaxClient",
     "Message",
@@ -53,5 +56,4 @@ __all__ = [
     "Opcode",
     "SocketMaxClient",
     "User",
-    "WebSocketNotConnectedError",
 ]

pymax/core.py

@@ -3,22 +3,20 @@ import logging
 import socket
 import ssl
 import time
-from collections.abc import Awaitable, Callable
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import Literal
 
 from typing_extensions import override
 
 from .crud import Database
-from .exceptions import InvalidPhoneError, WebSocketNotConnectedError
+from .exceptions import InvalidPhoneError
 from .mixins import ApiMixin, SocketMixin, WebSocketMixin
-from .static import Constants
-from .types import Channel, Chat, Dialog, Me, Message, User
-
-if TYPE_CHECKING:
-    import websockets
-
-    from .filters import Filter
+from .payloads import UserAgentPayload
+from .static.constant import (
+    HOST,
+    PORT,
+    WEBSOCKET_URI,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -34,12 +32,17 @@ class MaxClient(ApiMixin, WebSocketMixin):
         work_dir (str, optional): Рабочая директория для хранения базы данных. По умолчанию ".".
         logger (logging.Logger | None): Пользовательский логгер. Если не передан — используется
             логгер модуля с именем f"{__name__}.MaxClient".
-        headers (dict[str, Any] | None): Заголовки для подключения к WebSocket. По умолчанию
-            Constants.DEFAULT_USER_AGENT.value.
+        headers (UserAgentPayload): Заголовки для подключения к WebSocket.
         token (str | None, optional): Токен авторизации. Если не передан, будет выполнен
             процесс логина по номеру телефона.
         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: Если формат номера телефона неверный.
@@ -48,57 +51,49 @@ class MaxClient(ApiMixin, WebSocketMixin):
     def __init__(
         self,
         phone: str,
-        uri: str = Constants.WEBSOCKET_URI.value,
-        headers: dict[str, Any] | None = Constants.DEFAULT_USER_AGENT.value,
+        uri: str = WEBSOCKET_URI,
+        headers: UserAgentPayload = UserAgentPayload(),
         token: str | None = None,
         send_fake_telemetry: bool = True,
-        host: str = Constants.HOST.value,
-        port: int = Constants.PORT.value,
+        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")
+        ApiMixin.__init__(self, token=token, logger=logger)
+        WebSocketMixin.__init__(self, token=token, logger=logger)
         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.me: Me | None = None
-        self._users: dict[int, User] = {}
         if not self._check_phone():
             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._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._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
         self._session_id: int = int(time.time() * 1000)
         self._action_id: int = 1
-        self._current_screen: str = "chats_list_tab"
-
-        self._on_message_handlers: list[
-            tuple[Callable[[Message], Any], Filter | None]
-        ] = []
-        self._on_message_edit_handlers: list[
-            tuple[Callable[[Message], Any], Filter | None]
-        ] = []
-        self._on_message_delete_handlers: list[
-            tuple[Callable[[Message], Any], Filter | None]
-        ] = []
-        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
-        self._background_tasks: set[asyncio.Task[Any]] = set()
         self._ssl_context = ssl.create_default_context()
         self._ssl_context.set_ciphers("DEFAULT")
         self._ssl_context.check_hostname = True
@@ -106,16 +101,14 @@ class MaxClient(ApiMixin, WebSocketMixin):
         self._ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
         self._ssl_context.load_default_certs()
         self._socket: socket.socket | None = None
-        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
+            "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(
@@ -139,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
@@ -155,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)
 
@@ -170,18 +174,12 @@ class MaxClient(ApiMixin, WebSocketMixin):
                     await result
 
             ping_task = asyncio.create_task(self._send_interactive_ping())
+            ping_task.add_done_callback(self._log_task_exception)
             self._background_tasks.add(ping_task)
             if self._send_fake_telemetry:
                 telemetry_task = asyncio.create_task(self._start())
+                telemetry_task.add_done_callback(self._log_task_exception)
                 self._background_tasks.add(telemetry_task)
-                telemetry_task.add_done_callback(
-                    lambda t: self._background_tasks.discard(t)
-                    or self._log_task_exception(t)
-                )
-            ping_task.add_done_callback(
-                lambda t: self._background_tasks.discard(t)
-                or self._log_task_exception(t)
-            )
             await self._wait_forever()
         except Exception:
             self.logger.exception("Client start failed")

pymax/crud.py

@@ -1,10 +1,11 @@
+from typing import cast
 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
+from .static.enum import DeviceType
 
 
 class Database:
@@ -14,11 +15,6 @@ class Database:
         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)
 
@@ -30,11 +26,14 @@ class Database:
 
     def get_auth_token(self) -> str | None:
         with self.get_session() as session:
-            return session.exec(select(Auth.token)).first()
+            token = cast(str | None, session.exec(select(Auth.token)).first())
+            return token
 
     def get_device_id(self) -> UUID:
         with self.get_session() as session:
-            device_id = session.exec(select(Auth.device_id)).first()
+            device_id = cast(
+                UUID | None, session.exec(select(Auth.device_id)).first()
+            )
             if device_id is None:
                 auth = Auth()
                 session.add(auth)
@@ -52,7 +51,9 @@ class Database:
 
     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()
+            auth = session.exec(
+                select(Auth).where(Auth.device_id == device_id)
+            ).first()
             if auth:
                 auth.token = token
                 session.add(auth)

pymax/exceptions.py

@@ -46,3 +46,21 @@ class LoginError(Exception):
 
     def __init__(self, message: str) -> None:
         super().__init__(f"Login error: {message}")
+
+
+class ResponseError(Exception):
+    """
+    Исключение, вызываемое при ошибке в ответе от сервера.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(f"Response error: {message}")
+
+
+class ResponseStructureError(Exception):
+    """
+    Исключение, вызываемое при неверной структуре ответа от сервера.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(f"Response structure error: {message}")

pymax/files.py

@@ -22,7 +22,10 @@ class BaseFile(ABC):
     @abstractmethod
     async def read(self) -> bytes:
         if self.url:
-            async with ClientSession() as session, session.get(self.url) as response:
+            async with (
+                ClientSession() as session,
+                session.get(self.url) as response,
+            ):
                 response.raise_for_status()
                 return await response.read()
         elif self.path:
@@ -81,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/filters.py

@@ -1,4 +1,4 @@
-from .static import MessageStatus, MessageType
+from .static.enum import MessageStatus, MessageType
 from .types import Message
 
 
@@ -30,13 +30,18 @@ class Filter:
             text not in message.text for text in self.text
         ):
             return False
-        if self.text_contains is not None and self.text_contains not in message.text:
+        if (
+            self.text_contains is not None
+            and self.text_contains not in message.text
+        ):
             return False
         if self.status is not None and message.status != self.status:
             return False
         if self.type is not None and message.type != self.type:
             return False
-        if self.reaction_info is not None and message.reactionInfo is None:  # noqa: SIM103
+        if (
+            self.reaction_info is not None and message.reactionInfo is None
+        ):  # noqa: SIM103
             return False
 
         return True

pymax/formatting.py

@@ -1,6 +1,6 @@
 import re
 
-from pymax.static import FormattingType
+from pymax.static.enum import FormattingType
 from pymax.types import Element
 
 
@@ -46,9 +46,9 @@ class Formatting:
 
             if inner_text is not None and fmt_type is not None:
                 next_pos = match.end()
-                has_newline = (next_pos < len(text) and text[next_pos] == "\n") or (
-                    next_pos == len(text)
-                )
+                has_newline = (
+                    next_pos < len(text) and text[next_pos] == "\n"
+                ) or (next_pos == len(text))
 
                 length = len(inner_text) + (1 if has_newline else 0)
                 elements.append(

pymax/interfaces.py

@@ -1,17 +1,20 @@
 import asyncio
-import logging
 import socket
 import ssl
 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 .static import Constants
+from .payloads import UserAgentPayload
+from .static.constant import DEFAULT_TIMEOUT
+from .static.enum import Opcode
 from .types import Channel, Chat, Dialog, Me, Message, User
 
 if TYPE_CHECKING:
@@ -26,23 +29,20 @@ class ClientProtocol(ABC):
         self.logger = logger
         self._users: dict[int, User] = {}
         self.chats: list[Chat] = []
-        self.phone: str = ""
         self._database: Database
         self._device_id: UUID
-        self._on_message_handlers: list[
-            tuple[Callable[[Message], Any], Filter | None]
-        ] = []
         self.uri: str
-
         self.is_connected: bool = False
         self.phone: str
-        self.chats: list[Chat] = []
         self.dialogs: list[Dialog] = []
         self.channels: list[Channel] = []
         self.me: Me | None = None
         self.host: str
         self.port: int
-        self._users: dict[int, User] = {}
+        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
@@ -50,12 +50,17 @@ 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.user_agent = Constants.DEFAULT_USER_AGENT.value
-
+        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"
-
         self._on_message_handlers: list[
             tuple[Callable[[Message], Any], Filter | None]
         ] = []
@@ -73,13 +78,24 @@ class ClientProtocol(ABC):
     @abstractmethod
     async def _send_and_wait(
         self,
-        opcode: int,
+        opcode: Opcode,
         payload: dict[str, Any],
         cmd: int = 0,
-        timeout: float = Constants.DEFAULT_TIMEOUT.value,
+        timeout: float = DEFAULT_TIMEOUT,
     ) -> dict[str, Any]:
         pass
 
     @abstractmethod
     async def _get_chat(self, chat_id: int) -> Chat | None:
         pass
+
+    @abstractmethod
+    async def _queue_message(
+        self,
+        opcode: int,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = DEFAULT_TIMEOUT,
+        max_retries: int = 3,
+    ) -> Message | None:
+        pass

pymax/mixins/auth.py

@@ -1,15 +1,21 @@
 import asyncio
 import re
+import sys
 from typing import Any
 
 from pymax.interfaces import ClientProtocol
-from pymax.payloads import RequestCodePayload, SendCodePayload
-from pymax.static import AuthType, Constants, Opcode
+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
+
     def _check_phone(self) -> bool:
-        return bool(re.match(Constants.PHONE_REGEX.value, self.phone))
+        return bool(re.match(PHONE_REGEX, self.phone))
 
     async def _request_code(
         self, phone: str, language: str = "ru"
@@ -29,7 +35,12 @@ class AuthMixin(ClientProtocol):
                 data.get("opcode"),
                 data.get("seq"),
             )
-            return data.get("payload")
+            payload_data = data.get("payload")
+            if isinstance(payload_data, dict):
+                return payload_data
+            else:
+                self.logger.error("Invalid payload data received")
+                raise ValueError("Invalid payload data received")
         except Exception:
             self.logger.error("Request code failed", exc_info=True)
             raise RuntimeError("Request code failed")
@@ -50,20 +61,27 @@ class AuthMixin(ClientProtocol):
                 data.get("opcode"),
                 data.get("seq"),
             )
-            return data.get("payload")
+            payload_data = data.get("payload")
+            if isinstance(payload_data, dict):
+                return payload_data
+            else:
+                self.logger.error("Invalid payload data received")
+                raise ValueError("Invalid payload data received")
         except Exception:
             self.logger.error("Send code failed", exc_info=True)
             raise RuntimeError("Send code failed")
 
     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")
@@ -79,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")