maxapi-python 1.1.18__py3-none-any.whl → 1.1.20__py3-none-any.whl

{maxapi_python-1.1.18.dist-info → maxapi_python-1.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.18
+Version: 1.1.20
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/ink-developer/PyMax
 Project-URL: Repository, https://github.com/ink-developer/PyMax

maxapi_python-1.1.20.dist-info/RECORD

@@ -0,0 +1,31 @@
+pymax/__init__.py,sha256=6wUKKwsyxFpWG3b7kwptOvHd-w78C-ygw42iCDBYQvc,1915
+pymax/core.py,sha256=LqX56a5BagUYl1vpB55Y1pLZQdMoC86t6mIQVlkVByo,17322
+pymax/crud.py,sha256=wmJh8MPi3L_HbYp7MJP0eXfDcnjgfkLDa9rHAmXtkow,3219
+pymax/exceptions.py,sha256=nDUNx7bM-Yjugj-qfIllcrnwLg9JpZroYqfXapjYbMQ,3178
+pymax/files.py,sha256=AvFIr34Desq2p4CNWXIngRqeyTBKMT98VmcnI-zvUU0,3462
+pymax/filters.py,sha256=4hehzyQlyxBxLiEhtSH_KQdFHx8gYaqyIOOD72EsSS0,1536
+pymax/formatter.py,sha256=OVsTwambHhXlOMd0wVECJWuB_S2wSEVKdMLCzgPcvYQ,859
+pymax/formatting.py,sha256=hhtmakfcQDzQRsAckPunnJOCKY2lFdLeIp8Yw53yY8s,2522
+pymax/interfaces.py,sha256=Re8o5N7FSQ-5OgVlK4-WBltX27GheEbfFjoIYl9_u6I,3723
+pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
+pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
+pymax/payloads.py,sha256=cEXY_cVL6SPyhoFTTZnn7dyUx9MMdtNT5SuQSQtL4rg,6983
+pymax/types.py,sha256=_ARcVXLGHyiGAJKYPd6EU9QDKzz4VwS6kjTu3YEH_u4,35523
+pymax/mixins/__init__.py,sha256=xvjcq-lFVHCPss_t8xxXya0OJnsh-owlBqtUlrXSCcw,695
+pymax/mixins/auth.py,sha256=Emv-0WVB_orwv9L_V5gAHfp-VYVaVcbW6AlclW_K6W4,6731
+pymax/mixins/channel.py,sha256=7c8GANyxZuNbIHNBVcPAmMa1qqA1IRf9cGPBS1oK_q4,5159
+pymax/mixins/group.py,sha256=XWXNWluCvq4KkZWqv4sxLpzkXfH33U1yEP20_ZFtSM4,10624
+pymax/mixins/handler.py,sha256=ZuYX8wSgNXJoSMArcwyHvY_bL9A7X0AXnAOz22ATA3k,5897
+pymax/mixins/message.py,sha256=wYvkMPE9ORCSFd_9J-6ltf__4ELG_zaZ_Uey4rmCzHg,25460
+pymax/mixins/self.py,sha256=3BdHfUyqw3dn3ctJX9_hilP1jOaTaunstZ7nH8Y_xcU,5436
+pymax/mixins/socket.py,sha256=GEOscQKKC48bOAXXiDLoz8GusCLtjdxQnB5AK5xJbms,26997
+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=toiXt9qxx6yTgnWJdEOeNfp414MD4zmbHp1qVgVkjnY,19850
+pymax/static/constant.py,sha256=Q1NrmaRj17Gdhk3FmUp3HIwrad1TDorq3wFdQlOCzN8,1027
+pymax/static/enum.py,sha256=ddw5SEVfRb2J9TXOa5IGhssNd-7RyKfwZBKx_UionEM,4562
+maxapi_python-1.1.20.dist-info/METADATA,sha256=9yhRv1m8PbJJhnUdloacxlK0jAE0veq6zfXDP-Ok5nk,6245
+maxapi_python-1.1.20.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+maxapi_python-1.1.20.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
+maxapi_python-1.1.20.dist-info/RECORD,,

{maxapi_python-1.1.18.dist-info → maxapi_python-1.1.20.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pymax/core.py

@@ -7,12 +7,16 @@ import time
 import traceback
 from collections.abc import Awaitable
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, Self
+from typing import TYPE_CHECKING, Any, Literal
 
-from typing_extensions import override
+from typing_extensions import Self, override
 
 from .crud import Database
-from .exceptions import InvalidPhoneError, WebSocketNotConnectedError
+from .exceptions import (
+    InvalidPhoneError,
+    SocketNotConnectedError,
+    WebSocketNotConnectedError,
+)
 from .formatter import ColoredFormatter
 from .mixins import ApiMixin, SocketMixin, WebSocketMixin
 from .payloads import UserAgentPayload
@@ -29,7 +33,7 @@ if TYPE_CHECKING:
     import websockets
 
     from .filters import Filter
-    from .types import Channel, Chat, Dialog, Me, Message, User
+    from .types import Channel, Chat, Dialog, Me, Message, ReactionInfo, User
 
 
 logger = logging.getLogger(__name__)
@@ -143,6 +147,10 @@ class MaxClient(ApiMixin, WebSocketMixin):
             tuple[Callable[[Message], Any], Filter | None]
         ] = []
         self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
+        self._on_reaction_change_handlers: list[
+            tuple[Callable[[str, int, ReactionInfo], Any]]
+        ] = []
+        self._on_chat_update_handlers: list[tuple[Callable[[Chat], Any]]] = []
 
         self._ssl_context = ssl.create_default_context()
         self._ssl_context.set_ciphers("DEFAULT")
@@ -172,13 +180,13 @@ class MaxClient(ApiMixin, WebSocketMixin):
             handler.setFormatter(formatter)
             self.logger.addHandler(handler)
 
-    async def _wait_forever(self):
+    async def _wait_forever(self) -> None:
         try:
             await self.ws.wait_closed()
         except asyncio.CancelledError:
             self.logger.debug("wait_closed cancelled")
 
-    async def _safe_execute(self, coro, *, context: str = "unknown"):
+    async def _safe_execute(self, coro, *, context: str = "unknown") -> Any:
         """
         Безопасно выполняет пользовательскую корутину.
         Логирует traceback, но не роняет event loop.
@@ -232,6 +240,97 @@ class MaxClient(ApiMixin, WebSocketMixin):
         self._background_tasks.add(task)
         return task
 
+    async def _post_login_tasks(self, sync: bool = True) -> None:
+        if sync:
+            await self._sync()
+
+        if self._on_start_handler:
+            self.logger.debug("Calling on_start handler")
+            result = self._on_start_handler()
+            if asyncio.iscoroutine(result):
+                await 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)
+        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)
+
+    async def _cleanup_client(self) -> None:
+        for task in list(self._background_tasks):
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                self.logger.debug(
+                    "Background task raised during cancellation", exc_info=True
+                )
+            self._background_tasks.discard(task)
+
+        if self._recv_task:
+            self._recv_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._recv_task
+            self._recv_task = None
+
+        if self._outgoing_task:
+            self._outgoing_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._outgoing_task
+            self._outgoing_task = None
+
+        for fut in self._pending.values():
+            if not fut.done():
+                fut.set_exception(WebSocketNotConnectedError)
+        self._pending.clear()
+
+        if self._ws:
+            try:
+                await self._ws.close()
+            except Exception:
+                self.logger.debug("Error closing ws during cleanup", exc_info=True)
+            self._ws = None
+
+        self.is_connected = False
+        self.logger.info("Client start() cleaned up")
+
+    async def login_with_code(
+        self, temp_token: str, code: str, start: bool = False
+    ) -> None:
+        """
+        Завершает кастомный login flow: отправляет код, сохраняет токен и запускает пост-логин задачи.
+
+        Args:
+            temp_token (str): Временный токен, полученный из request_code()
+            code (str): Код, введённый пользователем
+
+        Returns:
+            str: Токен для входа
+        """
+        resp = await self._send_code(code, temp_token)
+        token = resp.get("tokenAttrs", {}).get("LOGIN", {}).get("token")
+        self._token = token
+        self._database.update_auth_token(self._device_id, token)
+        if start:
+            while True:
+                try:
+                    await self._post_login_tasks()
+                    await self._wait_forever()
+                except Exception:
+                    self.logger.exception("Error during post-login tasks")
+                finally:
+                    await self._cleanup_client()
+
+                self.logger.info("Reconnecting after post-login tasks failure")
+                await asyncio.sleep(self.reconnect_delay)
+        else:
+            self.logger.info("Login successful, token saved to database, exiting...")
+
     async def start(self) -> None:
         """
         Запускает клиент, подключается к WebSocket, авторизует
@@ -242,7 +341,7 @@ class MaxClient(ApiMixin, WebSocketMixin):
         while True:
             try:
                 self.logger.info("Client starting")
-                await self._connect(self.user_agent)
+                await self.connect(self.user_agent)
 
                 if self.registration:
                     if not self.first_name:
@@ -257,70 +356,18 @@ class MaxClient(ApiMixin, WebSocketMixin):
                 else:
                     await self._sync()
 
-                if self._on_start_handler:
-                    self.logger.debug("Calling on_start handler")
-                    result = self._on_start_handler()
-                    if asyncio.iscoroutine(result):
-                        await 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)
-                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)
+                await self._post_login_tasks(sync=False)
 
                 await self._wait_forever()
                 self.logger.info("WebSocket closed (wait_forever exited)")
-
-            except Exception:
+            except Exception as e:
                 self.logger.exception("Client start iteration failed")
+                raise e
 
             finally:
                 self.logger.debug("Cleaning up background tasks and pending futures")
 
-                for task in list(self._background_tasks):
-                    task.cancel()
-                    try:
-                        await task
-                    except asyncio.CancelledError:
-                        pass
-                    except Exception:
-                        self.logger.debug(
-                            "Background task raised during cancellation", exc_info=True
-                        )
-                    self._background_tasks.discard(task)
-
-                if self._recv_task:
-                    self._recv_task.cancel()
-                    with contextlib.suppress(asyncio.CancelledError):
-                        await self._recv_task
-                    self._recv_task = None
-
-                if self._outgoing_task:
-                    self._outgoing_task.cancel()
-                    with contextlib.suppress(asyncio.CancelledError):
-                        await self._outgoing_task
-                    self._outgoing_task = None
-
-                for fut in self._pending.values():
-                    if not fut.done():
-                        fut.set_exception(WebSocketNotConnectedError)
-                self._pending.clear()
-
-                if self._ws:
-                    try:
-                        await self._ws.close()
-                    except Exception:
-                        self.logger.debug(
-                            "Error closing ws during cleanup", exc_info=True
-                        )
-                    self._ws = None
-
-                self.is_connected = False
-                self.logger.info("Client start() cleaned up")
+                await self._cleanup_client()
 
             if not self.reconnect:
                 self.logger.info("Reconnect disabled — exiting start()")
@@ -352,3 +399,51 @@ class SocketMaxClient(SocketMixin, MaxClient):
                 self.logger.debug("Socket recv_task cancelled")
             except Exception as e:
                 self.logger.exception("Socket recv_task failed: %s", e)
+
+    @override
+    async def _cleanup_client(self):
+        """
+        Socket-specific cleanup: cancel background tasks, set pending futures
+        exceptions to SocketNotConnectedError, and close socket.
+        """
+        from .exceptions import SocketNotConnectedError
+
+        for task in list(self._background_tasks):
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                self.logger.debug(
+                    "Background task raised during cancellation (socket)",
+                    exc_info=True,
+                )
+            self._background_tasks.discard(task)
+
+        if self._recv_task:
+            self._recv_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._recv_task
+            self._recv_task = None
+
+        if self._outgoing_task:
+            self._outgoing_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._outgoing_task
+            self._outgoing_task = None
+
+        for fut in self._pending.values():
+            if not fut.done():
+                fut.set_exception(SocketNotConnectedError())
+        self._pending.clear()
+
+        if self._socket:
+            try:
+                self._socket.close()
+            except Exception:
+                self.logger.debug("Error closing socket during cleanup", exc_info=True)
+            self._socket = None
+
+        self.is_connected = False
+        self.logger.info("Client start() cleaned up (socket)")

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
@@ -84,15 +78,24 @@ class Photo(BaseFile):
 
 
 class Video(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()
 
 
 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/interfaces.py

@@ -4,21 +4,24 @@ 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, Literal
 
-import websockets
-
-from .filters import Filter
 from .payloads import UserAgentPayload
 from .static.constant import DEFAULT_TIMEOUT
 from .static.enum import Opcode
 from .types import Channel, Chat, Dialog, Me, Message, User
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from uuid import UUID
 
+    import websockets
+
+    from pymax import AttachType
+    from pymax.types import ReactionInfo
+
     from .crud import Database
+    from .filters import Filter
 
 
 class ClientProtocol(ABC):
@@ -50,7 +53,10 @@ 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
@@ -69,6 +75,10 @@ class ClientProtocol(ABC):
         self._on_message_delete_handlers: list[
             tuple[Callable[[Message], Any], Filter | None]
         ] = []
+        self._on_reaction_change_handlers: list[
+            tuple[Callable[[str, int, ReactionInfo], Any]]
+        ] = []
+        self._on_chat_update_handlers: list[tuple[Callable[[Chat], Any]]] = []
         self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
         self._background_tasks: set[asyncio.Task[Any]] = set()
         self._ssl_context: ssl.SSLContext

pymax/mixins/auth.py

@@ -15,71 +15,73 @@ class AuthMixin(ClientProtocol):
     def _check_phone(self) -> bool:
         return bool(re.match(PHONE_REGEX, self.phone))
 
-    async def _request_code(
-        self, phone: str, language: str = "ru"
-    ) -> dict[str, int | str]:
-        try:
-            self.logger.info("Requesting auth code")
+    async def request_code(self, phone: str, language: str = "ru") -> str:
+        """
+        Запрашивает код аутентификации для указанного номера телефона и возвращает временный токен.
 
-            payload = RequestCodePayload(
-                phone=phone, type=AuthType.START_AUTH, language=language
-            ).model_dump(by_alias=True)
+        Note:
+            Использовать только в кастомном login flow.
 
-            data = await self._send_and_wait(
-                opcode=Opcode.AUTH_REQUEST, payload=payload
-            )
-            if data.get("payload", {}).get("error"):
-                MixinsUtils.handle_error(data)
+        Args:
+            phone (str): Номер телефона в международном формате.
+            language (str, optional): Язык для сообщения с кодом. По умолчанию "ru".
 
-            self.logger.debug(
-                "Code request 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("Request code failed", exc_info=True)
-            raise RuntimeError("Request code failed")
+        Returns:
+            str: Временный токен для дальнейшей аутентификации.
+        """
+        self.logger.info("Requesting auth code")
+
+        payload = RequestCodePayload(
+            phone=phone, type=AuthType.START_AUTH, language=language
+        ).model_dump(by_alias=True)
+
+        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"),
+            data.get("seq"),
+        )
+        payload_data = data.get("payload")
+        if isinstance(payload_data, dict):
+            return payload_data["token"]
+        else:
+            self.logger.error("Invalid payload data received")
+            raise ValueError("Invalid payload data received")
 
     async def _send_code(self, code: str, token: str) -> dict[str, Any]:
-        try:
-            self.logger.info("Sending verification code")
+        self.logger.info("Sending verification code")
 
-            payload = SendCodePayload(
-                token=token,
-                verify_code=code,
-                auth_token_type=AuthType.CHECK_CODE,
-            ).model_dump(by_alias=True)
+        payload = SendCodePayload(
+            token=token,
+            verify_code=code,
+            auth_token_type=AuthType.CHECK_CODE,
+        ).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)
+        data = await self._send_and_wait(opcode=Opcode.AUTH, payload=payload)
 
-            self.logger.debug(
-                "Send code 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("Send code failed", exc_info=True)
-            raise RuntimeError("Send code failed")
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
+
+        self.logger.debug(
+            "Send code 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")
 
     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")
+        temp_token = await self.request_code(self.phone)
         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")
@@ -136,8 +138,8 @@ class AuthMixin(ClientProtocol):
     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")
+        request_code_payload = await self.request_code(self.phone)
+        temp_token = request_code_payload
 
         if not temp_token or not isinstance(temp_token, str):
             self.logger.critical("Failed to request code: token missing")

pymax/mixins/channel.py

@@ -67,11 +67,11 @@ class ChannelMixin(ClientProtocol):
     ) -> tuple[list[Member], int | None]:
         data = await self._send_and_wait(
             opcode=Opcode.CHAT_MEMBERS,
-            payload=payload.model_dump(by_alias=True),
+            payload=payload.model_dump(by_alias=True, exclude_none=True),
         )
         response_payload = data.get("payload", {})
-        if error := response_payload.get("error"):
-            raise ResponseError(error)
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
         marker = response_payload.get("marker")
         if isinstance(marker, str):
             marker = int(marker)
@@ -96,7 +96,7 @@ class ChannelMixin(ClientProtocol):
     async def load_members(
         self,
         chat_id: int,
-        marker: int = DEFAULT_MARKER_VALUE,
+        marker: int | None = DEFAULT_MARKER_VALUE,
         count: int = DEFAULT_CHAT_MEMBERS_LIMIT,
     ) -> tuple[list[Member], int | None]:
         """
@@ -106,11 +106,11 @@ class ChannelMixin(ClientProtocol):
             chat_id (int): Идентификатор канала
             marker (int, optional): Маркер для пагинации. По умолчанию DEFAULT_MARKER_VALUE
             count (int, optional): Количество членов для загрузки. По умолчанию DEFAULT_CHAT_MEMBERS_LIMIT.
-            Данное значение лучше не менять, так как веб-клиент загружает именно столько.
 
         Returns:
-            list[Member]: Список участников канала
+            tuple[list[Member], int | None]: Список участников канала и маркер для следующей страницы
         """
+
         payload = GetGroupMembersPayload(chat_id=chat_id, marker=marker, count=count)
         return await self._query_members(payload)