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

pymax/mixins/scheduler.py

@@ -1,28 +0,0 @@
-import asyncio
-import traceback
-from collections.abc import Awaitable, Callable
-from typing import Any
-
-from pymax.protocols import ClientProtocol
-
-
-class SchedulerMixin(ClientProtocol):
-    async def _run_periodic(
-        self, func: Callable[[], Any | Awaitable[Any]], interval: float
-    ) -> None:
-        while True:
-            try:
-                result = func()
-                if asyncio.iscoroutine(result):
-                    await result
-            except Exception as e:
-                tb = traceback.format_exc()
-                self.logger.error(f"Error in scheduled task {func}: {e}")
-                raise
-            await asyncio.sleep(interval)
-
-    async def _start_scheduled_tasks(self) -> None:
-        for func, interval in self._scheduled_tasks:
-            task = asyncio.create_task(self._run_periodic(func, interval))
-            self._background_tasks.add(task)
-            task.add_done_callback(self._background_tasks.discard)

pymax/mixins/self.py

@@ -1,259 +0,0 @@
-import urllib.parse
-from http import HTTPStatus
-from typing import Any
-from urllib.parse import parse_qs, urlparse
-from uuid import uuid4
-
-import aiohttp
-
-from pymax.exceptions import Error
-from pymax.files import Photo
-from pymax.payloads import (
-    ChangeProfilePayload,
-    CreateFolderPayload,
-    DeleteFolderPayload,
-    GetFolderPayload,
-    UpdateFolderPayload,
-    UploadPayload,
-)
-from pymax.protocols import ClientProtocol
-from pymax.static.enum import Opcode
-from pymax.types import Folder, FolderList, FolderUpdate, Me
-from pymax.utils import MixinsUtils
-
-
-class SelfMixin(ClientProtocol):
-    async def _request_photo_upload_url(self) -> str:
-        self.logger.info("Requesting profile photo upload URL")
-
-        data = await self._send_and_wait(
-            opcode=Opcode.PHOTO_UPLOAD,
-            payload=UploadPayload(profile=True).model_dump(by_alias=True),
-        )
-
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        return data["payload"]["url"]
-
-    async def _upload_profile_photo(self, upload_url: str, photo: Photo) -> str:
-        self.logger.info("Uploading profile photo")
-
-        parsed_url = urlparse(upload_url)
-        photo_id = parse_qs(parsed_url.query)["photoIds"][0]
-
-        form = aiohttp.FormData()
-        form.add_field(
-            "file",
-            await photo.read(),
-            filename=photo.file_name,
-        )
-
-        async with (
-            aiohttp.ClientSession() as session,
-            session.post(upload_url, data=form) as response,
-        ):
-            if response.status != HTTPStatus.OK:
-                raise Error(
-                    "Failed to upload profile photo.", message="UploadError", title="Upload Error"
-                )
-
-            self.logger.info("Upload successful")
-            data = await response.json()
-            return data["photos"][photo_id][
-                "token"
-            ]  # TODO: сделать нормальную типизацию и чекнинг ответа
-
-    async def change_profile(
-        self,
-        first_name: str,
-        last_name: str | None = None,
-        description: str | None = None,
-        photo: Photo | None = None,
-    ) -> bool:
-        """
-        Изменяет информацию профиля текущего пользователя.
-
-        :param first_name: Имя пользователя.
-        :type first_name: str
-        :param last_name: Фамилия пользователя. По умолчанию None.
-        :type last_name: str | None
-        :param description: Описание профиля. По умолчанию None.
-        :type description: str | None
-        :return: True, если профиль успешно изменен.
-        :rtype: bool
-        """
-
-        if photo:
-            upload_url = await self._request_photo_upload_url()
-            photo_token = await self._upload_profile_photo(upload_url, photo)
-
-            payload = ChangeProfilePayload(
-                first_name=first_name,
-                last_name=last_name,
-                description=description,
-                photo_token=photo_token,
-            ).model_dump(
-                by_alias=True,
-                exclude_none=True,
-            )
-        else:
-            payload = ChangeProfilePayload(
-                first_name=first_name,
-                last_name=last_name,
-                description=description,
-            ).model_dump(
-                by_alias=True,
-                exclude_none=True,
-            )
-
-        data = await self._send_and_wait(opcode=Opcode.PROFILE, payload=payload)
-
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        self.me = Me.from_dict(data["payload"]["profile"]["contact"])
-
-        return True
-
-    async def create_folder(
-        self, title: str, chat_include: list[int], filters: list[Any] | None = None
-    ) -> FolderUpdate:
-        """
-        Создает новую папку для группировки чатов.
-
-        :param title: Название папки.
-        :type title: str
-        :param chat_include: Список ID чатов для включения в папку.
-        :type chat_include: list[int]
-        :param filters: Список фильтров для папки (опциональный параметр).
-        :type filters: list[Any] | None
-        :return: Объект FolderUpdate с информацией о созданной папке.
-        :rtype: FolderUpdate
-        """
-        self.logger.info("Creating folder")
-
-        payload = CreateFolderPayload(
-            id=str(uuid4()),
-            title=title,
-            include=chat_include,
-            filters=filters or [],
-        ).model_dump(by_alias=True)
-
-        data = await self._send_and_wait(opcode=Opcode.FOLDERS_UPDATE, payload=payload)
-
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        return FolderUpdate.from_dict(data.get("payload", {}))
-
-    async def get_folders(self, folder_sync: int = 0) -> FolderList:
-        """
-        Получает список всех папок пользователя.
-
-        :param folder_sync: Синхронизационный маркер папок. По умолчанию 0.
-        :type folder_sync: int
-        :return: Объект FolderList с информацией о папках.
-        :rtype: FolderList
-        """
-        self.logger.info("Fetching folders")
-
-        payload = GetFolderPayload(folder_sync=folder_sync).model_dump(by_alias=True)
-
-        data = await self._send_and_wait(opcode=Opcode.FOLDERS_GET, payload=payload)
-
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        return FolderList.from_dict(data.get("payload", {}))
-
-    async def update_folder(
-        self,
-        folder_id: str,
-        title: str,
-        chat_include: list[int] | None = None,
-        filters: list[Any] | None = None,
-        options: list[Any] | None = None,
-    ) -> FolderUpdate | None:
-        """
-        Обновляет параметры существующей папки.
-
-        :param folder_id: Идентификатор папки.
-        :type folder_id: str
-        :param title: Название папки.
-        :type title: str
-        :param chat_include: Список ID чатов для включения в папку.
-        :type chat_include: list[int] | None
-        :param filters: Список фильтров для папки.
-        :type filters: list[Any] | None
-        :param options: Список опций для папки.
-        :type options: list[Any] | None
-        :return: Объект FolderUpdate с результатом или None.
-        :rtype: FolderUpdate | None
-        """
-        self.logger.info("Updating folder")
-
-        payload = UpdateFolderPayload(
-            id=folder_id,
-            title=title,
-            include=chat_include or [],
-            filters=filters or [],
-            options=options or [],
-        ).model_dump(by_alias=True, exclude_none=True)
-
-        data = await self._send_and_wait(opcode=Opcode.FOLDERS_UPDATE, payload=payload)
-
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        return FolderUpdate.from_dict(data.get("payload", {}))
-
-    async def delete_folder(self, folder_id: str) -> FolderUpdate | None:
-        """
-        Удаляет папку.
-
-        :param folder_id: Идентификатор папки для удаления.
-        :type folder_id: str
-        :return: Объект FolderUpdate с результатом операции или None.
-        :rtype: FolderUpdate | None
-        """
-        self.logger.info("Deleting folder")
-
-        payload = DeleteFolderPayload(folder_ids=[folder_id]).model_dump(by_alias=True)
-        data = await self._send_and_wait(opcode=Opcode.FOLDERS_DELETE, payload=payload)
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        return FolderUpdate.from_dict(data.get("payload", {}))
-
-    async def close_all_sessions(self) -> bool:
-        """
-        Закрывает все активные сессии, кроме текущей.
-
-        :return: True, если операция выполнена успешно.
-        :rtype: bool
-        """
-        self.logger.info("Closing all other sessions")
-
-        data = await self._send_and_wait(opcode=Opcode.SESSIONS_CLOSE, payload={})
-
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        return True
-
-    async def logout(self) -> bool:
-        """
-        Выполняет выход из текущей сессии.
-
-        :return: True, если выход выполнен успешно.
-        :rtype: bool
-        """
-        self.logger.info("Logging out")
-
-        data = await self._send_and_wait(opcode=Opcode.LOGOUT, payload={})
-
-        if data.get("payload", {}).get("error"):
-            MixinsUtils.handle_error(data)
-
-        return True

pymax/mixins/socket.py

@@ -1,297 +0,0 @@
-import asyncio
-import socket
-import ssl
-import sys
-import time
-from collections.abc import Callable
-from typing import Any
-
-import lz4.block
-import msgpack
-from typing_extensions import override
-
-from pymax.exceptions import Error, SocketNotConnectedError, SocketSendError
-from pymax.filters import BaseFilter
-from pymax.interfaces import BaseTransport
-from pymax.payloads import BaseWebSocketMessage, SyncPayload, UserAgentPayload
-from pymax.protocols import ClientProtocol
-from pymax.static.constant import (
-    DEFAULT_PING_INTERVAL,
-    DEFAULT_TIMEOUT,
-    RECV_LOOP_BACKOFF_DELAY,
-)
-from pymax.static.enum import ChatType, MessageStatus, Opcode
-from pymax.types import (
-    Channel,
-    Chat,
-    Dialog,
-    Me,
-    Message,
-    ReactionCounter,
-    ReactionInfo,
-    User,
-)
-
-
-class SocketMixin(BaseTransport):
-    @property
-    def sock(self) -> socket.socket:
-        if self._socket is None or not self.is_connected:
-            self.logger.critical("Socket not connected when access attempted")
-            raise SocketNotConnectedError()
-        return self._socket
-
-    def _unpack_packet(self, data: bytes) -> dict[str, Any] | None:
-        ver = int.from_bytes(data[0:1], "big")
-        cmd = int.from_bytes(data[1:3], "big")
-        seq = int.from_bytes(data[3:4], "big")
-        opcode = int.from_bytes(data[4:6], "big")
-        packed_len = int.from_bytes(data[6:10], "big", signed=False)
-        comp_flag = packed_len >> 24
-        payload_length = packed_len & 0xFFFFFF
-        payload_bytes = data[10 : 10 + payload_length]
-
-        payload = None
-        if payload_bytes:
-            if comp_flag != 0:
-                # TODO: надо выяснить правильный размер распаковки
-                # uncompressed_size = int.from_bytes(payload_bytes[0:4], "big")
-                compressed_data = payload_bytes
-                try:
-                    payload_bytes = lz4.block.decompress(
-                        compressed_data,
-                        uncompressed_size=99999,
-                    )
-                except lz4.block.LZ4BlockError:
-                    return None
-            payload = msgpack.unpackb(payload_bytes, raw=False, strict_map_key=False)
-
-        return {
-            "ver": ver,
-            "cmd": cmd,
-            "seq": seq,
-            "opcode": opcode,
-            "payload": payload,
-        }
-
-    def _pack_packet(
-        self,
-        ver: int,
-        cmd: int,
-        seq: int,
-        opcode: int,
-        payload: dict[str, Any],
-    ) -> bytes:
-        ver_b = ver.to_bytes(1, "big")
-        cmd_b = cmd.to_bytes(2, "big")
-        seq_b = seq.to_bytes(1, "big")
-        opcode_b = opcode.to_bytes(2, "big")
-        payload_bytes: bytes | None = msgpack.packb(payload)
-        if payload_bytes is None:
-            payload_bytes = b""
-        payload_len = len(payload_bytes) & 0xFFFFFF
-        self.logger.debug("Packing message: payload size=%d bytes", len(payload_bytes))
-        payload_len_b = payload_len.to_bytes(4, "big")
-        return ver_b + cmd_b + seq_b + opcode_b + payload_len_b + payload_bytes
-
-    async def connect(self, user_agent: UserAgentPayload | None = None) -> dict[str, Any]:
-        """
-        Устанавливает соединение с сервером и выполняет 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()
-        if sys.version_info[:2] == (3, 12):
-            self.logger.warning(
-                """
-===============================================================
-         ⚠️⚠️ \033[0;31mWARNING: Python 3.12 detected!\033[0m ⚠️⚠️
-Socket connections may be unstable, SSL issues are possible.
-===============================================================
-    """
-            )
-        self.logger.info("Connecting to socket %s:%s", self.host, self.port)
-        loop = asyncio.get_running_loop()
-        raw_sock = await loop.run_in_executor(
-            None, lambda: socket.create_connection((self.host, self.port))
-        )
-        self._socket = self._ssl_context.wrap_socket(raw_sock, server_hostname=self.host)
-        self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-        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("Socket connected, starting handshake")
-        return await self._handshake(user_agent)
-
-    def _recv_exactly(self, sock: socket.socket, n: int) -> bytes:
-        buf = bytearray()
-        while len(buf) < n:
-            chunk = sock.recv(n - len(buf))
-            if not chunk:
-                return bytes(buf)
-            buf.extend(chunk)
-        return bytes(buf)
-
-    async def _parse_header(
-        self, loop: asyncio.AbstractEventLoop, sock: socket.socket
-    ) -> bytes | None:
-        header = await loop.run_in_executor(None, lambda: self._recv_exactly(sock=sock, n=10))
-        if not header or len(header) < 10:
-            self.logger.info("Socket connection closed; exiting recv loop")
-            self.is_connected = False
-            try:
-                sock.close()
-            except Exception:
-                return None
-
-        return header
-
-    async def _recv_data(
-        self, loop: asyncio.AbstractEventLoop, header: bytes, sock: socket.socket
-    ) -> list[dict[str, Any]] | None:
-        packed_len = int.from_bytes(header[6:10], "big", signed=False)
-        payload_length = packed_len & 0xFFFFFF
-        remaining = payload_length
-        payload = bytearray()
-
-        while remaining > 0:
-            min_read = min(remaining, 8192)
-            chunk = await loop.run_in_executor(None, lambda: self._recv_exactly(sock, min_read))
-            if not chunk:
-                self.logger.error("Connection closed while reading payload")
-                break
-            payload.extend(chunk)
-            remaining -= len(chunk)
-
-        if remaining > 0:
-            self.logger.error("Incomplete payload received; skipping packet")
-            return None
-
-        raw = header + payload
-        if len(raw) < 10 + payload_length:
-            self.logger.error(
-                "Incomplete packet: expected %d bytes, got %d",
-                10 + payload_length,
-                len(raw),
-            )
-            await asyncio.sleep(RECV_LOOP_BACKOFF_DELAY)
-            return None
-
-        data = self._unpack_packet(raw)
-        if not data:
-            self.logger.warning("Failed to unpack packet, skipping")
-            return None
-
-        payload_objs = data.get("payload")
-        return (
-            [{**data, "payload": obj} for obj in payload_objs]
-            if isinstance(payload_objs, list)
-            else [data]
-        )
-
-    async def _recv_loop(self) -> None:
-        if self._socket is None:
-            self.logger.warning("Recv loop started without socket instance")
-            return
-
-        sock = self._socket
-        loop = asyncio.get_running_loop()
-
-        while True:
-            try:
-                header = await self._parse_header(loop, sock)
-
-                if not header:
-                    break
-
-                datas = await self._recv_data(loop, header, sock)
-
-                if not datas:
-                    continue
-
-                for data_item in datas:
-                    seq = data_item.get("seq")
-
-                    if self._handle_pending(seq, data_item):
-                        continue
-
-                    if self._incoming is not None:
-                        await self._handle_incoming_queue(data_item)
-
-                    await self._dispatch_incoming(data_item)
-
-            except asyncio.CancelledError:
-                self.logger.debug("Recv loop cancelled")
-                raise
-            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]:
-        if not self.is_connected or self._socket is None:
-            raise SocketNotConnectedError
-
-        sock = self.sock
-        msg = self._make_message(opcode, payload, cmd)
-        loop = asyncio.get_running_loop()
-        fut: asyncio.Future[dict[str, Any]] = loop.create_future()
-        self._pending[msg["seq"]] = fut
-        try:
-            self.logger.debug(
-                "Sending frame opcode=%s cmd=%s seq=%s",
-                opcode,
-                cmd,
-                msg["seq"],
-            )
-            packet = self._pack_packet(
-                msg["ver"],
-                msg["cmd"],
-                msg["seq"],
-                msg["opcode"],
-                msg["payload"],
-            )
-            await loop.run_in_executor(None, lambda: sock.sendall(packet))
-            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 (ssl.SSLEOFError, ssl.SSLError, ConnectionError) as conn_err:
-            self.logger.warning("Connection lost, reconnecting...")
-            self.is_connected = False
-            try:
-                await self.connect(self.user_agent)
-            except Exception as exc:
-                self.logger.exception("Reconnect failed")
-                raise exc from conn_err
-            raise SocketNotConnectedError from conn_err
-        except Exception as exc:
-            self.logger.exception("Send and wait failed (opcode=%s, seq=%s)", opcode, msg["seq"])
-            raise SocketSendError from exc
-
-        finally:
-            self._pending.pop(msg["seq"], 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/mixins/telemetry.py

@@ -1,112 +0,0 @@
-import asyncio
-import random
-import time
-
-from pymax.exceptions import Error
-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:
-                await self._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)