maxapi-python 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

pymax/client_web.py

@@ -6,7 +6,7 @@ from pymax.auth.qr import QrAuthFlow
 from pymax.connection import ConnectionManager
 from pymax.connection.readers import WSReader
 from pymax.logging import configure_logging, get_logger
-from pymax.protocol.ws import WsProtocol
+from pymax.protocol.tcp import TcpProtocol
 from pymax.transport.websocket import WebSocketTransport
 
 from .base import BaseClient
@@ -80,5 +80,5 @@ class WebClient(BaseClient["WebClient"]):
         return ConnectionManager(
             reader=reader,
             transport=transport,
-            protocol=WsProtocol(),
+            protocol=TcpProtocol(),
         )

pymax/config.py

@@ -1,4 +1,4 @@
-from random import choice, randint
+from random import choice, randint, random
 from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -11,17 +11,48 @@ from pymax.api.session.payloads import (
 from pymax.session import StoreProtocol
 from pymax.types.domain.sync import SyncOverrides
 
+MIN_PREFERRED_BUILD = 6712
 APP_VERSIONS: tuple[tuple[str, int], ...] = (
+    ("26.25.0", 6790),
+    ("26.24.0", 6784),
+    ("26.23.2", 6779),
+    ("26.23.1", 6778),
+    ("26.23.0", 6777),
+    ("26.22.2", 6773),
+    ("26.22.1", 6772),
+    ("26.22.0", 6770),
+    ("26.21.1", 6763),
+    ("26.20.2", 6758),
+    ("26.20.1", 6740),
+    ("26.19.3", 6734),
+    ("26.19.2", 6732),
+    ("26.19.1", 6729),
+    ("26.19.0", 6727),
+    ("26.18.4", 6724),
+    ("26.18.2", 6720),
+    ("26.18.1", 6716),
+    ("26.18.0", 6715),
+    ("26.17.1", 6712),
+    ("26.16.4", 6704),
+    ("26.16.3", 6702),
+    ("26.16.2", 6701),
+    ("26.16.1", 6700),
+    ("26.16.0", 6698),
+    ("26.15.3", 6695),
+    ("26.15.1", 6690),
+    ("26.15.0", 6689),
     ("26.14.1", 6686),
     ("26.14.0", 6685),
     ("26.13.0", 6683),
     ("26.12.2", 6681),
     ("26.12.1", 6679),
-    ("26.12.0", 6678),
-    ("26.11.3", 6680),
+    ("26.12.0", 6676),
+    ("26.11.3", 6670),
     ("26.11.2", 6669),
     ("26.11.1", 6665),
-    ("26.11.0", 6661),
+    ("26.10.1", 6653),
+    ("26.10.0", 6648),
+    ("26.9.1", 6643),
 )
 ANDROID_DEVICES: tuple[tuple[str, str, str, str], ...] = (
     ("Samsung SM-A525F", "Android 13", "405dpi 405dpi 1080x2400", "arm64-v8a"),
@@ -73,9 +104,12 @@ LOCALE_TIMEZONES: tuple[tuple[str, str], ...] = (
     ("ru", "Asia/Yakutsk"),
     ("ru", "Asia/Vladivostok"),
 )
-WEB_APP_VERSION = "26.5.5"
+WEB_APP_VERSION = "26.7.15"
 WEB_SCREEN = "1080x1920 1.0x"
 
+PREFERRED_VERSION = [version for version in APP_VERSIONS if version[1] >= MIN_PREFERRED_BUILD]
+LEGACY_VERSIONS = [version for version in APP_VERSIONS if version[1] < MIN_PREFERRED_BUILD]
+
 
 class DeviceConfig(BaseModel):
     mt_instance_id: str
@@ -119,6 +153,8 @@ class ClientConfig(BaseModel):
     log_level: str = "INFO"
     telemetry: bool = False
 
+    interactive: bool = True
+
     store: StoreProtocol | None = None
 
     sync: SyncOverrides = Field(default_factory=SyncOverrides)
@@ -176,7 +212,7 @@ class ExtraConfig(BaseModel):
 
     host: str = "api.oneme.ru"
     port: int = 443
-    url: str = "wss://ws-api.oneme.ru/websocket"
+    url: str = "wss://api.oneme.ru/websocket"
     use_ssl: bool = True
     proxy: str | None = None
     reconnect: bool = True
@@ -201,7 +237,8 @@ class ExtraConfig(BaseModel):
         Returns:
             Случайная, но правдоподобная конфигурация Android-клиента Max.
         """
-        app_version, build_number = choice(APP_VERSIONS)
+        versions = PREFERRED_VERSION if random() < 0.9 else LEGACY_VERSIONS
+        app_version, build_number = choice(versions)
         device_name, os_version, screen, arch = choice(ANDROID_DEVICES)
         locale, timezone = choice(LOCALE_TIMEZONES)
 

pymax/connection/connection.py

@@ -37,6 +37,8 @@ class ConnectionManager:
 
         self._recv_task: asyncio.Task[None] | None = None
         self._event_tasks: set[asyncio.Task[None]] = set()
+        self._closed_event = asyncio.Event()
+        self._closed_event.set()
 
     async def open(self) -> None:
         if self._is_open:
@@ -48,6 +50,7 @@ class ConnectionManager:
         self._is_open = True
         self._connection_lost = False
         self._close_reported = False
+        self._closed_event.clear()
 
         self._recv_task = asyncio.create_task(self._recv_loop())
         logger.debug("receive loop started")
@@ -58,25 +61,28 @@ class ConnectionManager:
             return
 
         logger.info("closing connection")
-        if self._recv_task:
-            if not self._recv_task.done():
-                self._recv_task.cancel()
-            with suppress(asyncio.CancelledError, Exception):
-                await self._recv_task
-            logger.debug("receive loop stopped")
-            self._recv_task = None
-
-        for task in tuple(self._event_tasks):
-            if not task.done():
-                task.cancel()
-        for task in tuple(self._event_tasks):
-            with suppress(asyncio.CancelledError, Exception):
-                await task
-        self._event_tasks.clear()
-
-        self.requests.cancel_all()
-        await self.transport.close()
         self._is_open = False
+        try:
+            if self._recv_task:
+                if not self._recv_task.done():
+                    self._recv_task.cancel()
+                with suppress(asyncio.CancelledError, Exception):
+                    await self._recv_task
+                logger.debug("receive loop stopped")
+                self._recv_task = None
+
+            for task in tuple(self._event_tasks):
+                if not task.done():
+                    task.cancel()
+            for task in tuple(self._event_tasks):
+                with suppress(asyncio.CancelledError, Exception):
+                    await task
+            self._event_tasks.clear()
+
+            self.requests.cancel_all()
+            await self.transport.close()
+        finally:
+            self._closed_event.set()
         logger.info("connection closed")
 
     async def fail(self, exc: Exception | None = None) -> None:
@@ -147,6 +153,11 @@ class ConnectionManager:
 
         try:
             await self._recv_task
+        except asyncio.CancelledError:
+            if self._is_open:
+                raise
+            await self._closed_event.wait()
+            return
         except Exception as e:
             if self._connection_lost:
                 raise ConnectionError("Connection lost") from e

pymax/dispatch/enums.py

@@ -13,5 +13,6 @@ class EventType(str, Enum):
     USER_UPDATE = "user_update"
     VIDEO_READY = "video_ready"
     FILE_READY = "file_ready"
+    VOICE_READY = "voice_ready"
     RAW = "raw"
     ON_START = "on_start"

pymax/dispatch/mapping.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 from pymax.api.binding import bind_api_model
 from pymax.protocol import InboundFrame, Opcode
 from pymax.protocol.enums import Command
-from pymax.types import Chat, MessageDeleteEvent
+from pymax.types import AudioUploadSignal, Chat, MessageDeleteEvent
 from pymax.types.domain import Message
 from pymax.types.events import (
     FileUploadSignal,
@@ -100,4 +100,6 @@ class EventMapper:
                 return VideoUploadSignal.model_validate(frame.payload)
             elif event_type == EventType.FILE_READY:
                 return FileUploadSignal.model_validate(frame.payload)
+            elif event_type == EventType.VOICE_READY:
+                return AudioUploadSignal.model_validate(frame.payload)
         return frame

pymax/dispatch/resolvers.py

@@ -3,7 +3,7 @@ from pydantic import ValidationError
 from pymax.logging import get_logger
 from pymax.protocol import InboundFrame
 from pymax.protocol.enums import Opcode
-from pymax.types import Message
+from pymax.types import AudioUploadSignal, Message
 from pymax.types.domain.enums import MessageStatus
 from pymax.types.events import FileUploadSignal, VideoUploadSignal
 
@@ -49,6 +49,12 @@ def resolve_attach(frame: InboundFrame) -> EventType | None:
     except ValidationError:
         logger.debug("attach event is not a video upload signal")
 
+    try:
+        AudioUploadSignal.model_validate(frame.payload)
+        return EventType.VOICE_READY
+    except ValidationError:
+        logger.debug("attach event is not a voice upload signal")
+
     return None
 
 

pymax/files/__init__.py

@@ -1,9 +1,12 @@
 from .file import File
 from .photo import Photo
-from .video import Video
+from .video import Video, VideoNote
+from .voice import Voice
 
 __all__ = (
     "File",
     "Photo",
     "Video",
+    "VideoNote",
+    "Voice",
 )

pymax/files/video.py

@@ -1,8 +1,14 @@
 from collections.abc import AsyncGenerator
+from io import BytesIO
 from pathlib import Path
 
 from .base import BaseFile
 
+try:
+    from tinytag import TinyTag
+except ImportError:
+    TinyTag = None
+
 
 class Video(BaseFile):
     """Видео для отправки в сообщение.
@@ -72,3 +78,55 @@ class Video(BaseFile):
             Async generator с байтами.
         """
         return super().iter_chunks(size)
+
+
+class VideoNote(Video):
+    """Круглое видеосообщение для отправки.
+
+    Принимает те же источники, что и ``Video``. Длительность задается в
+    миллисекундах. Если она не передана, требуется extra ``video`` для
+    автоматического определения длительности.
+    """
+
+    def __init__(
+        self,
+        raw: bytes | None = None,
+        *,
+        url: str | None = None,
+        path: str | None = None,
+        name: str | None = None,
+        duration: int | None = None,
+    ) -> None:
+        self.duration = duration
+        super().__init__(raw, url=url, path=path, name=name)
+
+    async def get_duration(self) -> int:
+        if self.duration is not None:
+            return self.duration
+
+        if not TinyTag:
+            raise RuntimeError(
+                "Automatic video duration detection requires the 'video' extra. "
+                "Install it with `uv add 'maxapi-python[video]'` "
+                "or pass duration manually."
+            )
+
+        if self.raw:
+            tag = TinyTag.get(
+                filename=self.name,
+                file_obj=BytesIO(self.raw),
+                tags=False,
+                duration=True,
+            )
+        else:
+            tag = TinyTag.get(
+                filename=self.name,
+                file_obj=BytesIO(await self.read()),
+                tags=False,
+                duration=True,
+            )
+
+        if tag.duration is None:
+            raise ValueError("Failed to determine video duration.")
+
+        return round(tag.duration * 1000)

pymax/files/voice.py

@@ -0,0 +1,39 @@
+from collections.abc import AsyncGenerator
+from pathlib import Path
+
+from .base import BaseFile
+
+
+class Voice(BaseFile):
+    """Голосовое сообщение в формате OGG для отправки.
+
+    Принимает ``path``, ``url`` или ``raw``. Для ``raw`` необходимо явно
+    передать имя файла.
+    """
+
+    def __init__(
+        self,
+        raw: bytes | None = None,
+        *,
+        path: str | None = None,
+        url: str | None = None,
+        name: str | None = None,
+    ) -> None:
+        self.name: str = name or ""
+        if not self.name and path:
+            self.name = Path(path).name
+        elif not self.name and url:
+            self.name = Path(url).name
+
+        if not self.name:
+            raise ValueError("Either name, url or path must be provided.")
+        super().__init__(raw=raw, url=url, path=path, name=self.name)
+
+    async def read(self) -> bytes:
+        return await super().read()
+
+    async def size(self) -> int:
+        return await super().size()
+
+    def iter_chunks(self, size: int) -> AsyncGenerator[bytes, None]:
+        return super().iter_chunks(size)

pymax/fingerprint/__init__.py

@@ -0,0 +1 @@
+from .fingerprint import FingerprintGenerator

pymax/fingerprint/fingerprint.py

@@ -0,0 +1,47 @@
+import hashlib
+import json
+import struct
+from importlib import resources
+from typing import Any
+
+from .models import ApkBuildFingerprint
+
+
+class FingerprintGenerator:
+    def __init__(
+        self,
+    ) -> None:
+        self.path = resources.files("pymax._data") / "apk_fingerprints.json"
+        self.data = self.load_fingerprints()
+
+    def load_fingerprints(self) -> Any:
+        with self.path.open("r", encoding="utf-8") as f:
+            return json.load(f)
+
+    def generate_fingerprint(
+        self,
+        version: str,
+        device_id: str,
+        calls_seed: int,
+        arch: str = "arm64-v8a",
+    ) -> bytes | None:
+        data = self.data.get(version)
+        if not data:
+            return None
+
+        model = ApkBuildFingerprint.model_validate(data)
+
+        seed_bytes = struct.pack(">q", calls_seed)
+        device_bytes = device_id.encode("utf-8")
+
+        h1 = hashlib.sha256(
+            bytes.fromhex(model.certificate_meta_sha256) + seed_bytes + device_bytes
+        ).digest()
+        h2 = hashlib.sha256(
+            bytes.fromhex(model.dex_meta_sha256) + seed_bytes + device_bytes
+        ).digest()
+        h3 = hashlib.sha256(
+            bytes.fromhex(model.so_meta_sha256[arch]) + seed_bytes + device_bytes
+        ).digest()
+
+        return h1 + h2 + h3

pymax/fingerprint/models.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+
+
+class ApkBuildFingerprint(BaseModel):
+    signature_scheme: str
+    certificate_count: int
+    certificate_meta_sha256: str
+    certificate_sha256: list[str]
+    dex_meta_sha256: str
+    so_meta_sha256: dict[str, str]
+    build_number: int

pymax/infra/auth.py

@@ -95,3 +95,7 @@ class AuthMixin(IClientProtocol):
         """
 
         return await self._app.api.auth.check_2fa()
+
+    def is_update_available(self) -> bool:
+        """Возвращает признак доступного обновления приложения по handshake."""
+        return self._app.api.auth.is_update_available()

pymax/infra/bots.py

@@ -9,14 +9,14 @@ class BotsMixin(IClientProtocol):
     async def get_bot_init_data(
         self,
         bot_id: int,
-        chat_id: int,
+        chat_id: int | None = None,
         start_param: str | None = None,
     ) -> InitData:
-        """Получает начальные данные для бота в контексте конкретного чата.
+        """Получает начальные данные для запуска бота.
 
         Args:
             bot_id: Идентификатор бота.
-            chat_id: Идентификатор чата, в котором бот будет использоваться.
+            chat_id: Необязательный ID чата, в котором бот будет использоваться.
             start_param: Необязательный параметр, передаваемый при запуске
                 бота.
 

pymax/infra/chat.py

@@ -1,3 +1,4 @@
+from pymax.api.chats import ChannelPermissions
 from pymax.types import Chat, Member, Message
 
 from .protocol import IClientProtocol
@@ -211,6 +212,28 @@ class ChatMixin(IClientProtocol):
         """
         return await self._app.api.chats.get_chat(chat_id)
 
+    async def get_chat_members(
+        self,
+        chat_id: int,
+        marker: int | None = None,
+        count: int = 50,
+    ) -> tuple[list[Member], int]:
+        """Возвращает страницу участников чата по ID.
+
+        Args:
+            chat_id: ID чата.
+            marker: Маркер страницы. Если ``None``, запрашивается первая
+                страница.
+            count: Максимальное количество участников в ответе.
+
+        Returns:
+            ``(members, next_marker)``. Если участников больше, чем
+            уместилось в ответ, ``next_marker`` ненулевой — передайте его в
+            следующий вызов, чтобы получить следующую страницу. ``0``
+            означает, что дальше страниц нет.
+        """
+        return await self._app.api.chats.get_chat_members(chat_id, marker, count)
+
     async def leave_group(self, chat_id: int) -> None:
         """Выходит из группы.
 
@@ -372,3 +395,18 @@ class ChatMixin(IClientProtocol):
             Канал, в который вступил клиент.
         """
         return await self._app.api.chats.join_channel(link=link)
+
+    async def add_admin(
+        self,
+        chat_id: int,
+        user_id: int,
+        permissions: list[ChannelPermissions],
+    ) -> None:
+        """Назначает пользователя администратором канала.
+
+        Args:
+            chat_id: ID канала.
+            user_id: ID пользователя.
+            permissions: Непустой список прав администратора.
+        """
+        return await self._app.api.chats.add_admin(chat_id, user_id, permissions)

pymax/infra/message.py

@@ -3,6 +3,7 @@ from pymax.api.messages.service import SendAttachments
 from pymax.types import (
     FileRequest,
     Message,
+    PollState,
     ReactionInfo,
     ReadState,
     VideoRequest,
@@ -17,23 +18,26 @@ class MessageMixin(IClientProtocol):
     async def send_message(
         self,
         chat_id: int,
-        text: str,
+        text: str | None = None,
         reply_to: int | None = None,
         attachments: SendAttachments = None,
         *,
         notify: bool = True,
-    ) -> Message | None:
+    ) -> Message:
         """Отправляет сообщение в чат.
 
         Args:
             chat_id: ID чата.
-            text: Текст сообщения.
+            text: Текст сообщения. Можно не передавать при наличии вложений.
             reply_to: ID сообщения для ответа.
-            attachments: Файлы, фотографии или видео для отправки.
+            attachments: Файлы, фотографии, видео или опросы для отправки.
             notify: Отправить ли получателям push-уведомление.
 
         Returns:
-            Отправленное сообщение или ``None``, если сервер не вернул его.
+            Отправленное сообщение.
+
+        Raises:
+            ValueError: Если не переданы ни текст, ни вложения.
         """
         return await self._app.api.messages.send_message(
             chat_id,
@@ -62,6 +66,33 @@ class MessageMixin(IClientProtocol):
             message_id=message_id,
         )
 
+    async def forward_message(
+        self,
+        chat_id: int,
+        message_id: int | str,
+        source_chat_id: int | None = None,
+        *,
+        notify: bool = True,
+    ) -> Message:
+        """Пересылает существующее сообщение в чат.
+
+        Args:
+            chat_id: ID целевого чата.
+            message_id: ID пересылаемого сообщения.
+            source_chat_id: ID исходного чата. Если не указан, используется
+                целевой чат.
+            notify: Отправить ли получателям push-уведомление.
+
+        Returns:
+            Пересланное сообщение.
+        """
+        return await self._app.api.messages.forward_message(
+            chat_id=chat_id,
+            message_id=message_id,
+            source_chat_id=source_chat_id,
+            notify=notify,
+        )
+
     async def get_messages(
         self,
         chat_id: int,
@@ -85,7 +116,7 @@ class MessageMixin(IClientProtocol):
         self,
         chat_id: int,
         message_id: int,
-        text: str,
+        text: str | None = None,
         attachments: SendAttachments = None,
     ) -> Message:
         """Редактирует текст и вложения сообщения.
@@ -94,7 +125,7 @@ class MessageMixin(IClientProtocol):
             chat_id: ID чата.
             message_id: ID сообщения.
             text: Новый текст сообщения с поддержкой markdown.
-            attachments: Новые файлы, фотографии или видео для сообщения.
+            attachments: Новые файлы, фотографии, видео или опросы для сообщения.
 
         Returns:
             Отредактированное сообщение.
@@ -118,7 +149,7 @@ class MessageMixin(IClientProtocol):
         get_chat: bool = False,
         get_messages: bool = True,
         interactive: bool = False,
-    ) -> list[Message] | None:
+    ) -> list[Message]:
         """Загружает историю сообщений чата.
 
         Args:
@@ -135,7 +166,7 @@ class MessageMixin(IClientProtocol):
             interactive: Пометить запрос как интерактивный.
 
         Returns:
-            Сообщения или ``None``, если сервер не вернул список.
+            Список сообщений. Если сервер не вернул сообщения, список пуст.
         """
         return await self._app.api.messages.fetch_history(
             chat_id=chat_id,
@@ -317,3 +348,28 @@ class MessageMixin(IClientProtocol):
             message_id=message_id,
             chat_id=chat_id,
         )
+
+    async def vote_poll(
+        self,
+        chat_id: int,
+        message_id: int,
+        poll_id: int,
+        answer_ids: list[int],
+    ) -> PollState:
+        """Отправляет выбранные ответы в опросе.
+
+        Args:
+            chat_id: ID чата с опросом.
+            message_id: ID сообщения с опросом.
+            poll_id: ID опроса из ``PollAttachment.poll_id``.
+            answer_ids: ID выбранных вариантов ответа.
+
+        Returns:
+            Обновленное состояние опроса.
+        """
+        return await self._app.api.messages.vote_poll(
+            chat_id=chat_id,
+            message_id=message_id,
+            poll_id=poll_id,
+            answer_ids=answer_ids,
+        )