maxapi-python 1.1.16__py3-none-any.whl → 1.1.18__py3-none-any.whl

{maxapi_python-1.1.16.dist-info → maxapi_python-1.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.16
+Version: 1.1.18
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/ink-developer/PyMax
 Project-URL: Repository, https://github.com/ink-developer/PyMax

{maxapi_python-1.1.16.dist-info → maxapi_python-1.1.18.dist-info}/RECORD

@@ -1,16 +1,16 @@
-pymax/__init__.py,sha256=vsdE56xHZnvDCXqLwSJL3v9MxsXcmmxE9p0QSHG66HA,1846
-pymax/core.py,sha256=EKgMlOnqvsPJwOQeCgQE1tnKk4E8kMnmxCAfo4jrP_k,11083
+pymax/__init__.py,sha256=6wUKKwsyxFpWG3b7kwptOvHd-w78C-ygw42iCDBYQvc,1915
+pymax/core.py,sha256=Ee5R9GfhjDhSjAd2skKsG7Sp5h7AkvN0gtEWXWL7wVE,14189
 pymax/crud.py,sha256=wmJh8MPi3L_HbYp7MJP0eXfDcnjgfkLDa9rHAmXtkow,3219
 pymax/exceptions.py,sha256=nDUNx7bM-Yjugj-qfIllcrnwLg9JpZroYqfXapjYbMQ,3178
 pymax/files.py,sha256=dRuOpvoJZWiH4xa_HVGyqQ-_Zzj-sVikElHmrPjwgs0,3166
 pymax/filters.py,sha256=4hehzyQlyxBxLiEhtSH_KQdFHx8gYaqyIOOD72EsSS0,1536
 pymax/formatter.py,sha256=OVsTwambHhXlOMd0wVECJWuB_S2wSEVKdMLCzgPcvYQ,859
 pymax/formatting.py,sha256=hhtmakfcQDzQRsAckPunnJOCKY2lFdLeIp8Yw53yY8s,2522
-pymax/interfaces.py,sha256=NspCm8asUhG_LHo-CTseGMg-zKAHU5H4bl6BMEwqAK0,3416
+pymax/interfaces.py,sha256=WWKNGT725GXuYneS9gCOAC6RNtySRs-BTU0fQLyh2OQ,3399
 pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
 pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
-pymax/payloads.py,sha256=qaafULDGBXsQ7gNFC374wZVUwN5tzJLHwkxtAmglOzU,6292
-pymax/types.py,sha256=tiSU_YpvOlx710SYQbYLNw_SjwefgqOu9Xk5ev_PbFU,30931
+pymax/payloads.py,sha256=S1dJwDPanFfIdY_NlXN2epVyibmmL9bceltgLVmEtTA,6304
+pymax/types.py,sha256=RaLn9bUpkxO0SKbDMIHnoFeqV6gqOl2pKDNCa2LxTRI,32102
 pymax/mixins/__init__.py,sha256=xvjcq-lFVHCPss_t8xxXya0OJnsh-owlBqtUlrXSCcw,695
 pymax/mixins/auth.py,sha256=H4Zp3n8cwpv4Q3Mn1_Kb7Oh9DbTL7T9GcWJ6R1JN7ls,6672
 pymax/mixins/channel.py,sha256=dMuJRnbqZisN8kcPFCCe1sIOOBQl2uT4P49PpZXcoKE,5206
@@ -22,10 +22,10 @@ pymax/mixins/socket.py,sha256=j6XTo_M3rNw-az2PfSW6oJ_YHg9M7cWARY4cXpMllDY,22256
 pymax/mixins/telemetry.py,sha256=LWr68DNQkPhAjGRDYQ5lORXxC3Yw6M9E8sF0TCNISTE,3609
 pymax/mixins/user.py,sha256=5utoK7Z-7lySOg0PEO69b6h_3kjfcnV-YydTZIdNj8g,7120
 pymax/mixins/utils.py,sha256=s3FUf3i_wjn2Gbg5YY1rWZB-90ZEGrrcUuND_MqqSTE,853
-pymax/mixins/websocket.py,sha256=gqGP-3XPrbo4DPqUL4H8tuOAjZQ4QKbBvJGxOFqwk9E,17254
+pymax/mixins/websocket.py,sha256=LaL-okzhJCyS3uWV7xsCCKnuff_rooKjAoZ8vkaintY,16817
 pymax/static/constant.py,sha256=Q1NrmaRj17Gdhk3FmUp3HIwrad1TDorq3wFdQlOCzN8,1027
-pymax/static/enum.py,sha256=ofqxOsRzi6XvZN_UOPinxug1uPEulJsQ95MWifAfCqA,4562
-maxapi_python-1.1.16.dist-info/METADATA,sha256=OLNhs5zuW9ux6C_57MVhTscaZknfVXh90OYf5P2_X8A,6245
-maxapi_python-1.1.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-maxapi_python-1.1.16.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
-maxapi_python-1.1.16.dist-info/RECORD,,
+pymax/static/enum.py,sha256=c_QaLU0Ephe4SuKFIpwpmrf_HCutc34JJ6o4Ik1E6_g,4582
+maxapi_python-1.1.18.dist-info/METADATA,sha256=XJlvDWCpM0QCT1HgbNgevis67UmNW8dp91ED3s9J2Wg,6245
+maxapi_python-1.1.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+maxapi_python-1.1.18.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
+maxapi_python-1.1.18.dist-info/RECORD,,

pymax/__init__.py

@@ -15,6 +15,10 @@ from .exceptions import (
     SocketSendError,
     WebSocketNotConnectedError,
 )
+from .files import (
+    File,
+    Photo,
+)
 from .static.enum import (
     AccessType,
     AttachType,
@@ -61,47 +65,49 @@ __all__ = [
     "AccessType",
     "AttachType",
     "AuthType",
-    "ContactAction",
-    "FormattingType",
-    "MarkupType",
     # Типы данных
     "Channel",
     "Chat",
     "ChatType",
     "Contact",
+    "ContactAction",
     "ControlAttach",
     "DeviceType",
     "Dialog",
     "Element",
     "ElementType",
+    "File",
     "FileAttach",
     "FileRequest",
+    "FormattingType",
+    # Исключения
+    "InvalidPhoneError",
+    "LoginError",
+    "MarkupType",
+    # Клиент
+    "MaxClient",
     "Me",
     "Member",
+    "Message",
     "MessageLink",
+    "MessageStatus",
+    "MessageType",
     "Name",
     "Names",
+    "Opcode",
+    "Photo",
     "PhotoAttach",
     "Presence",
     "ReactionCounter",
     "ReactionInfo",
-    "Session",
-    "VideoAttach",
-    "VideoRequest",
-    # Исключения
-    "InvalidPhoneError",
-    "LoginError",
-    "WebSocketNotConnectedError",
     "ResponseError",
     "ResponseStructureError",
+    "Session",
+    "SocketMaxClient",
     "SocketNotConnectedError",
     "SocketSendError",
-    # Клиент
-    "MaxClient",
-    "Message",
-    "MessageStatus",
-    "MessageType",
-    "Opcode",
-    "SocketMaxClient",
     "User",
+    "VideoAttach",
+    "VideoRequest",
+    "WebSocketNotConnectedError",
 ]

pymax/core.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import logging
 import socket
 import ssl
@@ -6,12 +7,12 @@ import time
 import traceback
 from collections.abc import Awaitable
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any, Literal, Self
 
 from typing_extensions import override
 
 from .crud import Database
-from .exceptions import InvalidPhoneError
+from .exceptions import InvalidPhoneError, WebSocketNotConnectedError
 from .formatter import ColoredFormatter
 from .mixins import ApiMixin, SocketMixin, WebSocketMixin
 from .payloads import UserAgentPayload
@@ -56,6 +57,8 @@ class MaxClient(ApiMixin, WebSocketMixin):
         send_fake_telemetry (bool, optional): Флаг отправки фейковой телеметрии. По умолчанию True.
         proxy (str | Literal[True] | None, optional): Прокси для подключения к WebSocket.
             (См. https://websockets.readthedocs.io/en/stable/topics/proxies.html).
+        reconnect (bool, optional): Флаг автоматического переподключения при потере соединения. По умолчанию True.
+
 
     Raises:
         InvalidPhoneError: Если формат номера телефона неверный.
@@ -76,6 +79,8 @@ class MaxClient(ApiMixin, WebSocketMixin):
         first_name: str = "",
         last_name: str | None = None,
         logger: logging.Logger | None = None,
+        reconnect: bool = True,
+        reconnect_delay: float = 1.0,
     ) -> None:
         self.logger = logger or logging.getLogger(f"{__name__}")
         self.uri: str = uri
@@ -88,6 +93,8 @@ class MaxClient(ApiMixin, WebSocketMixin):
         self.first_name: str = first_name
         self.last_name: str | None = last_name
         self.proxy: str | Literal[True] | None = proxy
+        self.reconnect: bool = reconnect
+        self.reconnect_delay: float = reconnect_delay
 
         self.is_connected: bool = False
 
@@ -205,14 +212,17 @@ class MaxClient(ApiMixin, WebSocketMixin):
         except Exception:
             self.logger.exception("Error closing client")
 
-    def _create_safe_task(self, coro: Awaitable[Any], *, name: str | None = None):
+    @override
+    def _create_safe_task(
+        self, coro: Awaitable[Any], *, name: str | None = None
+    ) -> asyncio.Task[Any | None]:
         async def runner():
             try:
                 return await coro
             except asyncio.CancelledError:
                 raise
             except Exception as e:
-                self.logger.error(
+                self.logger.exception(
                     f"Unhandled exception in task {name or coro}: {e}",
                     exc_info=e,
                 )
@@ -226,40 +236,110 @@ class MaxClient(ApiMixin, WebSocketMixin):
         """
         Запускает клиент, подключается к WebSocket, авторизует
         пользователя (если нужно) и запускает фоновый цикл.
+        Теперь включает безопасный reconnect-loop, если self.reconnect=True.
         """
-        try:
-            self.logger.info("Client starting")
-            await self._connect(self.user_agent)
-
-            if self.registration:
-                if not self.first_name:
-                    raise ValueError("First name is required for registration")
-                await self._register(self.first_name, self.last_name)
-
-            if self._token and self._database.get_auth_token() is None:
-                self._database.update_auth_token(self._device_id, self._token)
-
-            if self._token is None:
-                await self._login()
-            else:
-                await self._sync()
-
-            if self._on_start_handler:
-                self.logger.debug("Calling on_start handler")
-                result = self._on_start_handler()
-                if asyncio.iscoroutine(result):
-                    await self._safe_execute(result, context="on_start handler")
-
-            ping_task = asyncio.create_task(self._send_interactive_ping())
-            ping_task.add_done_callback(self._log_task_exception)
-            self._background_tasks.add(ping_task)
-            if self._send_fake_telemetry:
-                telemetry_task = asyncio.create_task(self._start())
-                telemetry_task.add_done_callback(self._log_task_exception)
-                self._background_tasks.add(telemetry_task)
-            await self._wait_forever()
-        except Exception:
-            self.logger.exception("Client start failed")
+
+        while True:
+            try:
+                self.logger.info("Client starting")
+                await self._connect(self.user_agent)
+
+                if self.registration:
+                    if not self.first_name:
+                        raise ValueError("First name is required for registration")
+                    await self._register(self.first_name, self.last_name)
+
+                if self._token and self._database.get_auth_token() is None:
+                    self._database.update_auth_token(self._device_id, self._token)
+
+                if self._token is None:
+                    await self._login()
+                else:
+                    await self._sync()
+
+                if self._on_start_handler:
+                    self.logger.debug("Calling on_start handler")
+                    result = self._on_start_handler()
+                    if asyncio.iscoroutine(result):
+                        await self._safe_execute(result, context="on_start handler")
+
+                ping_task = asyncio.create_task(self._send_interactive_ping())
+                ping_task.add_done_callback(self._log_task_exception)
+                self._background_tasks.add(ping_task)
+
+                if self._send_fake_telemetry:
+                    telemetry_task = asyncio.create_task(self._start())
+                    telemetry_task.add_done_callback(self._log_task_exception)
+                    self._background_tasks.add(telemetry_task)
+
+                await self._wait_forever()
+                self.logger.info("WebSocket closed (wait_forever exited)")
+
+            except Exception:
+                self.logger.exception("Client start iteration failed")
+
+            finally:
+                self.logger.debug("Cleaning up background tasks and pending futures")
+
+                for task in list(self._background_tasks):
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        pass
+                    except Exception:
+                        self.logger.debug(
+                            "Background task raised during cancellation", exc_info=True
+                        )
+                    self._background_tasks.discard(task)
+
+                if self._recv_task:
+                    self._recv_task.cancel()
+                    with contextlib.suppress(asyncio.CancelledError):
+                        await self._recv_task
+                    self._recv_task = None
+
+                if self._outgoing_task:
+                    self._outgoing_task.cancel()
+                    with contextlib.suppress(asyncio.CancelledError):
+                        await self._outgoing_task
+                    self._outgoing_task = None
+
+                for fut in self._pending.values():
+                    if not fut.done():
+                        fut.set_exception(WebSocketNotConnectedError)
+                self._pending.clear()
+
+                if self._ws:
+                    try:
+                        await self._ws.close()
+                    except Exception:
+                        self.logger.debug(
+                            "Error closing ws during cleanup", exc_info=True
+                        )
+                    self._ws = None
+
+                self.is_connected = False
+                self.logger.info("Client start() cleaned up")
+
+            if not self.reconnect:
+                self.logger.info("Reconnect disabled — exiting start()")
+                return
+
+            self.logger.info("Reconnect enabled — restarting client")
+            await asyncio.sleep(self.reconnect_delay)
+
+    async def idle(self):
+        await asyncio.Event().wait()
+
+    async def __aenter__(self) -> Self:
+        self._create_safe_task(self.start(), name="start")
+        while not self.is_connected:
+            await asyncio.sleep(0.05)
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.close()
 
 
 class SocketMaxClient(SocketMixin, MaxClient):

pymax/interfaces.py

@@ -43,15 +43,14 @@ class ClientProtocol(ABC):
         self.last_name: str | None
         self._token: str | None
         self._work_dir: str
+        self.reconnect: bool
         self._database_path: Path
         self._ws: websockets.ClientConnection | None = None
         self._seq: int = 0
         self._pending: dict[int, asyncio.Future[dict[str, Any]]] = {}
         self._recv_task: asyncio.Task[Any] | None = None
         self._incoming: asyncio.Queue[dict[str, Any]] | None = None
-        self._file_upload_waiters: dict[
-            int, asyncio.Future[dict[str, Any]]
-        ] = {}
+        self._file_upload_waiters: dict[int, asyncio.Future[dict[str, Any]]] = {}
         self.user_agent = UserAgentPayload()
         self._outgoing: asyncio.Queue[dict[str, Any]] | None = None
         self._outgoing_task: asyncio.Task[Any] | None = None
@@ -70,9 +69,7 @@ class ClientProtocol(ABC):
         self._on_message_delete_handlers: list[
             tuple[Callable[[Message], Any], Filter | None]
         ] = []
-        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = (
-            None
-        )
+        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
         self._background_tasks: set[asyncio.Task[Any]] = set()
         self._ssl_context: ssl.SSLContext
         self._socket: socket.socket | None = None

pymax/mixins/websocket.py

@@ -25,9 +25,7 @@ class WebSocketMixin(ClientProtocol):
     @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"
-            )
+            self.logger.critical("WebSocket not connected when access attempted")
             raise WebSocketNotConnectedError
         return self._ws
 
@@ -138,9 +136,7 @@ class WebSocketMixin(ClientProtocol):
 
                 if fut and not fut.done():
                     fut.set_result(data)
-                    self.logger.debug(
-                        "Matched response for pending seq=%s", seq
-                    )
+                    self.logger.debug("Matched response for pending seq=%s", seq)
                 else:
                     if self._incoming is not None:
                         try:
@@ -153,13 +149,9 @@ class WebSocketMixin(ClientProtocol):
 
                     try:  # TODO: переделать, временное решение
                         if data.get("opcode") == Opcode.NOTIF_ATTACH:
-                            file_id = data.get("payload", {}).get(
-                                "fileId", None
-                            )
+                            file_id = data.get("payload", {}).get("fileId", None)
                             if isinstance(file_id, int):
-                                fut = self._file_upload_waiters.pop(
-                                    file_id, None
-                                )
+                                fut = self._file_upload_waiters.pop(file_id, None)
                                 if fut and not fut.done():
                                     fut.set_result(data)
                                     self.logger.debug(
@@ -167,9 +159,7 @@ class WebSocketMixin(ClientProtocol):
                                         file_id,
                                     )
                     except Exception:
-                        self.logger.exception(
-                            "Error handling file upload notification"
-                        )
+                        self.logger.exception("Error handling file upload notification")
 
                     if (
                         data.get("opcode") == Opcode.NOTIF_MESSAGE.value
@@ -185,23 +175,17 @@ class WebSocketMixin(ClientProtocol):
                                             for (
                                                 edit_handler,
                                                 edit_filter,
-                                            ) in (
-                                                self._on_message_edit_handlers
-                                            ):
+                                            ) in self._on_message_edit_handlers:
                                                 await self._process_message_handler(
                                                     edit_handler,
                                                     edit_filter,
                                                     msg,
                                                 )
-                                        elif (
-                                            msg.status == MessageStatus.REMOVED
-                                        ):
+                                        elif msg.status == MessageStatus.REMOVED:
                                             for (
                                                 remove_handler,
                                                 remove_filter,
-                                            ) in (
-                                                self._on_message_delete_handlers
-                                            ):
+                                            ) in self._on_message_delete_handlers:
                                                 await self._process_message_handler(
                                                     remove_handler,
                                                     remove_filter,
@@ -211,19 +195,22 @@ class WebSocketMixin(ClientProtocol):
                                         handler, filter, msg
                                     )
                         except Exception:
-                            self.logger.exception(
-                                "Error in on_message_handler"
-                            )
+                            self.logger.exception("Error in on_message_handler")
 
             except websockets.exceptions.ConnectionClosed:
-                self.logger.info(
-                    "WebSocket connection closed; exiting recv loop"
-                )
+                self.logger.info("WebSocket connection closed; 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"
-                )
+                self.logger.exception("Error in recv_loop; backing off briefly")
                 await asyncio.sleep(RECV_LOOP_BACKOFF_DELAY)
 
     def _log_task_exception(self, fut: asyncio.Future[Any]) -> None:
@@ -312,9 +299,7 @@ class WebSocketMixin(ClientProtocol):
                         await asyncio.sleep(5)
                         continue
 
-                message = (
-                    await self._outgoing.get()
-                )  # TODO: persistent msg q mb?
+                message = await self._outgoing.get()  # TODO: persistent msg q mb?
                 if not message:
                     continue
 
@@ -388,9 +373,7 @@ class WebSocketMixin(ClientProtocol):
         ).model_dump(by_alias=True)
 
         try:
-            data = await self._send_and_wait(
-                opcode=Opcode.LOGIN, payload=payload
-            )
+            data = await self._send_and_wait(opcode=Opcode.LOGIN, payload=payload)
             raw_payload = data.get("payload", {})
 
             if error := raw_payload.get("error"):

pymax/payloads.py

@@ -1,4 +1,4 @@
-from typing import Any, Final, Literal
+from typing import Any, Literal
 
 from pydantic import AliasChoices, BaseModel, Field
 
@@ -30,7 +30,7 @@ class CamelModel(BaseModel):
 
 
 class BaseWebSocketMessage(BaseModel):
-    ver: Final[int] = 11
+    ver: Literal[10, 11] = 11
     cmd: int
     seq: int
     opcode: int
@@ -195,14 +195,14 @@ class ChangeGroupProfilePayload(CamelModel):
 
 
 class GetGroupMembersPayload(CamelModel):
-    type: Final[str] = "MEMBER"
+    type: Literal["MEMBER"] = "MEMBER"
     marker: int
     chat_id: int
     count: int
 
 
 class SearchGroupMembersPayload(CamelModel):
-    type: Final[str] = "MEMBER"
+    type: Literal["MEMBER"] = "MEMBER"
     query: str
     chat_id: int
 

pymax/static/enum.py

@@ -190,6 +190,7 @@ class AttachType(str, Enum):
     VIDEO = "VIDEO"
     FILE = "FILE"
     STICKER = "STICKER"
+    AUDIO = "AUDIO"
     CONTROL = "CONTROL"
 
 

pymax/types.py

@@ -163,9 +163,7 @@ class Contact:
 
     @override
     def __str__(self) -> str:
-        return (
-            f"Contact {self.id}: {', '.join(str(n) for n in self.names or [])}"
-        )
+        return f"Contact {self.id}: {', '.join(str(n) for n in self.names or [])}"
 
 
 class Member:
@@ -279,9 +277,7 @@ class StickerAttach:
 
 
 class ControlAttach:
-    def __init__(
-        self, type: AttachType, event: str, **kwargs: dict[str, Any]
-    ) -> None:
+    def __init__(self, type: AttachType, event: str, **kwargs: dict[str, Any]) -> None:
         self.type = type
         self.event = event
         self.extra = kwargs
@@ -306,6 +302,50 @@ class ControlAttach:
         return f"ControlAttach: {self.event}"
 
 
+class AudioAttach:
+    def __init__(
+        self,
+        duration: int,
+        audio_id: int,
+        url: str,
+        wave: str,
+        transcription_status: str,  # TODO: сделать энам
+        token: str,
+        type: AttachType,
+    ) -> None:
+        self.duration = duration
+        self.audio_id = audio_id
+        self.url = url
+        self.wave = wave
+        self.transcription_status = transcription_status
+        self.token = token
+        self.type = type
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        return cls(
+            duration=data["duration"],
+            audio_id=data["audioId"],
+            url=data["url"],
+            wave=data["wave"],
+            transcription_status=data["transcriptionStatus"],
+            token=data["token"],
+            type=AttachType(data["_type"]),
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"AudioAttach(duration={self.duration!r}, audio_id={self.audio_id!r}, "
+            f"url={self.url!r}, wave={self.wave!r}, transcription_status={self.transcription_status!r}, "
+            f"token={self.token!r}, type={self.type!r})"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"AudioAttach: {self.audio_id}"
+
+
 class PhotoAttach:
     def __init__(
         self,
@@ -522,13 +562,13 @@ class Element:
 
     @classmethod
     def from_dict(cls, data: dict[Any, Any]) -> Self:
-        return cls(
-            type=data["type"], length=data["length"], from_=data.get("from")
-        )
+        return cls(type=data["type"], length=data["length"], from_=data.get("from"))
 
     @override
     def __repr__(self) -> str:
-        return f"Element(type={self.type!r}, length={self.length!r}, from_={self.from_!r})"
+        return (
+            f"Element(type={self.type!r}, length={self.length!r}, from_={self.from_!r})"
+        )
 
     @override
     def __str__(self) -> str:
@@ -591,9 +631,7 @@ class ReactionInfo:
     def from_dict(cls, data: dict[str, Any]) -> Self:
         return cls(
             total_count=data.get("totalCount", 0),
-            counters=[
-                ReactionCounter.from_dict(c) for c in data.get("counters", [])
-            ],
+            counters=[ReactionCounter.from_dict(c) for c in data.get("counters", [])],
             your_reaction=data.get("yourReaction"),
         )
 
@@ -619,6 +657,7 @@ class Message:
                 | FileAttach
                 | ControlAttach
                 | StickerAttach
+                | AudioAttach
             ]
             | None
         ),
@@ -640,11 +679,7 @@ class Message:
     def from_dict(cls, data: dict[Any, Any]) -> Self:
         message = data["message"] if data.get("message") else data
         attaches: list[
-            PhotoAttach
-            | VideoAttach
-            | FileAttach
-            | ControlAttach
-            | StickerAttach
+            PhotoAttach | VideoAttach | FileAttach | ControlAttach | StickerAttach
         ] = []
         for a in message.get("attaches", []):
             if a["_type"] == AttachType.PHOTO:
@@ -657,6 +692,8 @@ class Message:
                 attaches.append(ControlAttach.from_dict(a))
             elif a["_type"] == AttachType.STICKER:
                 attaches.append(StickerAttach.from_dict(a))
+            elif a["_type"] == AttachType.AUDIO:
+                attaches.append(AudioAttach.from_dict(a))
         link_value = message.get("link")
         if isinstance(link_value, dict):
             link = MessageLink.from_dict(link_value)
@@ -670,9 +707,7 @@ class Message:
         return cls(
             chat_id=data.get("chatId"),
             sender=message.get("sender"),
-            elements=[
-                Element.from_dict(e) for e in message.get("elements", [])
-            ],
+            elements=[Element.from_dict(e) for e in message.get("elements", [])],
             options=message.get("options"),
             id=message["id"],
             time=message["time"],
@@ -834,13 +869,9 @@ class Chat:
             int(k): v for k, v in raw_admins.items()
         }
         raw_participants = data.get("participants", {}) or {}
-        participants: dict[int, int] = {
-            int(k): v for k, v in raw_participants.items()
-        }
+        participants: dict[int, int] = {int(k): v for k, v in raw_participants.items()}
         last_msg = (
-            Message.from_dict(data["lastMessage"])
-            if data.get("lastMessage")
-            else None
+            Message.from_dict(data["lastMessage"]) if data.get("lastMessage") else None
         )
         return cls(
             participants_count=data.get("participantsCount", 0),
@@ -852,9 +883,7 @@ class Chat:
             description=data.get("description"),
             chat_type=ChatType(data.get("type", ChatType.CHAT.value)),
             title=data.get("title"),
-            last_fire_delayed_error_time=data.get(
-                "lastFireDelayedErrorTime", 0
-            ),
+            last_fire_delayed_error_time=data.get("lastFireDelayedErrorTime", 0),
             last_delayed_update_time=data.get("lastDelayedUpdateTime", 0),
             options=data.get("options", {}),
             modified=data.get("modified", 0),
@@ -876,9 +905,7 @@ class Chat:
 
     @override
     def __repr__(self) -> str:
-        return (
-            f"Chat(id={self.id!r}, title={self.title!r}, type={self.type!r})"
-        )
+        return f"Chat(id={self.id!r}, title={self.title!r}, type={self.type!r})"
 
     @override
     def __str__(self) -> str: