maxapi-python 2.3.1__py3-none-any.whl → 2.4.1__py3-none-any.whl

pymax/auth/sms.py

@@ -6,6 +6,7 @@ from pymax.auth.base import AuthFlow
 from pymax.exceptions import ApiError
 from pymax.logging import get_logger
 
+from .exceptions import PasswordAttemptsExceededError
 from .models import AuthResult
 from .providers import (
     ConsolePasswordProvider,
@@ -116,7 +117,10 @@ class SmsAuthFlow(AuthFlow):
         hint: str | None,
     ) -> str:
         logger.info("starting 2fa password authentication")
-        while True:
+        attempt = 0
+        while (
+            app.config.password_max_attempts is None or app.config.password_max_attempts > attempt
+        ):
             password = await self.password_provider.get_password(hint)
             logger.debug(
                 "2fa password provider returned password_set=%s",
@@ -124,16 +128,19 @@ class SmsAuthFlow(AuthFlow):
             )
             if not password:
                 logger.warning("2fa password is empty; retrying")
+                attempt += 1
                 continue
 
             try:
                 response = await app.api.auth.check_password(track_id, password)
             except ApiError as e:
                 logger.error("2fa password check failed: %s", e)
+                attempt += 1
                 continue
 
             if response.error:
                 logger.error("2fa password check failed error=%s", response.error)
+                attempt += 1
                 continue
 
             if response.login_token:
@@ -141,3 +148,6 @@ class SmsAuthFlow(AuthFlow):
                 return response.login_token
 
             logger.error("2fa password response did not contain login token; retrying")
+            attempt += 1
+
+        raise PasswordAttemptsExceededError

pymax/base.py

@@ -3,15 +3,16 @@ from __future__ import annotations
 import asyncio
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Generic, TypeVar
-from uuid import uuid4
 
 from pymax.dispatch import ErrorScope, Router
 from pymax.dispatch.router import DisconnectDecorator, ErrorDecorator
+from pymax.exceptions import ApiError
+from pymax.fingerprint.models import ApkBuildFingerprint
 from pymax.infra import BaseMixin
 from pymax.logging import get_logger
 
 from .app import App
-from .config import ClientConfig, DeviceConfig, ExtraConfig
+from .config import ClientConfig, DeviceConfig, ExtraConfig, generate_device_id
 
 if TYPE_CHECKING:
     from pymax.api.session.payloads import MobileUserAgentPayload
@@ -46,11 +47,21 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
     _connection: ConnectionManager
     _auth_flow: AuthFlow
     _router: Router[ClientT]
-    _app: App[ClientT]
+    __app: App[ClientT] | None = None
+
+    @property
+    def _app(self) -> App[ClientT]:
+        if self.__app is None:
+            raise RuntimeError("Client runtime is not initialized")
+        return self.__app
+
+    @_app.setter
+    def _app(self, value: App[ClientT]) -> None:
+        self.__app = value
 
     @property
     def me(self) -> Profile | None:
-        """Профиль текущего аккаунта после успешного ``start``."""
+        """Профиль текущего аккаунта после успешного login."""
         return self._app.me
 
     @property
@@ -68,11 +79,17 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
         """Сообщения, которые Max вернул на login/sync."""
         return self._app.messages
 
+    @property
+    def is_connected(self) -> bool:
+        return self.__app is not None and self.__app.connection.is_open
+
     def _build_config(
         self,
         *,
         phone: str | None,
         user_agent: MobileUserAgentPayload,
+        version: str | None,
+        fingerprint: ApkBuildFingerprint | None,
     ) -> ClientConfig:
         logger.debug(
             "building client config token_set=%s",
@@ -93,17 +110,38 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
             store=self.extra_config.store,
             proxy=self.extra_config.proxy,
             registration_config=self.extra_config.registration_config,
+            upload_timeout=self.extra_config.upload_timeout,
+            password_max_attempts=self.extra_config.password_max_attempts,
+            relogin=self.extra_config.relogin,
+            app_version=version,
+            fingering=fingerprint,
+            persist_session=self.extra_config.persist_session,
             device=DeviceConfig(
                 mt_instance_id=self.extra_config.mt_instance_id,
-                device_id=self.extra_config.device_id or str(uuid4()),
+                device_id=self.extra_config.device_id or generate_device_id(),
                 user_agent=user_agent,
             ),
         )
 
     @abstractmethod
     def _build_connection(self) -> ConnectionManager:
+
+        raise NotImplementedError
+
+    @abstractmethod
+    async def _prepare_config(self) -> ClientConfig:
         raise NotImplementedError
 
+    async def _ensure_runtime(self: ClientT) -> None:  # noqa: PYI019
+        if getattr(self, "_config", None) is None:
+            self._config = await self._prepare_config()
+
+        if self.__app is not None and self.__app.connection.is_open:
+            return
+
+        self._connection = self._build_connection()
+        self._app = self._build_app()
+
     def _init_runtime(self: ClientT, *, auth_flow: AuthFlow) -> None:  # noqa: PYI019
         self._connection = self._build_connection()
         self._auth_flow = auth_flow
@@ -124,10 +162,43 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
         self._connection = self._build_connection()
         self._app = self._build_app()
 
+    async def connect(self: ClientT) -> None:  # noqa: PYI019
+        """Подключает клиента один раз и возвращается после ``on_start``.
+
+        После возврата соединение остается открытым. В отличие от
+        :meth:`start`, метод не ожидает закрытия соединения и не запускает
+        reconnect loop; завершите работу через :meth:`stop` или :meth:`close`.
+        """
+        try:
+            await self._ensure_runtime()
+            await self._app.start()
+            if not self._app.started:
+                await self.close()
+                return
+
+            await self._app.dispatcher.emit_start(self)
+        except asyncio.CancelledError:
+            await self.close()
+            raise
+        except (ConnectionError, EOFError, OSError, TimeoutError, ApiError) as e:
+            await self.close()
+
+            await self._app.dispatcher.emit_disconnect(
+                e,
+                self.extra_config.reconnect,
+                self.extra_config.reconnect_delay,
+            )
+            raise
+
     async def start(self: ClientT) -> None:  # noqa: PYI019
-        """Запускает клиента и слушает события до закрытия соединения."""
+        """Запускает клиента и слушает события до закрытия соединения.
+
+        При сетевых ошибках повторяет подключение, если ``reconnect=True``.
+        Отозванный login token автоматически сбрасывается при ``relogin=True``.
+        """
         while True:
             try:
+                await self._ensure_runtime()
                 await self._app.start()
                 if not self._app.started:
                     await self.close()
@@ -138,7 +209,15 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
             except asyncio.CancelledError:
                 await self.close()
                 raise
-            except (  # noqa: PERF203
+            except ApiError as e:
+                if not self._app._is_invalid_login_token_error(e):
+                    await self.close()
+                    raise
+
+                logger.warning("login token was revoked; starting authentication again")
+                if self.extra_config.relogin:
+                    await self.relogin(start=False)
+            except (
                 ConnectionError,
                 EOFError,
                 OSError,
@@ -170,7 +249,10 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
 
     async def close(self) -> None:
         """Закрывает соединение, фоновые задачи и файл сессии."""
-        await self._app.close()
+        if self.__app is None:
+            return
+
+        await self.__app.close()
 
     async def stop(self) -> None:
         """Останавливает клиента."""

pymax/client.py

@@ -7,12 +7,15 @@ from pymax.auth import (
     SmsAuthFlow,
     SmsCodeProvider,
 )
+from pymax.config import ClientConfig
 from pymax.connection import ConnectionManager
 from pymax.connection.readers import TCPReader
+from pymax.dispatch import Router
 from pymax.logging import configure_logging, get_logger
 from pymax.protocol.tcp import TcpProtocol
 from pymax.protocol.tcp.framing import TcpPacketFramer
 from pymax.transport.tcp import TCPTransport
+from pymax.versions.catalog import VersionCatalog
 
 from .base import BaseClient
 from .config import ExtraConfig
@@ -37,6 +40,15 @@ class Client(BaseClient["Client"]):
         auth_flow: Полностью пользовательский сценарий авторизации.
         sms_code_provider: Провайдер SMS-кода для стандартного ``SmsAuthFlow``.
         password_provider: Провайдер пароля 2FA, если аккаунт его требует.
+        app_version: Версия Android-клиента для user-agent и fingerprint.
+            По умолчанию используется ``VersionCatalog.recommended()``.
+        catalog: Каталог fingerprints. Если не передан, используется
+            встроенный каталог. Каталог и версия разрешаются при
+            :meth:`connect` или :meth:`start`.
+
+    Raises:
+        VersionNotFoundError: При запуске, если ``app_version`` отсутствует в
+            итоговом каталоге.
     """
 
     def __init__(  # noqa: PLR0913
@@ -48,12 +60,16 @@ class Client(BaseClient["Client"]):
         auth_flow: AuthFlow | None = None,
         sms_code_provider: SmsCodeProvider | None = None,
         password_provider: PasswordProvider | None = None,
+        app_version: str = VersionCatalog.RECOMMENDED_APP_VERSION,
+        catalog: VersionCatalog | None = None,
     ) -> None:
 
-        self.phone = phone
-        self.extra_config = extra_config or ExtraConfig()
-        self.session_name = session_name
-        self.work_dir = work_dir
+        self.phone: str = phone
+        self.extra_config: ExtraConfig = extra_config or ExtraConfig()
+        self.session_name: str = session_name
+        self.work_dir: str = work_dir
+        self.app_version: str = app_version
+        self.catalog: VersionCatalog = catalog or VersionCatalog()
 
         configure_logging(self.extra_config.log_level)
         logger.debug(
@@ -65,17 +81,13 @@ class Client(BaseClient["Client"]):
             self.extra_config.reconnect,
         )
 
-        self._config = self._build_config(
-            phone=phone,
-            user_agent=(self.extra_config.user_agent or self.extra_config.generate_user_agent()),
-        )
-
         if auth_flow is None:
             auth_flow = SmsAuthFlow(
                 sms_code_provider or ConsoleSmsCodeProvider(),
                 password_provider,
             )
-        self._init_runtime(auth_flow=auth_flow)
+        self._auth_flow = auth_flow
+        self._router = Router()
 
         logger.debug(
             "client created transport=tcp host=%s port=%s",
@@ -83,6 +95,23 @@ class Client(BaseClient["Client"]):
             self.extra_config.port,
         )
 
+    async def _prepare_config(self) -> ClientConfig:
+        catalog = await self.catalog.load()
+        fingerprint = catalog.resolve(self.app_version)
+
+        user_agent = self.extra_config.user_agent or self.extra_config.generate_user_agent(
+            self.app_version, fingerprint.build_number
+        )
+
+        config = self._build_config(
+            phone=self.phone,
+            user_agent=user_agent,
+            version=self.app_version,
+            fingerprint=fingerprint,
+        )
+        config.restore_user_agent_from_session = self.extra_config.user_agent is None
+        return config
+
     def _build_connection(self) -> ConnectionManager:
         logger.debug(
             "building tcp connection host=%s port=%s ssl=%s",

pymax/client_web.py

@@ -5,12 +5,13 @@ from pymax.auth.providers import ConsoleQrHandler, QrHandler
 from pymax.auth.qr import QrAuthFlow
 from pymax.connection import ConnectionManager
 from pymax.connection.readers import WSReader
+from pymax.dispatch import Router
 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
-from .config import ExtraConfig
+from .config import ClientConfig, ExtraConfig
 
 logger = get_logger(__name__)
 
@@ -38,9 +39,9 @@ class WebClient(BaseClient["WebClient"]):
         auth_flow: AuthFlow | None = None,
         qr_provider: QrHandler | None = None,
     ) -> None:
-        self.extra_config = extra_config or ExtraConfig()
-        self.session_name = session_name
-        self.work_dir = work_dir
+        self.extra_config: ExtraConfig = extra_config or ExtraConfig()
+        self.session_name: str = session_name
+        self.work_dir: str = work_dir
 
         configure_logging(self.extra_config.log_level)
         logger.debug(
@@ -51,22 +52,24 @@ class WebClient(BaseClient["WebClient"]):
             self.extra_config.reconnect,
         )
 
-        self._config = self._build_config(
-            phone=None,
-            user_agent=(
-                self.extra_config.user_agent or self.extra_config.generate_web_user_agent()
-            ),
-        )
-
         if auth_flow is None:
             auth_flow = QrAuthFlow(qr_provider or ConsoleQrHandler())
-        self._init_runtime(auth_flow=auth_flow)
+        self._auth_flow = auth_flow
+        self._router = Router()
 
         logger.debug(
             "web client created transport=ws url=%s",
             self.extra_config.url,
         )
 
+    async def _prepare_config(self) -> ClientConfig:
+        user_agent = self.extra_config.user_agent or self.extra_config.generate_web_user_agent()
+        config = self._build_config(
+            phone=None, user_agent=user_agent, version=None, fingerprint=None
+        )
+        config.restore_user_agent_from_session = self.extra_config.user_agent is None
+        return config
+
     def _build_connection(self) -> ConnectionManager:
         logger.debug(
             "building websocket connection url=%s",
@@ -80,5 +83,5 @@ class WebClient(BaseClient["WebClient"]):
         return ConnectionManager(
             reader=reader,
             transport=transport,
-            protocol=WsProtocol(),
+            protocol=TcpProtocol(),
         )

pymax/config.py

@@ -1,5 +1,5 @@
+import secrets
 from random import choice, randint
-from uuid import uuid4
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -8,20 +8,53 @@ from pymax.api.session.payloads import (
     DEFAULT_WEB_HEADER_USER_AGENT,
     MobileUserAgentPayload,
 )
+from pymax.fingerprint.models import ApkBuildFingerprint
 from pymax.session import StoreProtocol
 from pymax.types.domain.sync import SyncOverrides
+from pymax.versions.catalog import VersionCatalog
 
+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.11.2", 6669),
-    ("26.11.1", 6665),
-    ("26.11.0", 6661),
+    ("26.12.0", 6676),
+    # ("26.11.3", 6670), # Not supported TODO: delete maybe
+    # ("26.11.2", 6669),
+    # ("26.11.1", 6665),
+    # ("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,14 +106,21 @@ LOCALE_TIMEZONES: tuple[tuple[str, str], ...] = (
     ("ru", "Asia/Yakutsk"),
     ("ru", "Asia/Vladivostok"),
 )
-WEB_APP_VERSION = "26.5.5"
+WEB_APP_VERSION = "26.8.4"
 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]
+
+
+def generate_device_id() -> str:
+    return secrets.token_hex(8)
+
 
 class DeviceConfig(BaseModel):
     mt_instance_id: str
     user_agent: MobileUserAgentPayload
-    device_id: str = Field(default_factory=lambda: str(uuid4()))
+    device_id: str = Field(default_factory=generate_device_id)
     client_session_id: int = Field(default_factory=lambda: randint(1, 70))
 
 
@@ -102,6 +142,9 @@ class RegistrationConfig(BaseModel):
 class ClientConfig(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
+    app_version: str | None = VersionCatalog.RECOMMENDED_APP_VERSION
+    fingering: ApkBuildFingerprint | None
+
     phone: str | None = None
     work_dir: str = "."
     session_name: str = "session.db"
@@ -109,16 +152,22 @@ class ClientConfig(BaseModel):
     token: str | None = None
     proxy: str | None = None
     registration_config: RegistrationConfig | None = None
-
-    host: str = "api.oneme.ru"
+    upload_timeout: int = 900
+    relogin: bool = True
+    host: str = "api2.oneme.ru"
     port: int = 443
     use_ssl: bool = True
+    persist_session: bool = True
 
+    password_max_attempts: int | None = None
     protocol_version: int = 10
     request_timeout: float = 30.0
     log_level: str = "INFO"
     telemetry: bool = False
 
+    interactive: bool = True
+    restore_user_agent_from_session: bool = True
+
     store: StoreProtocol | None = None
 
     sync: SyncOverrides = Field(default_factory=SyncOverrides)
@@ -145,13 +194,35 @@ class ExtraConfig(BaseModel):
         proxy: Proxy URL для TCP- или WebSocket-транспорта.
         reconnect: Переподключаться после сетевых ошибок.
         reconnect_delay: Пауза перед reconnect.
-        device_id: Явный device ID. Если не передан, генерируется UUID.
+        upload_timeout: Общий timeout HTTP-загрузки файлов, видео, голосовых и
+            видеосообщений в секундах. По умолчанию ``900``; не применяется к
+            фотографиям и 60-секундному ожиданию обработки вложения. ``0`` и
+            отрицательные значения отключают общий timeout, но не отдельный
+            60-секундный socket/read timeout.
+        relogin: Автоматически сбрасывать сессию и повторять авторизацию, если
+            Max отозвал login token. По умолчанию ``True``.
+        password_max_attempts: Максимальное число попыток ввода пароля 2FA.
+            ``None`` означает отсутствие лимита; ``0`` и отрицательные значения
+            сразу завершают авторизацию с ``PasswordAttemptsExceededError``.
+        persist_session: Сохранять token, device/user-agent и sync-state между
+            runtime в SQLite или переданном ``store``. По умолчанию ``True``.
+            При ``False`` используется отдельный ``InMemoryStore`` и значение
+            ``store`` игнорируется; после пересоздания runtime, в том числе при
+            reconnect, сохраненная сессия недоступна.
+        device_id: Явный device ID. Если не передан, генерируется строка из
+            16 шестнадцатеричных символов.
         device_type: Тип устройства для mobile user-agent.
-        user_agent: Полностью заданный user-agent payload.
-        mt_instance_id: Instance ID устройства.
+        user_agent: Полностью заданный user-agent payload. Явное значение имеет
+            приоритет над user-agent из сохраненной сессии. Автоматически
+            сгенерированный user-agent восстанавливает характеристики устройства
+            из сессии, сохраняя версию приложения и build number текущего запуска.
+        mt_instance_id: Instance ID устройства. По умолчанию генерируется
+            строка из 16 шестнадцатеричных символов.
         request_timeout: Timeout API-запросов в секундах.
         log_level: Уровень логов ``pymax``.
         telemetry: Отправлять telemetry-события Max.
+        store: Пользовательское хранилище сессии. Используется только при
+            ``persist_session=True``.
         sync: Переопределения sync-маркеров для login.
 
     Example:
@@ -174,18 +245,22 @@ class ExtraConfig(BaseModel):
     token: str | None = None
     registration_config: RegistrationConfig | None = None
 
-    host: str = "api.oneme.ru"
+    host: str = "api2.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
     reconnect_delay: float = 1.0
+    upload_timeout: int = 900
+    relogin: bool = True
+    password_max_attempts: int | None = None
+    persist_session: bool = True
 
     device_id: str | None = None
     device_type: DeviceType = DeviceType.ANDROID
     user_agent: MobileUserAgentPayload | None = None
-    mt_instance_id: str = Field(default_factory=lambda: str(uuid4()))
+    mt_instance_id: str = Field(default_factory=generate_device_id)
 
     request_timeout: float = 30.0
     log_level: str = "INFO"
@@ -195,13 +270,17 @@ class ExtraConfig(BaseModel):
 
     sync: SyncOverrides = Field(default_factory=SyncOverrides)
 
-    def generate_user_agent(self) -> MobileUserAgentPayload:
+    def generate_user_agent(self, app_version: str, build_number: int) -> MobileUserAgentPayload:
         """Создает mobile user-agent payload для TCP-клиента.
 
+        Args:
+            app_version: Версия Android-клиента Max.
+            build_number: Build number той же версии из ``VersionCatalog``.
+
         Returns:
-            Случайная, но правдоподобная конфигурация Android-клиента Max.
+            Случайная конфигурация Android-устройства с переданными версией и
+            build number.
         """
-        app_version, build_number = choice(APP_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"