maxapi-python 1.2.5__py3-none-any.whl → 2.0.0__py3-none-any.whl

pymax/mixins/telemetry.py

@@ -1,118 +0,0 @@
-import asyncio
-import random
-import time
-
-from pymax.exceptions import Error, SocketNotConnectedError
-from pymax.navigation import Navigation
-from pymax.payloads import (
-    NavigationEventParams,
-    NavigationEventPayload,
-    NavigationPayload,
-)
-from pymax.protocols import ClientProtocol
-from pymax.static.enum import Opcode
-
-
-class TelemetryMixin(ClientProtocol):
-    async def _send_navigation_event(self, events: list[NavigationEventPayload]) -> None:
-        try:
-            payload = NavigationPayload(events=events).model_dump(by_alias=True)
-            data = await self._send_and_wait(
-                opcode=Opcode.LOG,
-                payload=payload,
-            )
-            payload_data = data.get("payload", {})
-            if payload_data and payload_data.get("error"):
-                error = payload_data.get("error")
-                self.logger.error("Navigation event error: %s", error)
-        except Exception:
-            self.logger.warning("Failed to send navigation event", exc_info=True)
-            return
-
-    async def _send_cold_start(self) -> None:
-        if not self.me:
-            self.logger.error("Cannot send cold start, user not set")
-            return
-
-        payload = NavigationEventPayload(
-            event="COLD_START",
-            time=int(time.time() * 1000),
-            user_id=self.me.id,
-            params=NavigationEventParams(
-                action_id=self._action_id,
-                screen_to=Navigation.get_screen_id("chats_list_tab"),
-                screen_from=1,
-                source_id=1,
-                session_id=self._session_id,
-            ),
-        )
-
-        self._action_id += 1
-
-        await self._send_navigation_event([payload])
-
-    async def _send_random_navigation(self) -> None:
-        if not self.me:
-            self.logger.error("Cannot send navigation event, user not set")
-            return
-
-        screen_from = self._current_screen
-        screen_to = Navigation.get_random_navigation(screen_from)
-
-        self._action_id += 1
-        self._current_screen = screen_to
-
-        payload = NavigationEventPayload(
-            event="NAV",
-            time=int(time.time() * 1000),
-            user_id=self.me.id,
-            params=NavigationEventParams(
-                action_id=self._action_id,
-                screen_from=Navigation.get_screen_id(screen_from),
-                screen_to=Navigation.get_screen_id(screen_to),
-                source_id=1,
-                session_id=self._session_id,
-            ),
-        )
-
-        await self._send_navigation_event([payload])
-
-    def _get_random_sleep_time(self) -> int:
-        # TODO: вынести в статик
-        sleep_options = [
-            (1000, 3000),
-            (300, 1000),
-            (60, 300),
-            (5, 60),
-            (5, 20),
-        ]
-
-        weights = [0.05, 0.10, 0.15, 0.20, 0.50]
-
-        low, high = random.choices(  # nosec B311
-            sleep_options, weights=weights, k=1
-        )[0]
-        return random.randint(low, high)  # nosec B311
-
-    async def _start(self) -> None:
-        if not self.is_connected:
-            self.logger.error("Cannot start telemetry, client not connected")
-            return
-
-        await self._send_cold_start()
-
-        try:
-            while self.is_connected:
-                try:
-                    await self._send_random_navigation()
-                except SocketNotConnectedError:
-                    self.logger.debug("Socket disconnected, exiting telemetry task")
-                    break
-                except Exception:
-                    self.logger.warning("Failed to send random navigation")
-                await asyncio.sleep(self._get_random_sleep_time())
-
-        except asyncio.CancelledError:
-            self.logger.debug("Telemetry task cancelled")
-        except Exception:
-            self.logger.warning("Telemetry task failed", exc_info=True)

pymax/mixins/user.py

@@ -1,219 +0,0 @@
-from typing import Any, Literal
-
-from pymax.exceptions import Error, ResponseError, ResponseStructureError
-from pymax.payloads import (
-    ContactActionPayload,
-    FetchContactsPayload,
-    SearchByPhonePayload,
-)
-from pymax.protocols import ClientProtocol
-from pymax.static.enum import ContactAction, Opcode
-from pymax.types import Contact, Session, User
-from pymax.utils import MixinsUtils
-
-
-class UserMixin(ClientProtocol):
-    def get_cached_user(self, user_id: int) -> User | None:
-        """
-        Получает пользователя из кеша по его идентификатору.
-
-        Проверяет внутренний кеш пользователей и возвращает объект User
-        если пользователь был ранее загружен.
-
-        :param user_id: Идентификатор пользователя.
-        :type user_id: int
-        :return: Объект User из кеша или None, если пользователь не найден.
-        :rtype: User | None
-        """
-        user = self._users.get(user_id)
-        self.logger.debug("get_cached_user id=%s hit=%s", user_id, bool(user))
-        return user
-
-    async def get_users(self, user_ids: list[int]) -> list[User]:
-        """
-        Получает информацию о пользователях по их идентификаторам.
-
-        Метод использует внутренний кеш для избежания повторных запросов.
-        Если пользователь уже загружен, берется из кеша, иначе выполняется
-        сетевой запрос к серверу.
-
-        :param user_ids: Список идентификаторов пользователей.
-        :type user_ids: list[int]
-        :return: Список объектов User в порядке, соответствующем входному списку.
-        :rtype: list[User]
-        """
-        self.logger.debug("get_users ids=%s", user_ids)
-        cached = {uid: self._users[uid] for uid in user_ids if uid in self._users}
-        missing_ids = [uid for uid in user_ids if uid not in self._users]
-
-        if missing_ids:
-            self.logger.debug("Fetching missing users: %s", missing_ids)
-            fetched_users = await self.fetch_users(missing_ids)
-            if fetched_users:
-                for user in fetched_users:
-                    self._users[user.id] = user
-                    cached[user.id] = user
-
-        ordered = [cached[uid] for uid in user_ids if uid in cached]
-        self.logger.debug("get_users result_count=%d", len(ordered))
-        return ordered
-
-    async def get_user(self, user_id: int) -> User | None:
-        """
-        Получает информацию о пользователе по его идентификатору.
-
-        Метод использует внутренний кеш. Если пользователь уже загружен,
-        возвращает его из кеша, иначе выполняет запрос к серверу.
-
-        :param user_id: Идентификатор пользователя.
-        :type user_id: int
-        :return: Объект User или None, если пользователь не найден.
-        :rtype: User | None
-        """
-        self.logger.debug("get_user id=%s", user_id)
-        if user_id in self._users:
-            return self._users[user_id]
-
-        users = await self.fetch_users([user_id])
-        if users:
-            self._users[user_id] = users[0]
-            return users[0]
-        return None
-
-    async def fetch_users(self, user_ids: list[int]) -> list[User]:
-        """
-        Загружает информацию о пользователях с сервера.
-
-        Запрашивает данные о пользователях по их идентификаторам и добавляет
-        их в внутренний кеш.
-
-        :param user_ids: Список идентификаторов пользователей для загрузки.
-        :type user_ids: list[int]
-        :return: Список загруженных объектов User.
-        :rtype: list[User]
-        """
-        self.logger.info("Fetching users count=%d", len(user_ids))
-
-        payload = FetchContactsPayload(contact_ids=user_ids).model_dump(by_alias=True)
-
-        data = await self._send_and_wait(opcode=Opcode.CONTACT_INFO, payload=payload)
-
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        users = [User.from_dict(u) for u in data["payload"].get("contacts", [])]
-        for user in users:
-            self._users[user.id] = user
-
-        self.logger.debug("Fetched users: %d", len(users))
-        return users
-
-    async def search_by_phone(self, phone: str) -> User:
-        """
-        Выполняет поиск пользователя по номеру телефона.
-
-        :param phone: Номер телефона пользователя.
-        :type phone: str
-        :return: Объект User с найденными данными пользователя.
-        :rtype: User
-        :raises Error: Если пользователь не найден или произошла ошибка.
-        """
-        self.logger.info("Searching user by phone: %s", phone)
-
-        payload = SearchByPhonePayload(phone=phone).model_dump(by_alias=True)
-
-        data = await self._send_and_wait(opcode=Opcode.CONTACT_INFO_BY_PHONE, payload=payload)
-
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        if not data.get("payload"):
-            raise Error("no_payload", "No payload in response", "User Error")
-
-        user = User.from_dict(data["payload"]["contact"])
-        if not user:
-            raise Error("no_user", "User data missing in response", "User Error")
-
-        self._users[user.id] = user
-        self.logger.debug("Found user by phone: %s", user)
-        return user
-
-    async def get_sessions(self) -> list[Session]:
-        """
-        Получает информацию о всех активных сессиях пользователя.
-
-        Возвращает список всех сессий, в которых авторизован пользователь.
-
-        :return: Список объектов Session.
-        :rtype: list[Session]
-        :raises Error: Если произошла ошибка при получении данных.
-        """
-        self.logger.info("Fetching sessions")
-
-        data = await self._send_and_wait(opcode=Opcode.SESSIONS_INFO, payload={})
-
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        if not data.get("payload"):
-            raise Error("no_payload", "No payload in response", "Session Error")
-
-        return [Session.from_dict(s) for s in data["payload"].get("sessions", [])]
-
-    async def _contact_action(self, payload: ContactActionPayload) -> dict[str, Any]:
-        data = await self._send_and_wait(
-            opcode=Opcode.CONTACT_UPDATE,  # 34
-            payload=payload.model_dump(by_alias=True),
-        )
-        response_payload = data.get("payload")
-        if not isinstance(response_payload, dict):
-            raise ResponseStructureError("Invalid response structure")
-        if error := response_payload.get("error"):
-            raise ResponseError(error)
-        return response_payload
-
-    async def add_contact(self, contact_id: int) -> Contact:
-        """
-        Добавляет контакт в список контактов
-
-        :param contact_id: ID контакта
-        :type contact_id: int
-        :return: Объект контакта
-        :rtype: Contact
-        :raises ResponseStructureError: Если структура ответа неверна
-        """
-        payload = await self._contact_action(
-            ContactActionPayload(contact_id=contact_id, action=ContactAction.ADD)
-        )
-        contact_dict = payload.get("contact")
-        if isinstance(contact_dict, dict):
-            return Contact.from_dict(contact_dict)
-        raise ResponseStructureError("Wrong contact structure in response")
-
-    async def remove_contact(self, contact_id: int) -> Literal[True]:
-        """
-        Удаляет контакт из списка контактов
-
-        :param contact_id: ID контакта
-        :type contact_id: int
-        :return: True если успешно
-        :rtype: Literal[True]
-        :raises ResponseStructureError: Если структура ответа неверна
-        """
-        await self._contact_action(
-            ContactActionPayload(contact_id=contact_id, action=ContactAction.REMOVE)
-        )
-        return True
-
-    def get_chat_id(self, first_user_id: int, second_user_id: int) -> int:
-        """
-        Получение айди лс (диалога)
-
-        :param first_user_id: ID первого пользователя
-        :type first_user_id: int
-        :param second_user_id: ID второго пользователя
-        :type second_user_id: int
-        :return: Айди диалога
-        :rtype: int
-        """
-        return first_user_id ^ second_user_id

pymax/mixins/websocket.py

@@ -1,151 +0,0 @@
-import asyncio
-import json
-from typing import Any
-
-import websockets
-from typing_extensions import override
-
-from pymax.exceptions import WebSocketNotConnectedError
-from pymax.interfaces import BaseTransport
-from pymax.payloads import UserAgentPayload
-from pymax.static.constant import (
-    DEFAULT_TIMEOUT,
-    RECV_LOOP_BACKOFF_DELAY,
-    WEBSOCKET_ORIGIN,
-)
-from pymax.static.enum import Opcode
-from pymax.types import (
-    Chat,
-)
-
-
-class WebSocketMixin(BaseTransport):
-    @property
-    def ws(self) -> websockets.ClientConnection:
-        if self._ws is None or not self.is_connected:
-            self.logger.critical("WebSocket not connected when access attempted")
-            raise WebSocketNotConnectedError
-        return self._ws
-
-    async def connect(self, user_agent: UserAgentPayload | None = None) -> dict[str, Any] | None:
-        """
-        Устанавливает соединение WebSocket с сервером и выполняет handshake.
-
-        :param user_agent: Пользовательский агент для handshake. Если None, используется значение по умолчанию.
-        :type user_agent: UserAgentPayload | None
-        :return: Результат handshake.
-        :rtype: dict[str, Any] | None
-        """
-        if user_agent is None:
-            user_agent = UserAgentPayload()
-
-        self.logger.info("Connecting to WebSocket %s", self.uri)
-
-        if self._ws is not None or self.is_connected:
-            self.logger.warning("WebSocket already connected")
-            return
-
-        self._ws = await websockets.connect(
-            self.uri,
-            origin=WEBSOCKET_ORIGIN,
-            user_agent_header=user_agent.header_user_agent,
-            proxy=self.proxy,
-        )
-        self.is_connected = True
-        self._incoming = asyncio.Queue()
-        self._outgoing = asyncio.Queue()
-        self._pending = {}
-        self._recv_task = asyncio.create_task(self._recv_loop())
-        self._outgoing_task = asyncio.create_task(self._outgoing_loop())
-        self.logger.info("WebSocket connected, starting handshake")
-        return await self._handshake(user_agent)
-
-    async def _recv_loop(self) -> None:
-        if self._ws is None:
-            self.logger.warning("Recv loop started without websocket instance")
-            return
-
-        self.logger.debug("Receive loop started")
-        while True:
-            try:
-                raw = await self._ws.recv()
-                data = self._parse_json(raw)
-
-                if data is None:
-                    continue
-
-                seq = data.get("seq")
-                if self._handle_pending(seq, data):
-                    continue
-
-                await self._handle_incoming_queue(data)
-                await self._dispatch_incoming(data)
-
-            except websockets.exceptions.ConnectionClosed as e:
-                self.logger.info(
-                    f"WebSocket connection closed with error: {e.code}, {e.reason}; exiting recv loop"
-                )
-                for fut in self._pending.values():
-                    if not fut.done():
-                        fut.set_exception(WebSocketNotConnectedError)
-                self._pending.clear()
-
-                self.is_connected = False
-                self._ws = None
-                self._recv_task = None
-
-                break
-            except Exception:
-                self.logger.exception("Error in recv_loop; backing off briefly")
-                await asyncio.sleep(RECV_LOOP_BACKOFF_DELAY)
-
-    @override
-    async def _send_and_wait(
-        self,
-        opcode: Opcode,
-        payload: dict[str, Any],
-        cmd: int = 0,
-        timeout: float = DEFAULT_TIMEOUT,
-    ) -> dict[str, Any]:
-        ws = self.ws
-        msg = self._make_message(opcode, payload, cmd)
-        loop = asyncio.get_running_loop()
-        fut: asyncio.Future[dict[str, Any]] = loop.create_future()
-        seq_key = msg["seq"]
-
-        old_fut = self._pending.get(seq_key)
-        if old_fut and not old_fut.done():
-            old_fut.cancel()
-
-        self._pending[seq_key] = fut
-
-        try:
-            self.logger.debug(
-                "Sending frame opcode=%s cmd=%s seq=%s",
-                opcode,
-                cmd,
-                msg["seq"],
-            )
-            await ws.send(json.dumps(msg))
-            data = await asyncio.wait_for(fut, timeout=timeout)
-            self.logger.debug(
-                "Received frame for seq=%s opcode=%s",
-                data.get("seq"),
-                data.get("opcode"),
-            )
-            return data
-        except asyncio.TimeoutError:
-            self.logger.exception("Send and wait failed (opcode=%s, seq=%s)", opcode, msg["seq"])
-            raise RuntimeError("Send and wait failed")
-        except Exception:
-            self.logger.exception("Send and wait failed (opcode=%s, seq=%s)", opcode, msg["seq"])
-            raise RuntimeError("Send and wait failed")
-        finally:
-            self._pending.pop(seq_key, None)
-
-    @override
-    async def _get_chat(self, chat_id: int) -> Chat | None:
-        for chat in self.chats:
-            if chat.id == chat_id:
-                return chat
-        return None

pymax/models.py

@@ -1,8 +0,0 @@
-from uuid import UUID, uuid4
-
-from sqlmodel import Field, SQLModel
-
-
-class Auth(SQLModel, table=True):
-    token: str | None = None
-    device_id: UUID = Field(default_factory=uuid4, primary_key=True)

pymax/navigation.py

@@ -1,187 +0,0 @@
-import random
-
-
-class Navigation:
-    SCREENS_GRAPH = {  # noqa: RUF012
-        "chats_list_tab": [
-            "chat",
-            "contacts_tab",
-            "call_history_tab",
-            "settings_tab",
-            "create_chat",
-            "chat_attachments_voices",
-        ],
-        "chat": [
-            "chats_list_tab",
-            "chat_attachments_media",
-        ],
-        "contacts_tab": [
-            "call_history_tab",
-            "chats_list_tab",
-            "settings_tab",
-            "create_chat",
-        ],
-        "call_history_tab": [
-            "chats_list_tab",
-            "settings_tab",
-            "contacts_tab",
-        ],
-        "settings_tab": [
-            "settings_folders",
-            "settings_privacy",
-            "settings_notifications",
-            "settings_chat_decoration",
-            "call_history_tab",
-            "contacts_tab",
-            "chats_list_tab",
-        ],
-        "settings_folders": [
-            "settings_tab",
-            "chats_list_tab",
-            "contacts_tab",
-            "call_history_tab",
-        ],
-        "settings_privacy": [
-            "settings_tab",
-            "chats_list_tab",
-            "contacts_tab",
-            "call_history_tab",
-        ],
-        "settings_notifications": [
-            "settings_tab",
-            "contacts_tab",
-            "call_history_tab",
-            "chats_list_tab",
-        ],
-        "settings_chat_decoration": [
-            "settings_tab",
-            "chats_list_tab",
-            "contacts_tab",
-            "call_history_tab",
-        ],
-        "create_chat": [
-            "chats_list_tab",
-            "contacts_tab",
-        ],
-        "chat_attachments_media": [
-            "chat_attachments_files",
-            "chat_attachments_voices",
-            "chat_attachments_links",
-            "chat",
-        ],
-        "chat_attachments_files": [
-            "chat_attachments_voices",
-            "chat_attachments_media",
-            "chat_attachments_links",
-            "chat",
-        ],
-        "chat_attachments_voices": [
-            "chat_attachments_links",
-            "chat_attachments_media",
-            "chat_attachments_files",
-            "chat",
-        ],
-        "chat_attachments_links": [
-            "chat_attachments_media",
-            "chat_attachments_files",
-            "chat_attachments_voices",
-            "chat",
-        ],
-    }
-    SCREENS = {  # noqa: RUF012
-        "application_background": 1,
-        "auth_sign_method": 50,
-        "auth_phone_login": 51,
-        "auth_otp": 52,
-        "auth_empty_profile": 53,
-        "auth_avatars": 54,
-        "contacts_tab": 100,
-        "contacts_search": 102,
-        "contacts_search_by_phone": 103,
-        "chats_list_tab": 150,
-        "chats_list_search_initial": 151,
-        "chats_list_search_result": 152,
-        "create_chat": 200,
-        "create_chat_members_picker": 201,
-        "create_chat_info": 202,
-        "avatar_picker_gallery": 250,
-        "avatar_picker_crop": 251,
-        "avatar_picker_camera": 252,
-        "avatar_viewer": 253,
-        "call_history_tab": 300,
-        "call_new_call": 302,
-        "call_create_group_link": 303,
-        "call_add_participants": 304,
-        "call": 305,
-        "chat": 350,
-        "chat_attach_picker": 351,
-        "chat_attach_picker_media_viewer": 352,
-        "chat_attach_picker_camera": 353,
-        "chat_share_location": 354,
-        "chat_share_contact": 355,
-        "chat_forward": 357,
-        "chat_media_viewer": 358,
-        "chat_system_file_viewer": 359,
-        "chat_location_viewer": 360,
-        "chat_info": 400,
-        "chat_info_all_participants": 401,
-        "chat_info_editing": 402,
-        "chat_info_add_participants": 403,
-        "chat_info_administrators": 404,
-        "chat_info_add_administrator": 405,
-        "chat_info_blocked_participants": 406,
-        "chat_info_change_owner": 407,
-        "chat_attachments_media": 408,
-        "chat_attachments_files": 409,
-        "chat_attachments_links": 410,
-        "chat_info_invite_link": 411,
-        "chat_attachments_voices": 412,
-        "settings_tab": 450,
-        "settings_profile_editing": 451,
-        "settings_shortname_change": 452,
-        "settings_phone_change": 453,
-        "settings_notifications": 454,
-        "settings_notifications_system": 455,
-        "settings_folders": 456,
-        "settings_privacy": 457,
-        "settings_privacy_block_list": 458,
-        "settings_media": 459,
-        "settings_messages": 460,
-        "settings_stickers": 461,
-        "settings_chat_decoration": 462,
-        "settings_phone_change_phone_input": 463,
-        "settings_phone_change_phone_otp": 464,
-        "settings_cache": 465,
-        "settings_profile_avatars": 466,
-        "settings_about_application": 467,
-        "settings_privacy_sensitive_content": 479,
-        "miniapp": 500,
-    }
-
-    @classmethod
-    def get_screen_id(cls, screen_name: str) -> int:
-        screen_id = cls.SCREENS.get(screen_name)
-
-        if screen_id is None:
-            raise ValueError(f"Unknown screen name: {screen_name}")
-
-        return screen_id
-
-    @classmethod
-    def can_navigate(cls, from_screen: str, to_screen: str) -> bool:
-        if from_screen == to_screen:
-            return True
-        return to_screen in cls.SCREENS_GRAPH.get(from_screen, [])
-
-    @classmethod
-    def get_random_navigation(cls, screen_name: str) -> str:
-        return random.choice(  # nosec B311
-            cls.SCREENS_GRAPH.get(screen_name, [])
-        )
-
-    @classmethod
-    def get_screen_name(cls, screen_id: int) -> str | None:
-        for name, id_ in cls.SCREENS.items():
-            if id_ == screen_id:
-                return name
-        return None