maxapi-python 1.0.1__tar.gz → 1.1.2__tar.gz

{maxapi_python-1.0.1 → maxapi_python-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.0.1
+Version: 1.1.2
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/noxzion/PyMax
 Project-URL: Repository, https://github.com/noxzion/PyMax
@@ -14,11 +14,9 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: aiohttp>=3.12.15
-Requires-Dist: build>=1.3.0
 Requires-Dist: lz4>=4.4.4
 Requires-Dist: msgpack>=1.1.1
 Requires-Dist: sqlmodel>=0.0.24
-Requires-Dist: twine>=6.2.0
 Requires-Dist: websockets>=11.0
 Description-Content-Type: text/markdown
 

{maxapi_python-1.0.1 → maxapi_python-1.1.2}/examples/example.py

@@ -1,16 +1,16 @@
 import asyncio
+import logging
 
-from pymax import MaxClient, Message
+from pymax import MaxClient, Message, SocketMaxClient
 from pymax.files import Photo
 from pymax.filters import Filter
+from pymax.static import AttachType
 
 phone = "+1234567890"
 
 
-client = MaxClient(
-    phone=phone,
-    work_dir="cache",
-)
+# client = MaxClient(phone=phone, work_dir="cache")
+client = SocketMaxClient(phone=phone, work_dir="cache")
 
 
 async def main() -> None:
@@ -46,25 +46,26 @@ async def handle_message(message: Message) -> None:
 @client.on_start
 async def handle_start() -> None:
     print("Client started successfully!")
-    # history = await client.fetch_history(chat_id=0)
-    # if history:
-    #     for message in history:
-    #         user_id = message.sender
-    #         user = await client.get_user(user_id)
+    history = await client.fetch_history(chat_id=0)
+    if history:
+        for message in history:
+            user_id = message.sender
+            user = await client.get_user(user_id)
 
-    #         if user:
-    #             print(f"{user.names[0].name}: {message.text}")
+            if user:
+                print(f"{user.names[0].name}: {message.text}")
 
-    # print(client.me.names[0].first_name)
-    # user = await client.get_user(client.me.id)
+    print(client.me.names[0].first_name)
+    user = await client.get_user(client.me.id)
 
-    # print(user.names[0].first_name)
-    # photo1 = Photo(path="tests/test.jpeg")
-    # photo2 = Photo(path="tests/test.jpg")
+    print(user.names[0].first_name)
 
-    # await client.send_message(
-    #     "Hello with photo!", chat_id=0, photos=[photo1, photo2], notify=True
-    # )
+    photo1 = Photo(path="tests/test.jpeg")
+    photo2 = Photo(path="tests/test.jpg")
+
+    await client.send_message(
+        "Hello with photo!", chat_id=0, photos=[photo1, photo2], notify=True
+    )
 
 
 if __name__ == "__main__":

{maxapi_python-1.0.1 → maxapi_python-1.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "maxapi-python"
-version = "1.0.1"
+version = "1.1.2"
 description = "Python wrapper для API мессенджера Max"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -21,8 +21,6 @@ dependencies = [
     "lz4>=4.4.4",
     "aiohttp>=3.12.15",
     "aiofiles>=24.1.0",
-    "build>=1.3.0",
-    "twine>=6.2.0",
 ]
 
 [project.urls]

{maxapi_python-1.0.1 → maxapi_python-1.1.2}/src/pymax/__init__.py

@@ -5,6 +5,7 @@ Python wrapper для API мессенджера Max
 from .core import (
     InvalidPhoneError,
     MaxClient,
+    SocketMaxClient,
     WebSocketNotConnectedError,
 )
 from .static import (
@@ -50,6 +51,7 @@ __all__ = [
     "MessageStatus",
     "MessageType",
     "Opcode",
+    "SocketMaxClient",
     "User",
     "WebSocketNotConnectedError",
 ]

{maxapi_python-1.0.1 → maxapi_python-1.1.2}/src/pymax/core.py

@@ -1,25 +1,23 @@
 import asyncio
-import json
 import logging
-import re
+import socket
+import ssl
 import time
 from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-import websockets
+from typing_extensions import override
 
 from .crud import Database
 from .exceptions import InvalidPhoneError, WebSocketNotConnectedError
-from .mixins import ApiMixin, WebSocketMixin
-from .payloads import (
-    BaseWebSocketMessage,
-    SyncPayload,
-)
-from .static import ChatType, Constants, Opcode
-from .types import Channel, Chat, Dialog, Me, Message, User, override
+from .mixins import ApiMixin, SocketMixin, WebSocketMixin
+from .static import Constants
+from .types import Channel, Chat, Dialog, Me, Message, User
 
 if TYPE_CHECKING:
+    import websockets
+
     from .filters import Filter
 
 logger = logging.getLogger(__name__)
@@ -36,6 +34,12 @@ class MaxClient(ApiMixin, WebSocketMixin):
         work_dir (str, optional): Рабочая директория для хранения базы данных. По умолчанию ".".
         logger (logging.Logger | None): Пользовательский логгер. Если не передан — используется
             логгер модуля с именем f"{__name__}.MaxClient".
+        headers (dict[str, Any] | None): Заголовки для подключения к WebSocket. По умолчанию
+            Constants.DEFAULT_USER_AGENT.value.
+        token (str | None, optional): Токен авторизации. Если не передан, будет выполнен
+            процесс логина по номеру телефона.
+        host (str, optional): Хост API сервера. По умолчанию Constants.HOST.value.
+        port (int, optional): Порт API сервера. По умолчанию Constants.PORT.value.
 
     Raises:
         InvalidPhoneError: Если формат номера телефона неверный.
@@ -48,6 +52,8 @@ class MaxClient(ApiMixin, WebSocketMixin):
         headers: dict[str, Any] | None = Constants.DEFAULT_USER_AGENT.value,
         token: str | None = None,
         send_fake_telemetry: bool = True,
+        host: str = Constants.HOST.value,
+        port: int = Constants.PORT.value,
         work_dir: str = ".",
         logger: logging.Logger | None = None,
     ) -> None:
@@ -61,6 +67,8 @@ class MaxClient(ApiMixin, WebSocketMixin):
         self._users: dict[int, User] = {}
         if not self._check_phone():
             raise InvalidPhoneError(self.phone)
+        self.host: str = host
+        self.port: int = port
         self._work_dir: str = work_dir
         self._database_path: Path = Path(work_dir) / "session.db"
         self._database_path.parent.mkdir(parents=True, exist_ok=True)
@@ -85,6 +93,13 @@ class MaxClient(ApiMixin, WebSocketMixin):
         ] = []
         self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
         self._background_tasks: set[asyncio.Task[Any]] = set()
+        self._ssl_context = ssl.create_default_context()
+        self._ssl_context.set_ciphers("DEFAULT")
+        self._ssl_context.check_hostname = True
+        self._ssl_context.verify_mode = ssl.CERT_REQUIRED
+        self._ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
+        self._ssl_context.load_default_certs()
+        self._socket: socket.socket | None = None
         self.logger = logger or logging.getLogger(f"{__name__}.MaxClient")
         self._setup_logger()
 
@@ -103,6 +118,12 @@ class MaxClient(ApiMixin, WebSocketMixin):
             handler.setFormatter(formatter)
             logger.addHandler(handler)
 
+    async def _wait_forever(self):
+        try:
+            await self.ws.wait_closed()
+        except asyncio.CancelledError:
+            self.logger.debug("wait_closed cancelled")
+
     async def close(self) -> None:
         try:
             self.logger.info("Closing client")
@@ -142,29 +163,31 @@ class MaxClient(ApiMixin, WebSocketMixin):
                 if asyncio.iscoroutine(result):
                     await result
 
-            if self._ws:
-                ping_task = asyncio.create_task(self._send_interactive_ping())
-                if self._send_fake_telemetry:
-                    telemetry_task = asyncio.create_task(self._start())
-                    self._background_tasks.add(telemetry_task)
-                    telemetry_task.add_done_callback(
-                        lambda t: self._background_tasks.discard(t)
-                        or self._log_task_exception(t)
-                    )
-                self._background_tasks.add(ping_task)
-                ping_task.add_done_callback(
+            ping_task = asyncio.create_task(self._send_interactive_ping())
+            self._background_tasks.add(ping_task)
+            if self._send_fake_telemetry:
+                telemetry_task = asyncio.create_task(self._start())
+                self._background_tasks.add(telemetry_task)
+                telemetry_task.add_done_callback(
                     lambda t: self._background_tasks.discard(t)
                     or self._log_task_exception(t)
                 )
-
-                try:
-                    await self._ws.wait_closed()
-                except asyncio.CancelledError:
-                    self.logger.debug("wait_closed cancelled")
+            ping_task.add_done_callback(
+                lambda t: self._background_tasks.discard(t)
+                or self._log_task_exception(t)
+            )
+            await self._wait_forever()
         except Exception:
             self.logger.exception("Client start failed")
 
 
-class SocketMaxClient:
-    pass  # нокс займись
-    # нет не займусь
+class SocketMaxClient(SocketMixin, MaxClient):
+    @override
+    async def _wait_forever(self):
+        if self._recv_task:
+            try:
+                await self._recv_task
+            except asyncio.CancelledError:
+                self.logger.debug("Socket recv_task cancelled")
+            except Exception as e:
+                self.logger.exception("Socket recv_task failed: %s", e)

{maxapi_python-1.0.1 → maxapi_python-1.1.2}/src/pymax/interfaces.py

@@ -1,5 +1,7 @@
 import asyncio
 import logging
+import socket
+import ssl
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
 from logging import Logger
@@ -38,6 +40,8 @@ class ClientProtocol(ABC):
         self.dialogs: list[Dialog] = []
         self.channels: list[Channel] = []
         self.me: Me | None = None
+        self.host: str
+        self.port: int
         self._users: dict[int, User] = {}
         self._work_dir: str
         self._database_path: Path
@@ -57,6 +61,8 @@ class ClientProtocol(ABC):
         ] = []
         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
 
     @abstractmethod
     async def _send_and_wait(

{maxapi_python-1.0.1 → maxapi_python-1.1.2}/src/pymax/mixins/__init__.py

@@ -3,6 +3,7 @@ from .channel import ChannelMixin
 from .handler import HandlerMixin
 from .message import MessageMixin
 from .self import SelfMixin
+from .socket import SocketMixin
 from .telemetry import TelemetryMixin
 from .user import UserMixin
 from .websocket import WebSocketMixin
@@ -18,3 +19,17 @@ class ApiMixin(
     TelemetryMixin,
 ):
     pass
+
+
+__all__ = [
+    "ApiMixin",
+    "AuthMixin",
+    "ChannelMixin",
+    "HandlerMixin",
+    "MessageMixin",
+    "SelfMixin",
+    "SocketMixin",
+    "TelemetryMixin",
+    "UserMixin",
+    "WebSocketMixin",
+]

maxapi_python-1.1.2/src/pymax/mixins/socket.py

@@ -0,0 +1,380 @@
+import asyncio
+import socket
+import ssl
+import sys
+from typing import Any
+
+import lz4.block
+import msgpack
+from typing_extensions import override
+
+from pymax.filters import Message
+from pymax.interfaces import ClientProtocol
+from pymax.payloads import BaseWebSocketMessage, SyncPayload
+from pymax.static import Opcode
+from pymax.types import Channel, Chat, Dialog, Me
+
+
+class SocketMixin(ClientProtocol):
+    @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 ConnectionError("Socket not connected")
+        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:
+                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 = msgpack.packb(payload)
+        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: dict[str, Any]) -> dict[str, Any]:
+        try:
+            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._pending = {}
+            self._recv_task = asyncio.create_task(self._recv_loop())
+            self.logger.info("Socket connected, starting handshake")
+            return await self._handshake(user_agent)
+        except Exception as e:
+            self.logger.error("Failed to connect: %s", e, exc_info=True)
+            raise ConnectionError(f"Failed to connect: {e}")
+
+    async def _handshake(self, user_agent: dict[str, Any]) -> dict[str, Any]:
+        try:
+            self.logger.debug(
+                "Sending handshake with user_agent keys=%s", list(user_agent.keys())
+            )
+            resp = await self._send_and_wait(
+                opcode=Opcode.SESSION_INIT,
+                payload={"deviceId": str(self._device_id), "userAgent": user_agent},
+            )
+            self.logger.info("Handshake completed")
+            return resp
+        except Exception as e:
+            self.logger.error("Handshake failed: %s", e, exc_info=True)
+            raise ConnectionError(f"Handshake failed: {e}")
+
+    async def _recv_loop(self) -> None:
+        if self._socket is None:
+            self.logger.warning("Recv loop started without socket instance")
+            return
+
+        loop = asyncio.get_running_loop()
+
+        def _recv_exactly(n: int) -> bytes:
+            """Синхронная функция: читает ровно n байт из сокета или возвращает b'' если закрыт."""
+            buf = bytearray()
+            sock = self._socket
+            while len(buf) < n:
+                chunk = sock.recv(n - len(buf))
+                if not chunk:
+                    return bytes(buf)
+                buf.extend(chunk)
+            return bytes(buf)
+
+        try:
+            while True:
+                try:
+                    header = await loop.run_in_executor(None, lambda: _recv_exactly(10))
+                    if not header or len(header) < 10:
+                        self.logger.info("Socket connection closed; exiting recv loop")
+                        self.is_connected = False
+                        try:
+                            self._socket.close()
+                        except Exception:
+                            pass
+                        break
+
+                    packed_len = int.from_bytes(header[6:10], "big", signed=False)
+                    payload_length = packed_len & 0xFFFFFF
+                    remaining = payload_length
+                    payload = bytearray()
+
+                    while remaining > 0:
+                        chunk = await loop.run_in_executor(
+                            None, lambda r=remaining: _recv_exactly(min(r, 8192))
+                        )
+                        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"
+                        )
+                        continue
+
+                    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(0.5)
+                        continue
+
+                    data = self._unpack_packet(raw)
+                    if not data:
+                        self.logger.warning("Failed to unpack packet, skipping")
+                        continue
+
+                    payload_objs = data.get("payload")
+                    datas = (
+                        [{**data, "payload": obj} for obj in payload_objs]
+                        if isinstance(payload_objs, list)
+                        else [data]
+                    )
+
+                    for data_item in datas:
+                        seq = data_item.get("seq")
+                        fut = self._pending.get(seq) if isinstance(seq, int) else None
+                        if fut and not fut.done():
+                            fut.set_result(data_item)
+                            self.logger.debug(
+                                "Matched response for pending seq=%s", seq
+                            )
+                            continue
+
+                        if self._incoming is not None:
+                            try:
+                                self._incoming.put_nowait(data_item)
+                            except asyncio.QueueFull:
+                                self.logger.warning(
+                                    "Incoming queue full; dropping message seq=%s",
+                                    seq,
+                                )
+
+                        if (
+                            data_item.get("opcode") == Opcode.NOTIF_MESSAGE
+                            and self._on_message_handlers
+                        ):
+                            try:
+                                for handler, filter in self._on_message_handlers:
+                                    payload = data_item.get("payload", {})
+                                    msg_dict = (
+                                        payload.get("message")
+                                        if isinstance(payload, dict)
+                                        else None
+                                    )
+                                    msg = (
+                                        Message.from_dict(msg_dict)
+                                        if msg_dict
+                                        else None
+                                    )
+                                    if msg and not msg.status:
+                                        if filter and not filter.match(msg):
+                                            continue
+                                        result = handler(msg)
+                                        if asyncio.iscoroutine(result):
+                                            task = asyncio.create_task(result)
+                                            self._background_tasks.add(task)
+                                            task.add_done_callback(
+                                                lambda t: self._background_tasks.discard(
+                                                    t
+                                                )
+                                                or self._log_task_exception(t)
+                                            )
+                            except Exception:
+                                self.logger.exception("Error in on_message_handler")
+                except asyncio.CancelledError:
+                    self.logger.debug("Recv loop cancelled")
+                    break
+                except Exception:
+                    self.logger.exception("Error in recv_loop; backing off briefly")
+                    await asyncio.sleep(0.5)
+        finally:
+            self.logger.warning("<<< Recv loop exited (socket)")
+
+    def _log_task_exception(self, task: asyncio.Task[Any]) -> None:
+        try:
+            exc = task.exception()
+            if exc:
+                self.logger.exception("Background task exception: %s", exc)
+        except Exception:
+            pass
+
+    async def _send_interactive_ping(self) -> None:
+        while self.is_connected:
+            try:
+                await self._send_and_wait(
+                    opcode=Opcode.PING,
+                    payload={"interactive": True},
+                    cmd=0,
+                )
+                self.logger.debug("Interactive ping sent successfully (socket)")
+            except Exception:
+                self.logger.warning("Interactive ping failed (socket)", exc_info=True)
+            await asyncio.sleep(30)
+
+    def _make_message(
+        self, opcode: int, payload: dict[str, Any], cmd: int = 0
+    ) -> dict[str, Any]:
+        self._seq += 1
+        msg = BaseWebSocketMessage(
+            ver=11,
+            cmd=cmd,
+            seq=self._seq,
+            opcode=opcode,
+            payload=payload,
+        ).model_dump(by_alias=True)
+        self.logger.debug(
+            "make_message opcode=%s cmd=%s seq=%s", opcode, cmd, self._seq
+        )
+        return msg
+
+    @override
+    async def _send_and_wait(
+        self,
+        opcode: int,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = 10.0,
+    ) -> dict[str, Any]:
+        if not self.is_connected or self._socket is None:
+            raise ConnectionError("Socket not connected")
+        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):
+            self.logger.warning("Connection lost, reconnecting...")
+            self.is_connected = False
+            try:
+                await self._connect(self.user_agent)
+            except Exception:
+                self.logger.error("Reconnect failed", exc_info=True)
+                raise
+        except Exception:
+            self.logger.exception(
+                "Send and wait failed (opcode=%s, seq=%s)", opcode, msg["seq"]
+            )
+            raise RuntimeError("Send and wait failed (socket)")
+
+        finally:
+            self._pending.pop(msg["seq"], None)
+
+    async def _sync(self) -> None:
+        try:
+            self.logger.info("Starting initial sync (socket)")
+            payload = SyncPayload(
+                interactive=True,
+                token=self._token,
+                chats_sync=0,
+                contacts_sync=0,
+                presence_sync=0,
+                drafts_sync=0,
+                chats_count=40,
+            ).model_dump(by_alias=True)
+            data = await self._send_and_wait(opcode=Opcode.LOGIN, payload=payload)
+            raw_payload = data.get("payload", {})
+            if error := raw_payload.get("error"):
+                self.logger.error("Sync error: %s", error)
+                return
+            for raw_chat in raw_payload.get("chats", []):
+                try:
+                    if raw_chat.get("type") == "DIALOG":
+                        self.dialogs.append(Dialog.from_dict(raw_chat))
+                    elif raw_chat.get("type") == "CHAT":
+                        self.chats.append(Chat.from_dict(raw_chat))
+                    elif raw_chat.get("type") == "CHANNEL":
+                        self.channels.append(Channel.from_dict(raw_chat))
+                except Exception:
+                    self.logger.exception("Error parsing chat entry (socket)")
+            if raw_payload.get("profile", {}).get("contact"):
+                self.me = Me.from_dict(
+                    raw_payload.get("profile", {}).get("contact", {})
+                )
+            self.logger.info(
+                "Sync completed: dialogs=%d chats=%d channels=%d",
+                len(self.dialogs),
+                len(self.chats),
+                len(self.channels),
+            )
+        except Exception:
+            self.logger.exception("Sync failed (socket)")
+
+    @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

{maxapi_python-1.0.1 → maxapi_python-1.1.2}/src/pymax/mixins/websocket.py

@@ -54,7 +54,7 @@ class WebSocketMixin(ClientProtocol):
     async def _connect(self, user_agent: dict[str, Any]) -> dict[str, Any]:
         try:
             self.logger.info("Connecting to WebSocket %s", self.uri)
-            self._ws = await websockets.connect(self.uri, origin="https://web.max.ru")
+            self._ws = await websockets.connect(self.uri, origin="https://web.max.ru")  # type: ignore[]
             self.is_connected = True
             self._incoming = asyncio.Queue()
             self._pending = {}

{maxapi_python-1.0.1 → maxapi_python-1.1.2}/src/pymax/static.py

@@ -196,6 +196,8 @@ class AttachType(str, Enum):
 class Constants(Enum):
     PHONE_REGEX = r"^\+?\d{10,15}$"
     WEBSOCKET_URI = "wss://ws-api.oneme.ru/websocket"
+    HOST = "api.oneme.ru"
+    PORT = 443
     DEFAULT_TIMEOUT = 10.0
     DEFAULT_USER_AGENT = {  # noqa: RUF012
         "deviceType": "WEB",

{maxapi_python-1.0.1 → maxapi_python-1.1.2}/src/pymax/types.py

@@ -39,6 +39,134 @@ class Names:
         return self.name
 
 
+class PhotoAttach:
+    def __init__(
+        self,
+        base_url: str,
+        height: int,
+        width: int,
+        photo_id: int,
+        photo_token: str,
+        preview_data: str,
+        type: AttachType,
+    ) -> None:
+        self.base_url = base_url
+        self.height = height
+        self.width = width
+        self.photo_id = photo_id
+        self.photo_token = photo_token
+        self.preview_data = preview_data
+        self.type = type
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "PhotoAttach":
+        return cls(
+            base_url=data["baseUrl"],
+            height=data["height"],
+            width=data["width"],
+            photo_id=data["photoId"],
+            photo_token=data["photoToken"],
+            preview_data=data["previewData"],
+            type=AttachType(data["_type"]),
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"PhotoAttach(photo_id={self.photo_id!r}, base_url={self.base_url!r}, "
+            f"height={self.height!r}, width={self.width!r}, photo_token={self.photo_token!r}, "
+            f"preview_data={self.preview_data!r}, type={self.type!r})"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"PhotoAttach: {self.photo_id}"
+
+
+class VideoAttach:
+    def __init__(
+        self,
+        height: int,
+        width: int,
+        video_id: int,
+        duration: int,
+        preview_data: str,
+        type: AttachType,
+        thumbnail: str,
+        token: str,
+        video_type: int,
+    ) -> None:
+        self.height = height
+        self.width = width
+        self.video_id = video_id
+        self.duration = duration
+        self.preview_data = preview_data
+        self.type = type
+        self.thumbnail = thumbnail
+        self.token = token
+        self.video_type = video_type
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "VideoAttach":
+        return cls(
+            height=data["height"],
+            width=data["width"],
+            video_id=data["videoId"],
+            duration=data["duration"],
+            preview_data=data["previewData"],
+            type=AttachType(data["_type"]),
+            thumbnail=data["thumbnail"],
+            token=data["token"],
+            video_type=data["videoType"],
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"VideoAttach(video_id={self.video_id!r}, height={self.height!r}, "
+            f"width={self.width!r}, duration={self.duration!r}, "
+            f"preview_data={self.preview_data!r}, type={self.type!r}, "
+            f"thumbnail={self.thumbnail!r}, token={self.token!r}, "
+            f"video_type={self.video_type!r})"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"VideoAttach: {self.video_id}"
+
+
+class FileAttach:
+    def __init__(
+        self, file_id: int, name: str, size: int, token: str, type: AttachType
+    ) -> None:
+        self.file_id = file_id
+        self.name = name
+        self.size = size
+        self.token = token
+        self.type = type
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "FileAttach":
+        return cls(
+            file_id=data["fileId"],
+            name=data["name"],
+            size=data["size"],
+            token=data["token"],
+            type=AttachType(data["_type"]),
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"FileAttach(file_id={self.file_id!r}, name={self.name!r}, "
+            f"size={self.size!r}, token={self.token!r}, type={self.type!r})"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"FileAttach: {self.file_id}"
+
+
 class Me:
     def __init__(
         self,
@@ -111,7 +239,7 @@ class Message:
         text: str,
         status: MessageStatus | str | None,
         type: MessageType | str,
-        attaches: list[Any],
+        attaches: list[PhotoAttach | VideoAttach | FileAttach],
     ) -> None:
         self.sender = sender
         self.elements = elements
@@ -126,6 +254,14 @@ class Message:
 
     @classmethod
     def from_dict(cls, data: dict[Any, Any]) -> "Message":
+        attaches = []
+        for a in data.get("attaches", []):
+            if a["_type"] == AttachType.PHOTO:
+                attaches.append(PhotoAttach.from_dict(a))
+            elif a["_type"] == AttachType.VIDEO:
+                attaches.append(VideoAttach.from_dict(a))
+            elif a["_type"] == AttachType.FILE:
+                attaches.append(FileAttach.from_dict(a))
         return cls(
             sender=data.get("sender"),
             elements=[Element.from_dict(e) for e in data.get("elements", [])],
@@ -134,7 +270,7 @@ class Message:
             time=data["time"],
             text=data["text"],
             type=data["type"],
-            attaches=data.get("attaches", []),
+            attaches=attaches,
             status=data.get("status"),
             reaction_info=data.get("reactionInfo"),
         )
@@ -397,7 +533,7 @@ class User:
         return f"User {self.id}: {', '.join(str(n) for n in self.names)}"
 
 
-class Attach:
+class Attach:  # УБРАТЬ ГАДА!!!
     def __init__(
         self,
         _type: AttachType,