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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.15
+Version: 1.1.16
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/ink-developer/PyMax
 Project-URL: Repository, https://github.com/ink-developer/PyMax
@@ -155,10 +155,14 @@ if __name__ == "__main__":
 
 [Telegram](https://t.me/pymax_news)
 
-## Авторы
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=ink-developer/PyMax&type=date&legend=top-left)](https://www.star-history.com/#ink-developer/PyMax&type=date&legend=top-left)
 
-- **[ink-developer](https://github.com/ink-developer)** — Оригинальный автор проекта
+## Авторы
 - **[ink](https://github.com/ink-developer)** — Главный разработчик, исследование API и его документация
+- **[noxzion](https://github.com/noxzion)** — Оригинальный автор проекта
+
 
 ## Контрибьюторы
 

maxapi_python-1.1.16.dist-info/RECORD

@@ -0,0 +1,31 @@
+pymax/__init__.py,sha256=vsdE56xHZnvDCXqLwSJL3v9MxsXcmmxE9p0QSHG66HA,1846
+pymax/core.py,sha256=EKgMlOnqvsPJwOQeCgQE1tnKk4E8kMnmxCAfo4jrP_k,11083
+pymax/crud.py,sha256=wmJh8MPi3L_HbYp7MJP0eXfDcnjgfkLDa9rHAmXtkow,3219
+pymax/exceptions.py,sha256=nDUNx7bM-Yjugj-qfIllcrnwLg9JpZroYqfXapjYbMQ,3178
+pymax/files.py,sha256=dRuOpvoJZWiH4xa_HVGyqQ-_Zzj-sVikElHmrPjwgs0,3166
+pymax/filters.py,sha256=4hehzyQlyxBxLiEhtSH_KQdFHx8gYaqyIOOD72EsSS0,1536
+pymax/formatter.py,sha256=OVsTwambHhXlOMd0wVECJWuB_S2wSEVKdMLCzgPcvYQ,859
+pymax/formatting.py,sha256=hhtmakfcQDzQRsAckPunnJOCKY2lFdLeIp8Yw53yY8s,2522
+pymax/interfaces.py,sha256=NspCm8asUhG_LHo-CTseGMg-zKAHU5H4bl6BMEwqAK0,3416
+pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
+pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
+pymax/payloads.py,sha256=qaafULDGBXsQ7gNFC374wZVUwN5tzJLHwkxtAmglOzU,6292
+pymax/types.py,sha256=tiSU_YpvOlx710SYQbYLNw_SjwefgqOu9Xk5ev_PbFU,30931
+pymax/mixins/__init__.py,sha256=xvjcq-lFVHCPss_t8xxXya0OJnsh-owlBqtUlrXSCcw,695
+pymax/mixins/auth.py,sha256=H4Zp3n8cwpv4Q3Mn1_Kb7Oh9DbTL7T9GcWJ6R1JN7ls,6672
+pymax/mixins/channel.py,sha256=dMuJRnbqZisN8kcPFCCe1sIOOBQl2uT4P49PpZXcoKE,5206
+pymax/mixins/group.py,sha256=7oa7RpiqnlcnAsnIHOfSiujNYAzUZ9lkTy9NGW5KVUE,8654
+pymax/mixins/handler.py,sha256=AhxIRvwftkuWN435_CXede2ZVWrDde4zkMPZtwIm5IU,3892
+pymax/mixins/message.py,sha256=ezU9d6r4MkYjH67gZ9SFLYPKqo4Nb6lswqDsEW5p-Bg,22329
+pymax/mixins/self.py,sha256=tDQrUdUpsCu7qGkWLtKxTfTHPHU5_r3qsn-eptHG2KY,1198
+pymax/mixins/socket.py,sha256=j6XTo_M3rNw-az2PfSW6oJ_YHg9M7cWARY4cXpMllDY,22256
+pymax/mixins/telemetry.py,sha256=LWr68DNQkPhAjGRDYQ5lORXxC3Yw6M9E8sF0TCNISTE,3609
+pymax/mixins/user.py,sha256=5utoK7Z-7lySOg0PEO69b6h_3kjfcnV-YydTZIdNj8g,7120
+pymax/mixins/utils.py,sha256=s3FUf3i_wjn2Gbg5YY1rWZB-90ZEGrrcUuND_MqqSTE,853
+pymax/mixins/websocket.py,sha256=gqGP-3XPrbo4DPqUL4H8tuOAjZQ4QKbBvJGxOFqwk9E,17254
+pymax/static/constant.py,sha256=Q1NrmaRj17Gdhk3FmUp3HIwrad1TDorq3wFdQlOCzN8,1027
+pymax/static/enum.py,sha256=ofqxOsRzi6XvZN_UOPinxug1uPEulJsQ95MWifAfCqA,4562
+maxapi_python-1.1.16.dist-info/METADATA,sha256=OLNhs5zuW9ux6C_57MVhTscaZknfVXh90OYf5P2_X8A,6245
+maxapi_python-1.1.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+maxapi_python-1.1.16.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
+maxapi_python-1.1.16.dist-info/RECORD,,

pymax/__init__.py

@@ -9,14 +9,22 @@ from .core import (
 from .exceptions import (
     InvalidPhoneError,
     LoginError,
+    ResponseError,
+    ResponseStructureError,
+    SocketNotConnectedError,
+    SocketSendError,
     WebSocketNotConnectedError,
 )
 from .static.enum import (
     AccessType,
+    AttachType,
     AuthType,
     ChatType,
+    ContactAction,
     DeviceType,
     ElementType,
+    FormattingType,
+    MarkupType,
     MessageStatus,
     MessageType,
     Opcode,
@@ -24,10 +32,26 @@ from .static.enum import (
 from .types import (
     Channel,
     Chat,
+    Contact,
+    ControlAttach,
     Dialog,
     Element,
+    FileAttach,
+    FileRequest,
+    Me,
+    Member,
     Message,
+    MessageLink,
+    Name,
+    Names,
+    PhotoAttach,
+    Presence,
+    ReactionCounter,
+    ReactionInfo,
+    Session,
     User,
+    VideoAttach,
+    VideoRequest,
 )
 
 __author__ = "ink-developer"
@@ -35,19 +59,43 @@ __author__ = "ink-developer"
 __all__ = [
     # Перечисления и константы
     "AccessType",
+    "AttachType",
     "AuthType",
+    "ContactAction",
+    "FormattingType",
+    "MarkupType",
     # Типы данных
     "Channel",
     "Chat",
     "ChatType",
+    "Contact",
+    "ControlAttach",
     "DeviceType",
     "Dialog",
     "Element",
     "ElementType",
+    "FileAttach",
+    "FileRequest",
+    "Me",
+    "Member",
+    "MessageLink",
+    "Name",
+    "Names",
+    "PhotoAttach",
+    "Presence",
+    "ReactionCounter",
+    "ReactionInfo",
+    "Session",
+    "VideoAttach",
+    "VideoRequest",
     # Исключения
     "InvalidPhoneError",
     "LoginError",
     "WebSocketNotConnectedError",
+    "ResponseError",
+    "ResponseStructureError",
+    "SocketNotConnectedError",
+    "SocketSendError",
     # Клиент
     "MaxClient",
     "Message",

pymax/core.py

@@ -3,13 +3,16 @@ import logging
 import socket
 import ssl
 import time
+import traceback
+from collections.abc import Awaitable
 from pathlib import Path
-from typing import Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 from typing_extensions import override
 
 from .crud import Database
 from .exceptions import InvalidPhoneError
+from .formatter import ColoredFormatter
 from .mixins import ApiMixin, SocketMixin, WebSocketMixin
 from .payloads import UserAgentPayload
 from .static.constant import (
@@ -18,6 +21,16 @@ from .static.constant import (
     WEBSOCKET_URI,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+    from typing import Any
+
+    import websockets
+
+    from .filters import Filter
+    from .types import Channel, Chat, Dialog, Me, Message, User
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -64,9 +77,7 @@ class MaxClient(ApiMixin, WebSocketMixin):
         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.logger = logger or logging.getLogger(f"{__name__}")
         self.uri: str = uri
         self.phone: str = phone
         if not self._check_phone():
@@ -77,23 +88,55 @@ class MaxClient(ApiMixin, WebSocketMixin):
         self.first_name: str = first_name
         self.last_name: str | None = last_name
         self.proxy: str | Literal[True] | None = proxy
+
+        self.is_connected: bool = False
+
+        self.chats: list[Chat] = []
+        self.dialogs: list[Dialog] = []
+        self.channels: list[Channel] = []
+        self.me: Me | None = None
+        self._users: dict[int, User] = {}
+
         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._incoming: asyncio.Queue[dict[str, Any]] | None = None
         self._outgoing: asyncio.Queue[dict[str, Any]] | None = None
+        self._recv_task: asyncio.Task[Any] | None = None
         self._outgoing_task: asyncio.Task[Any] | None = None
+        self._pending: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._file_upload_waiters: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._background_tasks: set[asyncio.Task[Any]] = set()
+
+        self._seq: int = 0
         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._ssl_context = ssl.create_default_context()
         self._ssl_context.set_ciphers("DEFAULT")
         self._ssl_context.check_hostname = True
@@ -101,6 +144,8 @@ 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._ws: websockets.ClientConnection | None = None
+
         self._setup_logger()
         self.logger.debug(
             "Initialized MaxClient uri=%s work_dir=%s",
@@ -109,13 +154,16 @@ class MaxClient(ApiMixin, WebSocketMixin):
         )
 
     def _setup_logger(self) -> None:
-        if not logger.handlers:
+        if not self.logger.handlers:
+            if not self.logger.level:
+                self.logger.setLevel(logging.INFO)
             handler = logging.StreamHandler()
-            formatter = logging.Formatter(
-                "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+            formatter = ColoredFormatter(
+                "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
             )
             handler.setFormatter(formatter)
-            logger.addHandler(handler)
+            self.logger.addHandler(handler)
 
     async def _wait_forever(self):
         try:
@@ -123,6 +171,18 @@ class MaxClient(ApiMixin, WebSocketMixin):
         except asyncio.CancelledError:
             self.logger.debug("wait_closed cancelled")
 
+    async def _safe_execute(self, coro, *, context: str = "unknown"):
+        """
+        Безопасно выполняет пользовательскую корутину.
+        Логирует traceback, но не роняет event loop.
+        """
+        try:
+            return await coro
+        except Exception as e:
+            self.logger.error(
+                f"Unhandled exception in {context}: {e}\n{traceback.format_exc()}"
+            )
+
     async def close(self) -> None:
         try:
             self.logger.info("Closing client")
@@ -145,6 +205,23 @@ class MaxClient(ApiMixin, WebSocketMixin):
         except Exception:
             self.logger.exception("Error closing client")
 
+    def _create_safe_task(self, coro: Awaitable[Any], *, name: str | None = None):
+        async def runner():
+            try:
+                return await coro
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                self.logger.error(
+                    f"Unhandled exception in task {name or coro}: {e}",
+                    exc_info=e,
+                )
+                return None
+
+        task = asyncio.create_task(runner(), name=name)
+        self._background_tasks.add(task)
+        return task
+
     async def start(self) -> None:
         """
         Запускает клиент, подключается к WebSocket, авторизует
@@ -171,7 +248,7 @@ class MaxClient(ApiMixin, WebSocketMixin):
                 self.logger.debug("Calling on_start handler")
                 result = self._on_start_handler()
                 if asyncio.iscoroutine(result):
-                    await result
+                    await self._safe_execute(result, context="on_start handler")
 
             ping_task = asyncio.create_task(self._send_interactive_ping())
             ping_task.add_done_callback(self._log_task_exception)

pymax/exceptions.py

@@ -39,15 +39,6 @@ class SocketSendError(Exception):
         super().__init__("Send and wait failed (socket)")
 
 
-class LoginError(Exception):
-    """
-    Исключение, вызываемое при ошибке авторизации.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(f"Login error: {message}")
-
-
 class ResponseError(Exception):
     """
     Исключение, вызываемое при ошибке в ответе от сервера.
@@ -64,3 +55,54 @@ class ResponseStructureError(Exception):
 
     def __init__(self, message: str) -> None:
         super().__init__(f"Response structure error: {message}")
+
+
+class Error(Exception):
+    """
+    Базовое исключение для ошибок PyMax.
+    """
+
+    def __init__(
+        self,
+        error: str,
+        message: str,
+        title: str,
+        localized_message: str | None = None,
+    ) -> None:
+        self.error = error
+        self.message = message
+        self.title = title
+        self.localized_message = localized_message
+
+        parts = []
+        if localized_message:
+            parts.append(localized_message)
+        if message:
+            parts.append(message)
+        if title:
+            parts.append(f"({title})")
+        parts.append(f"[{error}]")
+
+        super().__init__("PyMax Error: " + " ".join(parts))
+
+
+class RateLimitError(Error):
+    """
+    Исключение, вызываемое при превышении лимита запросов.
+    """
+
+    def __init__(
+        self, error: str, message: str, title: str, localized_message: str | None = None
+    ) -> None:
+        super().__init__(error, message, title, localized_message)
+
+
+class LoginError(Error):
+    """
+    Исключение, вызываемое при ошибке авторизации.
+    """
+
+    def __init__(
+        self, error: str, message: str, title: str, localized_message: str | None = None
+    ) -> None:
+        super().__init__(error, message, title, localized_message)

pymax/files.py

@@ -9,7 +9,9 @@ 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
 
@@ -45,7 +47,9 @@ 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:
@@ -67,7 +71,9 @@ 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
@@ -84,7 +90,9 @@ class Video(BaseFile):
 
 
 class File(BaseFile):
-    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.file_name: str = ""
         if path:
             self.file_name = Path(path).name

pymax/formatter.py

@@ -0,0 +1,30 @@
+import logging
+from typing import ClassVar
+
+
+class ColoredFormatter(logging.Formatter):
+    COLORS: ClassVar = {
+        "DEBUG": "\033[37m",
+        "INFO": "\033[36m",
+        "WARNING": "\033[33m",
+        "ERROR": "\033[31m",
+        "CRITICAL": "\033[41m",
+    }
+
+    RESET = "\033[0m"
+    DIM = "\033[2m"
+    BOLD = "\033[1m"
+
+    def format(self, record: logging.LogRecord) -> str:
+        level_color = self.COLORS.get(record.levelname, self.RESET)
+        time_color = self.DIM
+        name_color = "\033[35m"
+        message_color = self.RESET
+
+        log = (
+            f"{time_color}{self.formatTime(record, '%H:%M:%S')}{self.RESET} "
+            f"[{level_color}{record.levelname}{self.RESET}] "
+            f"{name_color}{record.name}{self.RESET}: "
+            f"{message_color}{record.getMessage()}{self.RESET}"
+        )
+        return log

pymax/interfaces.py

@@ -9,8 +9,6 @@ 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
@@ -43,6 +41,7 @@ class ClientProtocol(ABC):
         self.registration: bool
         self.first_name: str
         self.last_name: str | None
+        self._token: str | None
         self._work_dir: str
         self._database_path: Path
         self._ws: websockets.ClientConnection | None = None
@@ -50,14 +49,15 @@ 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._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"
@@ -70,7 +70,9 @@ 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
@@ -99,3 +101,9 @@ class ClientProtocol(ABC):
         max_retries: int = 3,
     ) -> Message | None:
         pass
+
+    @abstractmethod
+    def _create_safe_task(
+        self, coro: Awaitable[Any], name: str | None = None
+    ) -> asyncio.Task[Any]:
+        pass

pymax/mixins/auth.py

@@ -3,17 +3,15 @@ import re
 import sys
 from typing import Any
 
+from pymax.exceptions import Error
 from pymax.interfaces import ClientProtocol
+from pymax.mixins.utils import MixinsUtils
 from pymax.payloads import RegisterPayload, RequestCodePayload, SendCodePayload
 from pymax.static.constant import PHONE_REGEX
 from pymax.static.enum import AuthType, Opcode
 
 
 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(PHONE_REGEX, self.phone))
 
@@ -30,6 +28,9 @@ class AuthMixin(ClientProtocol):
             data = await self._send_and_wait(
                 opcode=Opcode.AUTH_REQUEST, payload=payload
             )
+            if data.get("payload", {}).get("error"):
+                MixinsUtils.handle_error(data)
+
             self.logger.debug(
                 "Code request response opcode=%s seq=%s",
                 data.get("opcode"),
@@ -56,6 +57,9 @@ class AuthMixin(ClientProtocol):
             ).model_dump(by_alias=True)
 
             data = await self._send_and_wait(opcode=Opcode.AUTH, payload=payload)
+            if data.get("payload", {}).get("error"):
+                MixinsUtils.handle_error(data)
+
             self.logger.debug(
                 "Send code response opcode=%s seq=%s",
                 data.get("opcode"),
@@ -113,6 +117,9 @@ class AuthMixin(ClientProtocol):
             data = await self._send_and_wait(
                 opcode=Opcode.AUTH_CONFIRM, payload=payload
             )
+            if data.get("payload", {}).get("error"):
+                MixinsUtils.handle_error(data)
+
             self.logger.debug(
                 "Registration info response opcode=%s seq=%s",
                 data.get("opcode"),
@@ -121,9 +128,7 @@ class AuthMixin(ClientProtocol):
             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")
+            raise ValueError("Invalid payload data received")
         except Exception:
             self.logger.error("Submit registration info failed", exc_info=True)
             raise RuntimeError("Submit registration info failed")

pymax/mixins/channel.py

@@ -1,7 +1,9 @@
-from pymax.exceptions import ResponseError, ResponseStructureError
+from pymax.exceptions import Error, ResponseError, ResponseStructureError
 from pymax.interfaces import ClientProtocol
+from pymax.mixins.utils import MixinsUtils
 from pymax.payloads import (
     GetGroupMembersPayload,
+    JoinChatPayload,
     ResolveLinkPayload,
     SearchGroupMembersPayload,
 )
@@ -32,12 +34,32 @@ class ChannelMixin(ClientProtocol):
             link=f"https://max.ru/{name}",
         ).model_dump(by_alias=True)
 
-        data = await self._send_and_wait(
-            opcode=Opcode.LINK_INFO, payload=payload
-        )
-        if error := data.get("payload", {}).get("error"):
-            self.logger.error("Resolve link error: %s", error)
-            return False
+        data = await self._send_and_wait(opcode=Opcode.LINK_INFO, payload=payload)
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
+        return True
+
+    async def join_channel(self, link: str) -> bool:
+        """
+        Присоединяется к каналу по ссылке
+
+        Args:
+            link (str): Ссылка на канал
+
+        Exceptions:
+            ResponseError: Ошибка в ответе сервера
+            ResponseStructureError: Ошибка структуры ответа сервера
+
+        Returns:
+            bool: True, если присоединение прошло успешно
+        """
+        payload = JoinChatPayload(
+            link=link,
+        ).model_dump(by_alias=True)
+
+        data = await self._send_and_wait(opcode=Opcode.CHAT_JOIN, payload=payload)
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
         return True
 
     async def _query_members(
@@ -65,9 +87,7 @@ class ChannelMixin(ClientProtocol):
         if isinstance(members, list):
             for item in members:
                 if not isinstance(item, dict):
-                    raise ResponseStructureError(
-                        "Invalid member structure in response"
-                    )
+                    raise ResponseStructureError("Invalid member structure in response")
                 member_list.append(Member.from_dict(item))
         else:
             raise ResponseStructureError("Invalid members type in response")
@@ -91,9 +111,7 @@ class ChannelMixin(ClientProtocol):
         Returns:
             list[Member]: Список участников канала
         """
-        payload = GetGroupMembersPayload(
-            chat_id=chat_id, marker=marker, count=count
-        )
+        payload = GetGroupMembersPayload(chat_id=chat_id, marker=marker, count=count)
         return await self._query_members(payload)
 
     async def find_members(