maxapi-python 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

pymax/dispatch/dispatcher.py

@@ -9,7 +9,6 @@ from pymax.logging import get_logger
 from pymax.protocol import InboundFrame
 from pymax.types import Chat, MessageDeleteEvent
 from pymax.types.domain import Message
-from pymax.types.events import FileUploadSignal, VideoUploadSignal
 
 from .enums import EventType
 from .mapping import EventMapper, EventResolver
@@ -26,7 +25,6 @@ if TYPE_CHECKING:
     from collections.abc import Generator
 
     from pymax.app import App
-    from pymax.client import Client
 
 
 logger = get_logger(__name__)
@@ -35,7 +33,9 @@ ClientT = TypeVar("ClientT")
 
 
 class Dispatcher(Generic[ClientT]):
-    def __init__(self, app: App, root_router: Router[ClientT] | None = None) -> None:
+    def __init__(
+        self, app: App, root_router: Router[ClientT] | None = None
+    ) -> None:
         self.root_router: Router[ClientT] = root_router or Router()
         self.internal_router: Router[ClientT] = Router()
         self.resolver = EventResolver()
@@ -59,7 +59,11 @@ class Dispatcher(Generic[ClientT]):
         event: EventType,
         *filters: FilterCallback[Any],
     ) -> HandlerDecorator[Any, ClientT]:
-        logger.debug("registering internal handler event=%s filters=%s", event, len(filters))
+        logger.debug(
+            "registering internal handler event=%s filters=%s",
+            event,
+            len(filters),
+        )
         return self.internal_router.on(event, *filters)
 
     def on(
@@ -67,7 +71,9 @@ class Dispatcher(Generic[ClientT]):
         event: EventType,
         *filters: FilterCallback[Any],
     ) -> HandlerDecorator[Any, ClientT]:
-        logger.debug("registering handler event=%s filters=%s", event, len(filters))
+        logger.debug(
+            "registering handler event=%s filters=%s", event, len(filters)
+        )
         return self.root_router.on(event, *filters)
 
     def on_message(
@@ -81,7 +87,9 @@ class Dispatcher(Generic[ClientT]):
         self,
         *filters: FilterCallback[Message],
     ) -> HandlerDecorator[Message, ClientT]:
-        logger.debug("registering message edit handler filters=%s", len(filters))
+        logger.debug(
+            "registering message edit handler filters=%s", len(filters)
+        )
         return self.root_router.on_message_edit(*filters)
 
     def on_message_delete(
@@ -108,7 +116,9 @@ class Dispatcher(Generic[ClientT]):
     def iter_routers(self) -> Generator[Router[ClientT], Any, None]:
         yield from self._iter_router(self.root_router)
 
-    def _iter_router(self, router: Router[ClientT]) -> Generator[Router[ClientT], Any, None]:
+    def _iter_router(
+        self, router: Router[ClientT]
+    ) -> Generator[Router[ClientT], Any, None]:
         yield router
 
         for child in router.children:
@@ -151,10 +161,16 @@ class Dispatcher(Generic[ClientT]):
         if event_type is not None:
             logger.debug("dispatching event type=%s", event_type)
             event = self.mapper.map(event_type, frame)
-            await self._dispatch_to_router(self.internal_router, event_type, event)
+            await self._dispatch_to_router(
+                self.internal_router, event_type, event
+            )
             await self._dispatch_to_router(self.root_router, event_type, event)
         else:
-            logger.debug("dispatching raw event only opcode=%s cmd=%s", frame.opcode, frame.cmd)
+            logger.debug(
+                "dispatching raw event only opcode=%s cmd=%s",
+                frame.opcode,
+                frame.cmd,
+            )
 
         await self._dispatch_to_router(self.root_router, EventType.RAW, frame)
 
@@ -193,7 +209,9 @@ class Dispatcher(Generic[ClientT]):
                 return False
         return True
 
-    async def _call(self, callback: HandlerCallback[Any, ClientT], event: Any) -> Any:
+    async def _call(
+        self, callback: HandlerCallback[Any, ClientT], event: Any
+    ) -> Any:
         if self.client is None:
             raise RuntimeError("client is not bound")
 

pymax/dispatch/mapping.py

@@ -10,7 +10,12 @@ from pymax.types.domain import Message
 from pymax.types.events import FileUploadSignal, VideoUploadSignal
 
 from .enums import EventType
-from .resolvers import resolve_attach, resolve_chat, resolve_message, resolve_message_delete
+from .resolvers import (
+    resolve_attach,
+    resolve_chat,
+    resolve_message,
+    resolve_message_delete,
+)
 
 if TYPE_CHECKING:
     from pymax.app import App
@@ -53,7 +58,9 @@ class EventMapper:
 
         if frame.payload:
             if event_type in (EventType.MESSAGE_NEW, EventType.MESSAGE_EDIT):
-                return Message.model_validate(frame.payload).bind(self.app.api.messages)
+                return Message.model_validate(frame.payload).bind(
+                    self.app.api.messages
+                )
             elif event_type == EventType.CHAT_UPDATE:
                 return Chat.model_validate(frame.payload["chat"]).bind(
                     self.app.api.messages,

pymax/dispatch/router.py

@@ -106,6 +106,7 @@ class Router(Generic[ClientT]):
                async def raw(frame: InboundFrame, client: Client) -> None:
                    print(frame.payload)
         """
+
         def decorator(
             handler: HandlerCallback[_EventT, ClientT],
         ) -> HandlerCallback[_EventT, ClientT]:
@@ -136,6 +137,7 @@ class Router(Generic[ClientT]):
         Returns:
             Декоратор для ``handler(client)``.
         """
+
         def decorator(handler: StartCallback) -> StartCallback:
             self.on_start_handler = handler
             return handler

pymax/files/base.py

@@ -8,7 +8,12 @@ import aiohttp
 
 class BaseFile(ABC):
     def __init__(
-        self, raw: bytes | None = None, *, path: str | None, url: str | None, name: str | None
+        self,
+        raw: bytes | None = None,
+        *,
+        path: str | None,
+        url: str | None,
+        name: str | None,
     ) -> None:
         self.path = path
         self.url = url

pymax/formatting/markdown.py

@@ -151,7 +151,10 @@ class Formatter:
                     if marker == "```":
                         closing_index = text.find(marker, i + marker_len)
 
-                        if closing_index == -1 or closing_index == i + marker_len:
+                        if (
+                            closing_index == -1
+                            or closing_index == i + marker_len
+                        ):
                             clean_text += marker
                             clean_pos += marker_len
                             i += marker_len

pymax/infra/auth.py

@@ -53,3 +53,45 @@ class AuthMixin(IClientProtocol):
             RuntimeError: Если удаление пароля не удалось.
         """
         return await self._app.api.auth.remove_2fa(password=password)
+
+    async def change_password(
+        self,
+        password_old: str,
+        password_new: str,
+    ) -> bool:
+        """Меняет пароль 2FA для текущей учетной записи.
+
+        Args:
+            password_old: Текущий пароль 2FA.
+            password_new: Новый пароль 2FA.
+
+        Returns:
+            ``True``, если пароль успешно изменен.
+
+        Raises:
+            RuntimeError: Если изменение пароля не удалось.
+        """
+        return await self._app.api.auth.change_password(
+            password_old=password_old,
+            password_new=password_new,
+        )
+
+    async def authorize_qr_login(self, qr_link: str) -> bool:
+        """Авторизует вход по QR-коду.
+
+        Args:
+            qr_link: Ссылка на QR-код для авторизации.
+
+        Returns:
+            ``True``, если вход по QR-коду успешно авторизован.
+        """
+        return await self._app.api.auth.authorize_qr_login(qr_link=qr_link)
+
+    async def check_2fa(self) -> bool:
+        """Проверяет, включена ли 2FA для текущей учетной записи.
+
+        Returns:
+            ``True``, если на аккаунте установлен пароль 2FA.
+        """
+
+        return await self._app.api.auth.check_2fa()

pymax/infra/base.py

@@ -1,4 +1,5 @@
 from .auth import AuthMixin
+from .bots import BotsMixin
 from .chat import ChatMixin
 from .message import MessageMixin
 from .self import SelfMixin
@@ -10,6 +11,7 @@ class BaseMixin(
     UserMixin,
     ChatMixin,
     MessageMixin,
+    BotsMixin,
     AuthMixin,
 ):
     """Собирает публичные API-методы клиента."""

pymax/infra/bots.py

@@ -0,0 +1,33 @@
+from pymax.types.domain import InitData
+
+from .protocol import IClientProtocol
+
+
+class BotsMixin(IClientProtocol):
+    """Методы клиента для взаимодействия с ботами."""
+
+    async def get_bot_init_data(
+        self,
+        bot_id: int,
+        chat_id: int,
+        start_param: str | None = None,
+    ) -> InitData:
+        """Получает начальные данные для бота в контексте конкретного чата.
+
+        Args:
+            bot_id: Идентификатор бота.
+            chat_id: Идентификатор чата, в котором бот будет использоваться.
+            start_param: Необязательный параметр, передаваемый при запуске
+                бота.
+
+        Returns:
+            Объект с начальными данными для бота.
+
+        Raises:
+            RuntimeError: Если получение данных не удалось.
+        """
+        return await self._app.api.bots.get_init_data(
+            bot_id=bot_id,
+            chat_id=chat_id,
+            start_param=start_param,
+        )

pymax/infra/chat.py

@@ -1,4 +1,4 @@
-from pymax.types import Chat, Message
+from pymax.types import Chat, Member, Message
 
 from .protocol import IClientProtocol
 
@@ -238,3 +238,104 @@ class ChatMixin(IClientProtocol):
             Загруженные чаты.
         """
         return await self._app.api.chats.fetch_chats(marker=marker)
+
+    async def get_join_requests(
+        self,
+        chat_id: int,
+        count: int = 100,
+    ) -> list[Member]:
+        """Возвращает заявки на вступление в группу или канал.
+
+        Args:
+            chat_id: ID группы или канала.
+            count: Максимальное количество заявок в ответе.
+
+        Returns:
+            Список пользователей, ожидающих подтверждения заявки.
+        """
+        return await self._app.api.chats.get_join_requests(
+            chat_id=chat_id,
+            count=count,
+        )
+
+    async def confirm_join_requests(
+        self,
+        chat_id: int,
+        user_ids: list[int],
+        show_history: bool = True,
+    ) -> Chat | None:
+        """Подтверждает несколько заявок на вступление.
+
+        Args:
+            chat_id: ID группы или канала.
+            user_ids: ID пользователей, чьи заявки нужно подтвердить.
+            show_history: Показать новым участникам историю сообщений.
+
+        Returns:
+            Обновленный чат или ``None``, если сервер не вернул чат.
+        """
+        return await self._app.api.chats.confirm_join_requests(
+            chat_id=chat_id,
+            user_ids=user_ids,
+            show_history=show_history,
+        )
+
+    async def confirm_join_request(
+        self,
+        chat_id: int,
+        user_id: int,
+        show_history: bool = True,
+    ) -> Chat | None:
+        """Подтверждает одну заявку на вступление.
+
+        Args:
+            chat_id: ID группы или канала.
+            user_id: ID пользователя, чью заявку нужно подтвердить.
+            show_history: Показать новому участнику историю сообщений.
+
+        Returns:
+            Обновленный чат или ``None``, если сервер не вернул чат.
+        """
+        return await self._app.api.chats.confirm_join_request(
+            chat_id=chat_id,
+            user_id=user_id,
+            show_history=show_history,
+        )
+
+    async def decline_join_requests(
+        self,
+        chat_id: int,
+        user_ids: list[int],
+    ) -> Chat | None:
+        """Отклоняет несколько заявок на вступление.
+
+        Args:
+            chat_id: ID группы или канала.
+            user_ids: ID пользователей, чьи заявки нужно отклонить.
+
+        Returns:
+            Обновленный чат или ``None``, если сервер не вернул чат.
+        """
+        return await self._app.api.chats.decline_join_requests(
+            chat_id=chat_id,
+            user_ids=user_ids,
+        )
+
+    async def decline_join_request(
+        self,
+        chat_id: int,
+        user_id: int,
+    ) -> Chat | None:
+        """Отклоняет одну заявку на вступление.
+
+        Args:
+            chat_id: ID группы или канала.
+            user_id: ID пользователя, чью заявку нужно отклонить.
+
+        Returns:
+            Обновленный чат или ``None``, если сервер не вернул чат.
+        """
+        return await self._app.api.chats.decline_join_request(
+            chat_id=chat_id,
+            user_id=user_id,
+        )

pymax/protocol/tcp/compression.py

@@ -1,5 +1,7 @@
 class Lz4BlockCompression:
-    def decompress(self, src: bytes, max_output: int = 5 * 1024 * 1024) -> bytes:
+    def decompress(
+        self, src: bytes, max_output: int = 5 * 1024 * 1024
+    ) -> bytes:
         dst = bytearray()
         pos = 0
 

pymax/protocol/tcp/framing.py

@@ -4,15 +4,9 @@ from pymax.protocol import PackedPacket, TcpPacketHeader
 
 
 class TcpPacketFramer:
-    HEADER_STRUCT = struct.Struct(">BHBHI")
+    HEADER_STRUCT = struct.Struct(">BBHHI")
     HEADER_SIZE = HEADER_STRUCT.size
 
-    def _pack_cmd(self, cmd: int) -> int:
-        return (cmd & 0xFF) << 8
-
-    def _unpack_cmd(self, packed_cmd: int) -> int:
-        return (packed_cmd >> 8) & 0xFF
-
     def pack(
         self,
         *,
@@ -26,7 +20,7 @@ class TcpPacketFramer:
         packed_len = ((flags & 0xFF) << 24) | (len(payload_bytes) & 0x00FFFFFF)
         header = self.HEADER_STRUCT.pack(
             ver,
-            self._pack_cmd(cmd),
+            cmd,
             seq,
             opcode,
             packed_len,
@@ -37,7 +31,9 @@ class TcpPacketFramer:
         if len(data) < self.HEADER_SIZE:
             return None
 
-        ver, cmd, seq, opcode, packed_len = self.HEADER_STRUCT.unpack_from(data, 0)
+        ver, cmd, seq, opcode, packed_len = self.HEADER_STRUCT.unpack_from(
+            data, 0
+        )
         flags = (packed_len >> 24) & 0xFF
         payload_len = packed_len & 0x00FFFFFF
 
@@ -48,7 +44,7 @@ class TcpPacketFramer:
         return PackedPacket(
             header=TcpPacketHeader(
                 ver=ver,
-                cmd=self._unpack_cmd(cmd),
+                cmd=cmd,
                 seq=seq,
                 opcode=opcode,
                 flags=flags,
@@ -62,7 +58,6 @@ class TcpPacketFramer:
             return None
 
         _, _, _, _, packed_len = self.HEADER_STRUCT.unpack_from(data, 0)
-        flags = (packed_len >> 24) & 0xFF
         payload_len = packed_len & 0x00FFFFFF
 
         return payload_len

pymax/protocol/tcp/payload.py

@@ -7,7 +7,6 @@ from pymax.logging import get_logger
 
 from .compression import Lz4BlockCompression
 
-
 logger = get_logger(__name__)
 
 
@@ -44,7 +43,9 @@ class MsgpackPayloadCodec:
             return {}
 
         try:
-            return msgpack.unpackb(payload_bytes, raw=False, strict_map_key=False)
+            return msgpack.unpackb(
+                payload_bytes, raw=False, strict_map_key=False
+            )
         except msgpack.exceptions.ExtraData as e:
             if isinstance(e.unpacked, dict):
                 logger.debug(

pymax/protocol/tcp/protocol.py

@@ -3,7 +3,11 @@ from pymax.protocol import InboundFrame, OutboundFrame
 from pymax.protocol.base import BaseProtocol
 
 from .framing import TcpPacketFramer
-from .payload import Lz4BlockCompression, MsgpackPayloadCodec, TcpPayloadDecoder
+from .payload import (
+    Lz4BlockCompression,
+    MsgpackPayloadCodec,
+    TcpPayloadDecoder,
+)
 
 logger = get_logger(__name__)
 
@@ -21,7 +25,11 @@ class TcpProtocol(BaseProtocol):
         )
 
     def encode(self, frame: OutboundFrame) -> bytes:
-        payload_bytes = self.serializer.encode(frame.payload) if frame.payload is not None else b""
+        payload_bytes = (
+            self.serializer.encode(frame.payload)
+            if frame.payload is not None
+            else b""
+        )
 
         flags = 0
 
@@ -44,7 +52,9 @@ class TcpProtocol(BaseProtocol):
 
         packed_packet = self.framer.unpack(raw)
         if not packed_packet:
-            return InboundFrame(opcode=0, cmd=0, seq=None, payload=None, raw=None)
+            return InboundFrame(
+                opcode=0, cmd=0, seq=None, payload=None, raw=None
+            )
 
         logger.debug(
             "tcp frame decoded header ver=%s cmd=%s seq=%s opcode=%s flags=%s payload_len=%s",

pymax/protocol/ws/protocol.py

@@ -20,8 +20,14 @@ class WsProtocol(BaseProtocol):
             data = json.loads(raw)
             return InboundFrame.model_validate(data)
         except json.JSONDecodeError:
-            logger.debug("failed to decode websocket frame json", exc_info=True)
-            return InboundFrame(opcode=0, cmd=0, seq=None, payload=None, raw=None)
+            logger.debug(
+                "failed to decode websocket frame json", exc_info=True
+            )
+            return InboundFrame(
+                opcode=0, cmd=0, seq=None, payload=None, raw=None
+            )
         except ValidationError:
             logger.debug("failed to validate websocket frame", exc_info=True)
-            return InboundFrame(opcode=0, cmd=0, seq=None, payload=None, raw=None)
+            return InboundFrame(
+                opcode=0, cmd=0, seq=None, payload=None, raw=None
+            )

pymax/session/protocol.py

@@ -8,7 +8,11 @@ class StoreProtocol(Protocol):
     async def save_session(self, session_info: SessionInfo) -> None: ...
     async def update_token(self, old_token: str, new_token: str) -> None: ...
     async def load_session(self) -> SessionInfo | None: ...
-    async def load_session_by_device_id(self, device_id: str) -> SessionInfo | None: ...
-    async def load_session_by_phone(self, phone: str) -> SessionInfo | None: ...
+    async def load_session_by_device_id(
+        self, device_id: str
+    ) -> SessionInfo | None: ...
+    async def load_session_by_phone(
+        self, phone: str
+    ) -> SessionInfo | None: ...
     async def delete_session(self, token: str) -> None: ...
     async def close(self) -> None: ...

pymax/session/store.py

@@ -55,12 +55,24 @@ class SessionStore:
             )
             """
         )
-        await self._ensure_column(conn, "mt_instance_id", "TEXT NOT NULL DEFAULT ''")
-        await self._ensure_column(conn, "chats_sync", "INTEGER NOT NULL DEFAULT -1")
-        await self._ensure_column(conn, "contacts_sync", "INTEGER NOT NULL DEFAULT -1")
-        await self._ensure_column(conn, "drafts_sync", "INTEGER NOT NULL DEFAULT -1")
-        await self._ensure_column(conn, "presence_sync", "INTEGER NOT NULL DEFAULT -1")
-        await self._ensure_column(conn, "config_hash", "TEXT NOT NULL DEFAULT ''")
+        await self._ensure_column(
+            conn, "mt_instance_id", "TEXT NOT NULL DEFAULT ''"
+        )
+        await self._ensure_column(
+            conn, "chats_sync", "INTEGER NOT NULL DEFAULT -1"
+        )
+        await self._ensure_column(
+            conn, "contacts_sync", "INTEGER NOT NULL DEFAULT -1"
+        )
+        await self._ensure_column(
+            conn, "drafts_sync", "INTEGER NOT NULL DEFAULT -1"
+        )
+        await self._ensure_column(
+            conn, "presence_sync", "INTEGER NOT NULL DEFAULT -1"
+        )
+        await self._ensure_column(
+            conn, "config_hash", "TEXT NOT NULL DEFAULT ''"
+        )
         await conn.execute(
             """
             UPDATE sessions
@@ -81,7 +93,9 @@ class SessionStore:
             columns = {row["name"] for row in await cursor.fetchall()}
 
         if name not in columns:
-            await conn.execute(f"ALTER TABLE sessions ADD COLUMN {name} {definition}")
+            await conn.execute(
+                f"ALTER TABLE sessions ADD COLUMN {name} {definition}"
+            )
 
     async def save_session(self, session_info: SessionInfo) -> None:
         conn = await self._get_connection()
@@ -144,7 +158,9 @@ class SessionStore:
         )
         return self._row_to_session(row)
 
-    async def load_session_by_device_id(self, device_id: str) -> SessionInfo | None:
+    async def load_session_by_device_id(
+        self, device_id: str
+    ) -> SessionInfo | None:
         conn = await self._get_connection()
         logger.debug("loading session by device_id=%s", device_id)
         async with conn.execute(

pymax/telemetry/navigation.py

@@ -155,7 +155,9 @@ class NavigationPlanner:
             self.current_screen = self.history.pop()
             return self.current_screen
 
-        next_screen = self._weighted_choice(self.rules.graph[self.current_screen])
+        next_screen = self._weighted_choice(
+            self.rules.graph[self.current_screen]
+        )
         if next_screen != self.current_screen:
             self.history.append(self.current_screen)
             if len(self.history) > 4:

pymax/telemetry/service.py

@@ -88,10 +88,14 @@ class TelemetryService:
 
             while True:
                 self._session_id += 1
-                events = await self._collect_session_events(self._planner.new_profile())
+                events = await self._collect_session_events(
+                    self._planner.new_profile()
+                )
                 await self._send_events(events)
                 self._planner.reset_to_background()
-                await asyncio.sleep(self._between(self._timing.session_idle_delay))
+                await asyncio.sleep(
+                    self._between(self._timing.session_idle_delay)
+                )
 
         except asyncio.CancelledError:
             raise
@@ -159,7 +163,9 @@ class TelemetryService:
         except Exception:
             logger.debug("telemetry send failed", exc_info=True)
 
-    def _nav_event(self, screen_from: Screen, screen_to: Screen) -> TelemetryEvent:
+    def _nav_event(
+        self, screen_from: Screen, screen_to: Screen
+    ) -> TelemetryEvent:
         event = self._payloads.navigation(
             user_id=self._user_id,
             session_id=self._session_id,

pymax/transport/tcp.py

@@ -10,7 +10,9 @@ logger = get_logger(__name__)
 
 
 class TCPTransport(Transport):
-    def __init__(self, host: str, port: int, proxy: str | None, use_ssl: bool = True) -> None:
+    def __init__(
+        self, host: str, port: int, proxy: str | None, use_ssl: bool = True
+    ) -> None:
         self._host = host
         self._port = port
         self._proxy = proxy
@@ -57,10 +59,14 @@ class TCPTransport(Transport):
         )
 
     async def close(self) -> None:
-        if self._writer:
+        writer = self._writer
+        self._reader = None
+        self._writer = None
+
+        if writer:
             logger.debug("tcp close")
-            self._writer.close()
-            await self._writer.wait_closed()
+            writer.close()
+            await writer.wait_closed()
             logger.debug("tcp closed")
 
     async def send(self, data: bytes | str) -> None:

pymax/transport/websocket.py

@@ -1,5 +1,3 @@
-import asyncio
-
 from websockets import ClientConnection, Origin
 from websockets.asyncio import client
 

pymax/types/domain/__init__.py

@@ -1,10 +1,13 @@
 from .attachments import *
+from .bots import InitData
 from .chat import Chat
 from .error import MaxApiError
 from .folder import Folder, FolderList, FolderUpdate
 from .login import LoginResponse
+from .member import Member
 from .message import Message, ReactionCounter, ReactionInfo, ReadState
 from .name import Name
+from .presence import Presence
 from .profile import Profile
 from .session import Session
 from .sync import SyncOverrides, SyncState