maxapi-python 1.1.19__py3-none-any.whl → 1.1.20__py3-none-any.whl

{maxapi_python-1.1.19.dist-info → maxapi_python-1.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.19
+Version: 1.1.20
 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.20.dist-info/RECORD

@@ -0,0 +1,31 @@
+pymax/__init__.py,sha256=6wUKKwsyxFpWG3b7kwptOvHd-w78C-ygw42iCDBYQvc,1915
+pymax/core.py,sha256=LqX56a5BagUYl1vpB55Y1pLZQdMoC86t6mIQVlkVByo,17322
+pymax/crud.py,sha256=wmJh8MPi3L_HbYp7MJP0eXfDcnjgfkLDa9rHAmXtkow,3219
+pymax/exceptions.py,sha256=nDUNx7bM-Yjugj-qfIllcrnwLg9JpZroYqfXapjYbMQ,3178
+pymax/files.py,sha256=AvFIr34Desq2p4CNWXIngRqeyTBKMT98VmcnI-zvUU0,3462
+pymax/filters.py,sha256=4hehzyQlyxBxLiEhtSH_KQdFHx8gYaqyIOOD72EsSS0,1536
+pymax/formatter.py,sha256=OVsTwambHhXlOMd0wVECJWuB_S2wSEVKdMLCzgPcvYQ,859
+pymax/formatting.py,sha256=hhtmakfcQDzQRsAckPunnJOCKY2lFdLeIp8Yw53yY8s,2522
+pymax/interfaces.py,sha256=Re8o5N7FSQ-5OgVlK4-WBltX27GheEbfFjoIYl9_u6I,3723
+pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
+pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
+pymax/payloads.py,sha256=cEXY_cVL6SPyhoFTTZnn7dyUx9MMdtNT5SuQSQtL4rg,6983
+pymax/types.py,sha256=_ARcVXLGHyiGAJKYPd6EU9QDKzz4VwS6kjTu3YEH_u4,35523
+pymax/mixins/__init__.py,sha256=xvjcq-lFVHCPss_t8xxXya0OJnsh-owlBqtUlrXSCcw,695
+pymax/mixins/auth.py,sha256=Emv-0WVB_orwv9L_V5gAHfp-VYVaVcbW6AlclW_K6W4,6731
+pymax/mixins/channel.py,sha256=7c8GANyxZuNbIHNBVcPAmMa1qqA1IRf9cGPBS1oK_q4,5159
+pymax/mixins/group.py,sha256=XWXNWluCvq4KkZWqv4sxLpzkXfH33U1yEP20_ZFtSM4,10624
+pymax/mixins/handler.py,sha256=ZuYX8wSgNXJoSMArcwyHvY_bL9A7X0AXnAOz22ATA3k,5897
+pymax/mixins/message.py,sha256=wYvkMPE9ORCSFd_9J-6ltf__4ELG_zaZ_Uey4rmCzHg,25460
+pymax/mixins/self.py,sha256=3BdHfUyqw3dn3ctJX9_hilP1jOaTaunstZ7nH8Y_xcU,5436
+pymax/mixins/socket.py,sha256=GEOscQKKC48bOAXXiDLoz8GusCLtjdxQnB5AK5xJbms,26997
+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=toiXt9qxx6yTgnWJdEOeNfp414MD4zmbHp1qVgVkjnY,19850
+pymax/static/constant.py,sha256=Q1NrmaRj17Gdhk3FmUp3HIwrad1TDorq3wFdQlOCzN8,1027
+pymax/static/enum.py,sha256=ddw5SEVfRb2J9TXOa5IGhssNd-7RyKfwZBKx_UionEM,4562
+maxapi_python-1.1.20.dist-info/METADATA,sha256=9yhRv1m8PbJJhnUdloacxlK0jAE0veq6zfXDP-Ok5nk,6245
+maxapi_python-1.1.20.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+maxapi_python-1.1.20.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
+maxapi_python-1.1.20.dist-info/RECORD,,

{maxapi_python-1.1.19.dist-info → maxapi_python-1.1.20.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

pymax/core.py

@@ -7,12 +7,16 @@ import time
 import traceback
 from collections.abc import Awaitable
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, Self
+from typing import TYPE_CHECKING, Any, Literal
 
-from typing_extensions import override
+from typing_extensions import Self, override
 
 from .crud import Database
-from .exceptions import InvalidPhoneError, WebSocketNotConnectedError
+from .exceptions import (
+    InvalidPhoneError,
+    SocketNotConnectedError,
+    WebSocketNotConnectedError,
+)
 from .formatter import ColoredFormatter
 from .mixins import ApiMixin, SocketMixin, WebSocketMixin
 from .payloads import UserAgentPayload
@@ -176,13 +180,13 @@ class MaxClient(ApiMixin, WebSocketMixin):
             handler.setFormatter(formatter)
             self.logger.addHandler(handler)
 
-    async def _wait_forever(self):
+    async def _wait_forever(self) -> None:
         try:
             await self.ws.wait_closed()
         except asyncio.CancelledError:
             self.logger.debug("wait_closed cancelled")
 
-    async def _safe_execute(self, coro, *, context: str = "unknown"):
+    async def _safe_execute(self, coro, *, context: str = "unknown") -> Any:
         """
         Безопасно выполняет пользовательскую корутину.
         Логирует traceback, но не роняет event loop.
@@ -255,7 +259,7 @@ class MaxClient(ApiMixin, WebSocketMixin):
             telemetry_task.add_done_callback(self._log_task_exception)
             self._background_tasks.add(telemetry_task)
 
-    async def _cleanup_client(self):
+    async def _cleanup_client(self) -> None:
         for task in list(self._background_tasks):
             task.cancel()
             try:
@@ -356,7 +360,6 @@ class MaxClient(ApiMixin, WebSocketMixin):
 
                 await self._wait_forever()
                 self.logger.info("WebSocket closed (wait_forever exited)")
-
             except Exception as e:
                 self.logger.exception("Client start iteration failed")
                 raise e
@@ -396,3 +399,51 @@ class SocketMaxClient(SocketMixin, MaxClient):
                 self.logger.debug("Socket recv_task cancelled")
             except Exception as e:
                 self.logger.exception("Socket recv_task failed: %s", e)
+
+    @override
+    async def _cleanup_client(self):
+        """
+        Socket-specific cleanup: cancel background tasks, set pending futures
+        exceptions to SocketNotConnectedError, and close socket.
+        """
+        from .exceptions import SocketNotConnectedError
+
+        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 (socket)",
+                    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(SocketNotConnectedError())
+        self._pending.clear()
+
+        if self._socket:
+            try:
+                self._socket.close()
+            except Exception:
+                self.logger.debug("Error closing socket during cleanup", exc_info=True)
+            self._socket = None
+
+        self.is_connected = False
+        self.logger.info("Client start() cleaned up (socket)")

pymax/files.py

@@ -9,9 +9,7 @@ from typing_extensions import override
 
 
 class BaseFile(ABC):
-    def __init__(
-        self, url: str | None = None, path: str | None = None
-    ) -> None:
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
         self.url = url
         self.path = path
 
@@ -47,9 +45,7 @@ class Photo(BaseFile):
         ".bmp",
     }  # FIXME: костыль ✅
 
-    def __init__(
-        self, url: str | None = None, path: str | None = None
-    ) -> None:
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
         super().__init__(url, path)
 
     def validate_photo(self) -> tuple[str, str] | None:
@@ -71,9 +67,7 @@ class Photo(BaseFile):
             mime_type = mimetypes.guess_type(self.url)[0]
 
             if not mime_type or not mime_type.startswith("image/"):
-                raise ValueError(
-                    f"URL does not appear to be an image: {self.url}"
-                )
+                raise ValueError(f"URL does not appear to be an image: {self.url}")
 
             return (extension[1:], mime_type)
         return None
@@ -84,15 +78,24 @@ class Photo(BaseFile):
 
 
 class Video(BaseFile):
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
+        self.file_name: str = ""
+        if path:
+            self.file_name = Path(path).name
+        elif url:
+            self.file_name = Path(url).name
+
+        if not self.file_name:
+            raise ValueError("Either url or path must be provided.")
+        super().__init__(url, path)
+
     @override
     async def read(self) -> bytes:
         return await super().read()
 
 
 class File(BaseFile):
-    def __init__(
-        self, url: str | None = None, path: str | None = None
-    ) -> None:
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
         self.file_name: str = ""
         if path:
             self.file_name = Path(path).name

pymax/interfaces.py

@@ -4,23 +4,24 @@ import ssl
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
 from logging import Logger
-from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
-import websockets
-
-from .filters import Filter
 from .payloads import UserAgentPayload
 from .static.constant import DEFAULT_TIMEOUT
 from .static.enum import Opcode
 from .types import Channel, Chat, Dialog, Me, Message, User
 
 if TYPE_CHECKING:
+    from pathlib import Path
     from uuid import UUID
 
+    import websockets
+
+    from pymax import AttachType
     from pymax.types import ReactionInfo
 
     from .crud import Database
+    from .filters import Filter
 
 
 class ClientProtocol(ABC):
@@ -52,7 +53,10 @@ class ClientProtocol(ABC):
         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

pymax/mixins/auth.py

@@ -139,7 +139,7 @@ class AuthMixin(ClientProtocol):
         self.logger.info("Starting registration flow")
 
         request_code_payload = await self.request_code(self.phone)
-        temp_token = request_code_payload.get("token")
+        temp_token = request_code_payload
 
         if not temp_token or not isinstance(temp_token, str):
             self.logger.critical("Failed to request code: token missing")

pymax/mixins/channel.py

@@ -67,11 +67,11 @@ class ChannelMixin(ClientProtocol):
     ) -> tuple[list[Member], int | None]:
         data = await self._send_and_wait(
             opcode=Opcode.CHAT_MEMBERS,
-            payload=payload.model_dump(by_alias=True),
+            payload=payload.model_dump(by_alias=True, exclude_none=True),
         )
         response_payload = data.get("payload", {})
-        if error := response_payload.get("error"):
-            raise ResponseError(error)
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
         marker = response_payload.get("marker")
         if isinstance(marker, str):
             marker = int(marker)
@@ -96,7 +96,7 @@ class ChannelMixin(ClientProtocol):
     async def load_members(
         self,
         chat_id: int,
-        marker: int = DEFAULT_MARKER_VALUE,
+        marker: int | None = DEFAULT_MARKER_VALUE,
         count: int = DEFAULT_CHAT_MEMBERS_LIMIT,
     ) -> tuple[list[Member], int | None]:
         """
@@ -106,11 +106,11 @@ class ChannelMixin(ClientProtocol):
             chat_id (int): Идентификатор канала
             marker (int, optional): Маркер для пагинации. По умолчанию DEFAULT_MARKER_VALUE
             count (int, optional): Количество членов для загрузки. По умолчанию DEFAULT_CHAT_MEMBERS_LIMIT.
-            Данное значение лучше не менять, так как веб-клиент загружает именно столько.
 
         Returns:
-            list[Member]: Список участников канала
+            tuple[list[Member], int | None]: Список участников канала и маркер для следующей страницы
         """
+
         payload = GetGroupMembersPayload(chat_id=chat_id, marker=marker, count=count)
         return await self._query_members(payload)
 

pymax/mixins/group.py

@@ -10,6 +10,7 @@ from pymax.payloads import (
     CreateGroupAttach,
     CreateGroupMessage,
     CreateGroupPayload,
+    GetChatInfoPayload,
     InviteUsersPayload,
     JoinChatPayload,
     RemoveUsersPayload,
@@ -258,3 +259,62 @@ class GroupMixin(ClientProtocol):
             raise Error("no_chat", "Chat data missing in response", "Chat Error")
 
         return chat
+
+    async def get_chats(self, chat_ids: list[int]) -> list[Chat]:
+        """
+        Получает информацию о группах по их ID
+
+        Args:
+            chat_ids (list[int]): Список идентификаторов групп.
+
+        Returns:
+            list[Chat]: Список объектов Chat.
+        """
+        missed_chat_ids = [
+            chat_id for chat_id in chat_ids if await self._get_chat(chat_id) is None
+        ]
+        if missed_chat_ids:
+            payload = GetChatInfoPayload(chat_ids=missed_chat_ids).model_dump(
+                by_alias=True
+            )
+        else:
+            chats: list[Chat] = [
+                chat
+                for chat_id in chat_ids
+                if (chat := await self._get_chat(chat_id)) is not None
+            ]
+            return chats
+
+        data = await self._send_and_wait(opcode=Opcode.CHAT_INFO, payload=payload)
+
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
+
+        chats_data = data["payload"].get("chats", [])
+        chats: list[Chat] = []
+        for chat_dict in chats_data:
+            chat = Chat.from_dict(chat_dict)
+            chats.append(chat)
+            cached_chat = await self._get_chat(chat.id)
+            if cached_chat is None:
+                self.chats.append(chat)
+            else:
+                idx = self.chats.index(cached_chat)
+                self.chats[idx] = chat
+
+        return chats
+
+    async def get_chat(self, chat_id: int) -> Chat:
+        """
+        Получает информацию о группе по ее ID
+
+        Args:
+            chat_id (int): Идентификатор группы.
+
+        Returns:
+            Chat: Объект Chat.
+        """
+        chats = await self.get_chats([chat_id])
+        if not chats:
+            raise Error("no_chat", "Chat not found in response", "Chat Error")
+        return chats[0]

pymax/mixins/handler.py

@@ -1,7 +1,8 @@
 from collections.abc import Awaitable, Callable
 from typing import Any
 
-from pymax.interfaces import ClientProtocol, Filter
+from pymax.filters import Filter
+from pymax.interfaces import ClientProtocol
 from pymax.types import Chat, Message, ReactionInfo
 
 

pymax/mixins/message.py

@@ -1,11 +1,12 @@
 import asyncio
 import time
+from http import HTTPStatus
 
 import aiohttp
 from aiohttp import ClientSession
 
 from pymax.exceptions import Error
-from pymax.files import File, Photo
+from pymax.files import File, Photo, Video
 from pymax.formatting import Formatting
 from pymax.interfaces import ClientProtocol
 from pymax.mixins.utils import MixinsUtils
@@ -27,6 +28,7 @@ from pymax.payloads import (
     SendMessagePayload,
     SendMessagePayloadMessage,
     UploadPayload,
+    VideoAttachPayload,
 )
 from pymax.static.constant import DEFAULT_TIMEOUT
 from pymax.static.enum import AttachType, Opcode
@@ -35,6 +37,7 @@ from pymax.types import (
     FileRequest,
     Message,
     ReactionInfo,
+    VideoAttach,
     VideoRequest,
 )
 
@@ -79,9 +82,8 @@ class MessageMixin(ClientProtocol):
                     data=file_bytes,
                 ) as response,
             ):
-                if response.status != 200:
+                if response.status != HTTPStatus.OK:
                     self.logger.error(f"Upload failed with status {response.status}")
-                    # cleanup waiter
                     self._file_upload_waiters.pop(int(file_id), None)
                     return None
 
@@ -97,7 +99,76 @@ class MessageMixin(ClientProtocol):
                     return None
         except Exception as e:
             self.logger.exception("Upload file failed: %s", str(e))
-            return None
+            raise e
+
+    async def _upload_video(self, video: Video) -> None | Attach:
+        try:
+            self.logger.info("Uploading video")
+            payload = UploadPayload().model_dump(by_alias=True)
+            data = await self._send_and_wait(
+                opcode=Opcode.VIDEO_UPLOAD,
+                payload=payload,
+            )
+
+            if data.get("payload", {}).get("error"):
+                MixinsUtils.handle_error(data)
+
+            url = data.get("payload", {}).get("info", [None])[0].get("url", None)
+            video_id = (
+                data.get("payload", {}).get("info", [None])[0].get("videoId", None)
+            )
+            if not url or not video_id:
+                self.logger.error("No upload URL or video ID received")
+                return None
+
+            token = data.get("payload", {}).get("info", [None])[0].get("token", None)
+            if not token:
+                self.logger.error("No upload token received")
+                return None
+
+            file_bytes = await video.read()
+
+            headers = {
+                "Content-Disposition": f"attachment; filename={video.file_name}",
+                "Content-Range": f"0-{len(file_bytes) - 1}/{len(file_bytes)}",
+            }
+
+            loop = asyncio.get_running_loop()
+            fut: asyncio.Future[dict] = loop.create_future()
+            try:
+                self._file_upload_waiters[int(video_id)] = fut
+            except Exception:
+                self.logger.exception("Failed to register file upload waiter")
+
+            async with (
+                ClientSession() as session,
+                session.post(
+                    url=url,
+                    headers=headers,
+                    data=file_bytes,
+                ) as response,
+            ):
+                if response.status != HTTPStatus.OK:
+                    self.logger.error(f"Upload failed with status {response.status}")
+                    self._file_upload_waiters.pop(int(video_id), None)
+                    return None
+
+                try:
+                    await asyncio.wait_for(fut, timeout=DEFAULT_TIMEOUT)
+                    return Attach(
+                        _type=AttachType.VIDEO, video_id=video_id, token=token
+                    )
+                except asyncio.TimeoutError:
+                    self.logger.error(
+                        "Timed out waiting for video processing notification for videoId=%s",
+                        video_id,
+                    )
+                    self._file_upload_waiters.pop(int(video_id), None)
+                    return None
+
+        except Exception as e:
+            self.logger.exception("Upload video failed: %s", str(e))
+            raise e
 
     async def _upload_photo(self, photo: Photo) -> None | Attach:
         try:
@@ -137,7 +208,7 @@ class MessageMixin(ClientProtocol):
                     data=form,
                 ) as response,
             ):
-                if response.status != 200:
+                if response.status != HTTPStatus.OK:
                     self.logger.error(f"Upload failed with status {response.status}")
                     return None
 
@@ -161,7 +232,7 @@ class MessageMixin(ClientProtocol):
             self.logger.exception("Upload photo failed: %s", str(e))
             return None
 
-    async def _upload_attachment(self, attach: Photo | File) -> dict | None:
+    async def _upload_attachment(self, attach: Photo | File | Video) -> dict | None:
         if isinstance(attach, Photo):
             uploaded = await self._upload_photo(attach)
             if uploaded and uploaded.photo_token:
@@ -174,6 +245,12 @@ class MessageMixin(ClientProtocol):
                 return AttachFilePayload(file_id=uploaded.file_id).model_dump(
                     by_alias=True
                 )
+        elif isinstance(attach, Video):
+            uploaded = await self._upload_video(attach)
+            if uploaded and uploaded.video_id and uploaded.token:
+                return VideoAttachPayload(
+                    video_id=uploaded.video_id, token=uploaded.token
+                ).model_dump(by_alias=True)
         self.logger.error(f"Attachment upload failed for {attach}")
         return None
 
@@ -181,9 +258,9 @@ class MessageMixin(ClientProtocol):
         self,
         text: str,
         chat_id: int,
-        notify: bool,
-        attachment: Photo | File | None = None,
-        attachments: list[Photo | File] | None = None,
+        notify: bool = True,
+        attachment: Photo | File | Video | None = None,
+        attachments: list[Photo | File | Video] | None = None,
         reply_to: int | None = None,
         use_queue: bool = False,
     ) -> Message | None:
@@ -268,8 +345,8 @@ class MessageMixin(ClientProtocol):
         chat_id: int,
         message_id: int,
         text: str,
-        attachment: Photo | None = None,
-        attachments: list[Photo] | None = None,
+        attachment: Photo | File | Video | None = None,
+        attachments: list[Photo | Video | File] | None = None,
         use_queue: bool = False,
     ) -> Message | None:
         self.logger.info(
@@ -480,7 +557,7 @@ class MessageMixin(ClientProtocol):
                 video_id=video_id,
             ).model_dump(by_alias=True)
 
-            data = await self._send_and_wait(opcode=Opcode.VIDEO_PLAY, payload=payload)
+        data = await self._send_and_wait(opcode=Opcode.VIDEO_PLAY, payload=payload)
 
         if data.get("payload", {}).get("error"):
             MixinsUtils.handle_error(data)

pymax/mixins/self.py

@@ -1,8 +1,18 @@
+from typing import Any
+from uuid import uuid4
+
 from pymax.exceptions import Error
 from pymax.interfaces import ClientProtocol
 from pymax.mixins.utils import MixinsUtils
-from pymax.payloads import ChangeProfilePayload
+from pymax.payloads import (
+    ChangeProfilePayload,
+    CreateFolderPayload,
+    DeleteFolderPayload,
+    GetFolderPayload,
+    UpdateFolderPayload,
+)
 from pymax.static.enum import Opcode
+from pymax.types import Folder, FolderList, FolderUpdate
 
 
 class SelfMixin(ClientProtocol):
@@ -39,3 +49,107 @@ class SelfMixin(ClientProtocol):
             MixinsUtils.handle_error(data)
 
         return True
+
+    async def create_folder(
+        self, title: str, chat_include: list[int], filters: list[Any] | None = None
+    ) -> FolderUpdate:
+        """
+        Создает папку для чатов
+
+        Args:
+            title (str): Название папки
+            chat_include (list[int]): Список ID чатов для включения в папку
+            filters (list[Any] | None, optional): Список фильтров для папки (Неизвестный параметр, использование на свой страх и риск)
+
+        Returns:
+            bool: True, если папка создана
+        """
+        self.logger.info("Creating folder")
+
+        payload = CreateFolderPayload(
+            id=str(uuid4()),
+            title=title,
+            include=chat_include,
+            filters=filters or [],
+        ).model_dump(by_alias=True)
+
+        data = await self._send_and_wait(opcode=Opcode.FOLDERS_UPDATE, payload=payload)
+
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
+
+        return FolderUpdate.from_dict(data.get("payload", {}))
+
+    async def get_folders(self, folder_sync: int = 0) -> FolderList:
+        """
+        Получает список папок
+        Args:
+            folder_sync (int, optional): Синхронизационный маркер папок. По умолчанию 0. (Неизвестный параметр, использование на свой страх и риск)
+        Returns:
+            FolderList: Список папок
+        """
+        self.logger.info("Fetching folders")
+
+        payload = GetFolderPayload(folder_sync=folder_sync).model_dump(by_alias=True)
+
+        data = await self._send_and_wait(opcode=Opcode.FOLDERS_GET, payload=payload)
+
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
+
+        return FolderList.from_dict(data.get("payload", {}))
+
+    async def update_folder(
+        self,
+        folder_id: str,
+        title: str,
+        chat_include: list[int] | None = None,
+        filters: list[Any] | None = None,
+        options: list[Any] | None = None,
+    ):
+        """
+        Обновляет папку для чатов
+
+        Args:
+            folder_id (str): ID папки
+            title (str): Название папки
+            chat_include (list[int] | None, optional): Список ID чатов для включения в папку. По умолчанию None.
+            filters (list[Any] | None, optional): Список фильтров для папки. По умолчанию None.
+            options (list[Any] | None, optional): Список опций для папки. По умолчанию None.
+        Returns:
+        """
+        self.logger.info("Updating folder")
+
+        payload = UpdateFolderPayload(
+            id=folder_id,
+            title=title,
+            include=chat_include or [],
+            filters=filters or [],
+            options=options or [],
+        ).model_dump(by_alias=True, exclude_none=True)
+
+        data = await self._send_and_wait(opcode=Opcode.FOLDERS_UPDATE, payload=payload)
+
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
+
+        return FolderUpdate.from_dict(data.get("payload", {}))
+
+    async def delete_folder(self, folder_id: str) -> FolderUpdate:
+        """
+        Удаляет папку для чатов
+
+        Args:
+            folder_id (str): ID папки
+
+        Returns:
+            bool: True, если папка удалена
+        """
+        self.logger.info("Deleting folder")
+
+        payload = DeleteFolderPayload(folder_ids=[folder_id]).model_dump(by_alias=True)
+        data = await self._send_and_wait(opcode=Opcode.FOLDERS_DELETE, payload=payload)
+        if data.get("payload", {}).get("error"):
+            MixinsUtils.handle_error(data)
+
+        return FolderUpdate.from_dict(data.get("payload", {}))

pymax/mixins/socket.py

@@ -92,37 +92,33 @@ class SocketMixin(ClientProtocol):
         payload_len_b = payload_len.to_bytes(4, "big")
         return ver_b + cmd_b + seq_b + opcode_b + payload_len_b + payload_bytes
 
-    async def _connect(self, user_agent: UserAgentPayload) -> dict[str, Any]:
-        try:
-            if sys.version_info[:2] == (3, 12):
-                self.logger.warning(
-                    """
+    async def connect(self, user_agent: UserAgentPayload) -> dict[str, Any]:
+        if sys.version_info[:2] == (3, 12):
+            self.logger.warning(
+                """
 ===============================================================
          ⚠️⚠️ \033[0;31mWARNING: Python 3.12 detected!\033[0m ⚠️⚠️
 Socket connections may be unstable, SSL issues are possible.
 ===============================================================
     """
-                )
-            self.logger.info("Connecting to socket %s:%s", self.host, self.port)
-            loop = asyncio.get_running_loop()
-            raw_sock = await loop.run_in_executor(
-                None, lambda: socket.create_connection((self.host, self.port))
             )
-            self._socket = self._ssl_context.wrap_socket(
-                raw_sock, server_hostname=self.host
-            )
-            self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-            self.is_connected = True
-            self._incoming = asyncio.Queue()
-            self._outgoing = asyncio.Queue()
-            self._pending = {}
-            self._recv_task = asyncio.create_task(self._recv_loop())
-            self._outgoing_task = asyncio.create_task(self._outgoing_loop())
-            self.logger.info("Socket connected, starting handshake")
-            return await self._handshake(user_agent)
-        except Exception as e:
-            self.logger.error("Failed to connect: %s", e, exc_info=True)
-            raise ConnectionError(f"Failed to connect: {e}")
+        self.logger.info("Connecting to socket %s:%s", self.host, self.port)
+        loop = asyncio.get_running_loop()
+        raw_sock = await loop.run_in_executor(
+            None, lambda: socket.create_connection((self.host, self.port))
+        )
+        self._socket = self._ssl_context.wrap_socket(
+            raw_sock, server_hostname=self.host
+        )
+        self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+        self.is_connected = True
+        self._incoming = asyncio.Queue()
+        self._outgoing = asyncio.Queue()
+        self._pending = {}
+        self._recv_task = asyncio.create_task(self._recv_loop())
+        self._outgoing_task = asyncio.create_task(self._outgoing_loop())
+        self.logger.info("Socket connected, starting handshake")
+        return await self._handshake(user_agent)
 
     async def _handshake(self, user_agent: UserAgentPayload) -> dict[str, Any]:
         try:
@@ -345,6 +341,35 @@ Socket connections may be unstable, SSL issues are possible.
                                 self.logger.exception(
                                     "Error in on_chat_update_handler: %s", e
                                 )
+
+                        try:  # TODO: переделать, временное решение
+                            if data_item.get("opcode") == Opcode.NOTIF_ATTACH:
+                                file_id = data_item.get("payload", {}).get(
+                                    "fileId", None
+                                )
+                                video_id = data_item.get("payload", {}).get(
+                                    "videoId", None
+                                )
+                                if file_id is not None:
+                                    fut = self._file_upload_waiters.pop(file_id, None)
+                                    if fut and not fut.done():
+                                        fut.set_result(data)
+                                        self.logger.debug(
+                                            "Fulfilled file upload waiter for fileId=%s",
+                                            file_id,
+                                        )
+                                elif video_id is not None:
+                                    fut = self._file_upload_waiters.pop(video_id, None)
+                                    if fut and not fut.done():
+                                        fut.set_result(data)
+                                        self.logger.debug(
+                                            "Fulfilled file upload waiter for videoId=%s",
+                                            video_id,
+                                        )
+                        except Exception:
+                            self.logger.exception(
+                                "Error handling file upload notification"
+                            )
                 except asyncio.CancelledError:
                     self.logger.debug("Recv loop cancelled")
                     break
@@ -396,6 +421,7 @@ Socket connections may be unstable, SSL issues are possible.
     ) -> dict[str, Any]:
         self._seq += 1
         msg = BaseWebSocketMessage(
+            ver=10,
             cmd=cmd,
             seq=self._seq,
             opcode=opcode.value,
@@ -416,6 +442,7 @@ Socket connections may be unstable, SSL issues are possible.
     ) -> dict[str, Any]:
         if not self.is_connected or self._socket is None:
             raise SocketNotConnectedError
+
         sock = self.sock
         msg = self._make_message(opcode, payload, cmd)
         loop = asyncio.get_running_loop()
@@ -448,7 +475,7 @@ Socket connections may be unstable, SSL issues are possible.
             self.logger.warning("Connection lost, reconnecting...")
             self.is_connected = False
             try:
-                await self._connect(self.user_agent)
+                await self.connect(self.user_agent)
             except Exception as exc:
                 self.logger.exception("Reconnect failed")
                 raise exc from conn_err

pymax/mixins/websocket.py

@@ -167,7 +167,8 @@ class WebSocketMixin(ClientProtocol):
                     try:  # TODO: переделать, временное решение
                         if data.get("opcode") == Opcode.NOTIF_ATTACH:
                             file_id = data.get("payload", {}).get("fileId", None)
-                            if isinstance(file_id, int):
+                            video_id = data.get("payload", {}).get("videoId", None)
+                            if file_id is not None:
                                 fut = self._file_upload_waiters.pop(file_id, None)
                                 if fut and not fut.done():
                                     fut.set_result(data)
@@ -175,6 +176,14 @@ class WebSocketMixin(ClientProtocol):
                                         "Fulfilled file upload waiter for fileId=%s",
                                         file_id,
                                     )
+                            elif video_id is not None:
+                                fut = self._file_upload_waiters.pop(video_id, None)
+                                if fut and not fut.done():
+                                    fut.set_result(data)
+                                    self.logger.debug(
+                                        "Fulfilled file upload waiter for videoId=%s",
+                                        video_id,
+                                    )
                     except Exception:
                         self.logger.exception("Error handling file upload notification")
 

pymax/payloads.py

@@ -73,6 +73,12 @@ class AttachPhotoPayload(CamelModel):
     photo_token: str
 
 
+class VideoAttachPayload(CamelModel):
+    type: AttachType = Field(default=AttachType.VIDEO, alias="_type")
+    video_id: int
+    token: str
+
+
 class AttachFilePayload(CamelModel):
     type: AttachType = Field(default=AttachType.FILE, alias="_type")
     file_id: int
@@ -88,7 +94,7 @@ class SendMessagePayloadMessage(CamelModel):
     text: str
     cid: int
     elements: list[MessageElement]
-    attaches: list[AttachPhotoPayload | AttachFilePayload]
+    attaches: list[AttachPhotoPayload | AttachFilePayload | VideoAttachPayload]
     link: ReplyLink | None = None
 
 
@@ -103,7 +109,7 @@ class EditMessagePayload(CamelModel):
     message_id: int
     text: str
     elements: list[MessageElement]
-    attaches: list[AttachPhotoPayload]
+    attaches: list[AttachPhotoPayload | AttachFilePayload | VideoAttachPayload]
 
 
 class DeleteMessagePayload(CamelModel):
@@ -196,7 +202,7 @@ class ChangeGroupProfilePayload(CamelModel):
 
 class GetGroupMembersPayload(CamelModel):
     type: Literal["MEMBER"] = "MEMBER"
-    marker: int
+    marker: int | None = None
     chat_id: int
     count: int
 
@@ -295,3 +301,30 @@ class RegisterPayload(CamelModel):
     first_name: str
     token: str
     token_type: AuthType = AuthType.REGISTER
+
+
+class CreateFolderPayload(CamelModel):
+    id: str
+    title: str
+    include: list[int]
+    filters: list[Any] = []
+
+
+class GetChatInfoPayload(CamelModel):
+    chat_ids: list[int]
+
+
+class GetFolderPayload(CamelModel):
+    folder_sync: int = 0
+
+
+class UpdateFolderPayload(CamelModel):
+    id: str
+    title: str
+    include: list[int]
+    filters: list[Any] = []
+    options: list[Any] = []
+
+
+class DeleteFolderPayload(CamelModel):
+    folder_ids: list[str]

pymax/static/enum.py

@@ -17,7 +17,6 @@ class Opcode(int, Enum):
     AUTH_CONFIRM = 23
     PRESET_AVATARS = 25
     ASSETS_GET = 26
-    UNKNOWN_26 = 26
     ASSETS_UPDATE = 27
     ASSETS_GET_BY_IDS = 28
     ASSETS_ADD = 29

pymax/types.py

@@ -1,6 +1,6 @@
-from typing import Any, Self
+from typing import Any
 
-from typing_extensions import override
+from typing_extensions import Self, override
 
 from .static.enum import (
     AccessType,
@@ -1052,3 +1052,115 @@ class Session:
     @override
     def __str__(self) -> str:
         return f"Session: {self.client} from {self.location} at {self.time} (current={self.current})"
+
+
+class Folder:
+    def __init__(
+        self,
+        source_id: int,
+        include: list[int],
+        options: list[Any],
+        update_time: int,
+        id: str,
+        filters: list[Any],
+        title: str,
+    ) -> None:
+        self.source_id = source_id
+        self.include = include
+        self.options = options
+        self.update_time = update_time
+        self.id = id
+        self.filters = filters
+        self.title = title
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        return cls(
+            source_id=data.get("sourceId", 0),
+            include=data.get("include", []),
+            options=data.get("options", []),
+            update_time=data.get("updateTime", 0),
+            id=data.get("id", ""),
+            filters=data.get("filters", []),
+            title=data.get("title", ""),
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"Folder(id={self.id!r}, title={self.title!r}, source_id={self.source_id!r}, "
+            f"include={self.include!r}, options={self.options!r}, "
+            f"update_time={self.update_time!r}, filters={self.filters!r})"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"Folder: {self.title} ({self.id})"
+
+
+class FolderUpdate:
+    def __init__(
+        self, folder_order: list[str] | None, folder: Folder | None, folder_sync: int
+    ) -> None:
+        self.folder_order = folder_order
+        self.folder = folder
+        self.folder_sync = folder_sync
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        folder_order = data.get("foldersOrder", [])
+        folder_sync = data.get("folderSync", 0)
+        folder_data = data.get("folder", {})
+        folder = Folder.from_dict(folder_data)
+        return cls(
+            folder_order=folder_order,
+            folder=folder,
+            folder_sync=folder_sync,
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"FolderUpdate(folder_order={self.folder_order!r}, "
+            f"folder={self.folder!r}, folder_sync={self.folder_sync!r})"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"FolderUpdate: {self.folder.title} ({self.folder.id})"
+
+
+class FolderList:
+    def __init__(
+        self,
+        folders_order: list[str],
+        folders: list[Folder],
+        folder_sync: int,
+        all_filter_exclude_folders: list[Any] | None = None,
+    ) -> None:
+        self.folders_order = folders_order
+        self.folders = folders
+        self.all_filter_exclude_folders = all_filter_exclude_folders or []
+        self.folder_sync = folder_sync
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        return cls(
+            folders_order=data.get("foldersOrder", []),
+            folders=[Folder.from_dict(f) for f in data.get("folders", [])],
+            all_filter_exclude_folders=data.get("allFilterExcludeFolders", []),
+            folder_sync=data.get("folderSync", 0),
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"FolderList(folders_order={self.folders_order!r}, "
+            f"folders={self.folders!r}, "
+            f"all_filter_exclude_folders={self.all_filter_exclude_folders!r}, "
+            f"folder_sync={self.folder_sync!r})"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"FolderList: {len(self.folders)} folders"

maxapi_python-1.1.19.dist-info/RECORD

@@ -1,31 +0,0 @@
-pymax/__init__.py,sha256=6wUKKwsyxFpWG3b7kwptOvHd-w78C-ygw42iCDBYQvc,1915
-pymax/core.py,sha256=QEERtU32ODmEIf1XFCDhD18a29yRW5TB97NjtusMUCg,15644
-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=OqYTiTUs6HqTkx3I3CU34q-En8nLS1Rx2hRlmEq65V4,3643
-pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
-pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
-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=zkMkALjvb2427g1DMcvUIKsOQgw1y8d-tEo3jlyNiWQ,6744
-pymax/mixins/channel.py,sha256=dMuJRnbqZisN8kcPFCCe1sIOOBQl2uT4P49PpZXcoKE,5206
-pymax/mixins/group.py,sha256=7oa7RpiqnlcnAsnIHOfSiujNYAzUZ9lkTy9NGW5KVUE,8654
-pymax/mixins/handler.py,sha256=TuO5bHK6qwJ-Wdh3lMg6uWaG6IwNPOUTCnMw2PkCFjA,5872
-pymax/mixins/message.py,sha256=ezU9d6r4MkYjH67gZ9SFLYPKqo4Nb6lswqDsEW5p-Bg,22329
-pymax/mixins/self.py,sha256=tDQrUdUpsCu7qGkWLtKxTfTHPHU5_r3qsn-eptHG2KY,1198
-pymax/mixins/socket.py,sha256=VsQSDyzP2xvQp-V8SgeOBn3vVQfWwi0m_wMIvlzu2lY,25517
-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=Rfn3PFfmey2u3e3xnebNeT9VoxBF9Dq20xM8ljaDiII,19286
-pymax/static/constant.py,sha256=Q1NrmaRj17Gdhk3FmUp3HIwrad1TDorq3wFdQlOCzN8,1027
-pymax/static/enum.py,sha256=c_QaLU0Ephe4SuKFIpwpmrf_HCutc34JJ6o4Ik1E6_g,4582
-maxapi_python-1.1.19.dist-info/METADATA,sha256=2tRU1Um8ZR6LHzm83ze-bWs0V5FI6ru6DNYHbi4JBw8,6245
-maxapi_python-1.1.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-maxapi_python-1.1.19.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
-maxapi_python-1.1.19.dist-info/RECORD,,