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

pymax/mixins/user.py

@@ -15,13 +15,15 @@ from pymax.types import Contact, Session, User
 class UserMixin(ClientProtocol):
     def get_cached_user(self, user_id: int) -> User | None:
         """
-        Получает юзера из кеша по его ID
+        Получает пользователя из кеша по его идентификатору.
 
-        Args:
-            user_id (int): ID пользователя.
+        Проверяет внутренний кеш пользователей и возвращает объект User
+        если пользователь был ранее загружен.
 
-        Returns:
-            User | None: Объект User или None при ошибке.
+        :param user_id: Идентификатор пользователя.
+        :type user_id: int
+        :return: Объект User из кеша или None, если пользователь не найден.
+        :rtype: User | None
         """
         user = self._users.get(user_id)
         self.logger.debug("get_cached_user id=%s hit=%s", user_id, bool(user))
@@ -29,7 +31,16 @@ class UserMixin(ClientProtocol):
 
     async def get_users(self, user_ids: list[int]) -> list[User]:
         """
-        Получает информацию о пользователях по их ID (с кешем).
+        Получает информацию о пользователях по их идентификаторам.
+
+        Метод использует внутренний кеш для избежания повторных запросов.
+        Если пользователь уже загружен, берется из кеша, иначе выполняется
+        сетевой запрос к серверу.
+
+        :param user_ids: Список идентификаторов пользователей.
+        :type user_ids: list[int]
+        :return: Список объектов User в порядке, соответствующем входному списку.
+        :rtype: list[User]
         """
         self.logger.debug("get_users ids=%s", user_ids)
         cached = {uid: self._users[uid] for uid in user_ids if uid in self._users}
@@ -49,7 +60,15 @@ class UserMixin(ClientProtocol):
 
     async def get_user(self, user_id: int) -> User | None:
         """
-        Получает информацию о пользователе по его ID (с кешем).
+        Получает информацию о пользователе по его идентификатору.
+
+        Метод использует внутренний кеш. Если пользователь уже загружен,
+        возвращает его из кеша, иначе выполняет запрос к серверу.
+
+        :param user_id: Идентификатор пользователя.
+        :type user_id: int
+        :return: Объект User или None, если пользователь не найден.
+        :rtype: User | None
         """
         self.logger.debug("get_user id=%s", user_id)
         if user_id in self._users:
@@ -63,7 +82,15 @@ class UserMixin(ClientProtocol):
 
     async def fetch_users(self, user_ids: list[int]) -> list[User]:
         """
-        Получает информацию о пользователях по их ID.
+        Загружает информацию о пользователях с сервера.
+
+        Запрашивает данные о пользователях по их идентификаторам и добавляет
+        их в внутренний кеш.
+
+        :param user_ids: Список идентификаторов пользователей для загрузки.
+        :type user_ids: list[int]
+        :return: Список загруженных объектов User.
+        :rtype: list[User]
         """
         self.logger.info("Fetching users count=%d", len(user_ids))
 
@@ -83,13 +110,13 @@ class UserMixin(ClientProtocol):
 
     async def search_by_phone(self, phone: str) -> User:
         """
-        Ищет пользователя по номеру телефона.
+        Выполняет поиск пользователя по номеру телефона.
 
-        Args:
-            phone (str): Номер телефона.
-
-        Returns:
-            User: Объект User.
+        :param phone: Номер телефона пользователя.
+        :type phone: str
+        :return: Объект User с найденными данными пользователя.
+        :rtype: User
+        :raises Error: Если пользователь не найден или произошла ошибка.
         """
         self.logger.info("Searching user by phone: %s", phone)
 
@@ -115,10 +142,13 @@ class UserMixin(ClientProtocol):
 
     async def get_sessions(self) -> list[Session]:
         """
-        Получает информацию о сессиях.
+        Получает информацию о всех активных сессиях пользователя.
+
+        Возвращает список всех сессий, в которых авторизован пользователь.
 
-        Returns:
-            list[Session]: Список объектов Session.
+        :return: Список объектов Session.
+        :rtype: list[Session]
+        :raises Error: Если произошла ошибка при получении данных.
         """
         self.logger.info("Fetching sessions")
 
@@ -133,15 +163,6 @@ class UserMixin(ClientProtocol):
         return [Session.from_dict(s) for s in data["payload"].get("sessions", [])]
 
     async def _contact_action(self, payload: ContactActionPayload) -> dict[str, Any]:
-        """
-        Действия с контактом
-
-        Args:
-            payload (ContactActionPayload): Полезная нагрузка
-
-        Return:
-            Полезная нагрузка ответа
-        """
         data = await self._send_and_wait(
             opcode=Opcode.CONTACT_UPDATE,  # 34
             payload=payload.model_dump(by_alias=True),
@@ -157,11 +178,11 @@ class UserMixin(ClientProtocol):
         """
         Добавляет контакт в список контактов
 
-        Args:
-            contact_id (int): ID контакта
-
-        Returns:
-            Contact: Объект контакта, иначе будут выброшены исключения
+        :param contact_id: ID контакта
+        :type contact_id: int
+        :return: Объект контакта
+        :rtype: Contact
+        :raises ResponseStructureError: Если структура ответа неверна
         """
         payload = await self._contact_action(
             ContactActionPayload(contact_id=contact_id, action=ContactAction.ADD)
@@ -175,11 +196,11 @@ class UserMixin(ClientProtocol):
         """
         Удаляет контакт из списка контактов
 
-        Args:
-            contact_id (int): ID контакта
-
-        Returns:
-            True если успешно, иначе будут выброшены исключения
+        :param contact_id: ID контакта
+        :type contact_id: int
+        :return: True если успешно
+        :rtype: Literal[True]
+        :raises ResponseStructureError: Если структура ответа неверна
         """
         await self._contact_action(
             ContactActionPayload(contact_id=contact_id, action=ContactAction.REMOVE)
@@ -190,11 +211,11 @@ class UserMixin(ClientProtocol):
         """
         Получение айди лс (диалога)
 
-        Args:
-            first_user_id (int): ID первого пользователя
-            second_user_id (int): ID второго пользователя
-
-        Returns:
-            int: Айди диалога
+        :param first_user_id: ID первого пользователя
+        :type first_user_id: int
+        :param second_user_id: ID второго пользователя
+        :type second_user_id: int
+        :return: Айди диалога
+        :rtype: int
         """
         return first_user_id ^ second_user_id

pymax/mixins/websocket.py

@@ -8,7 +8,7 @@ import websockets
 from typing_extensions import override
 
 from pymax.exceptions import LoginError, WebSocketNotConnectedError
-from pymax.filters import Filter
+from pymax.filters import BaseFilter
 from pymax.interfaces import ClientProtocol
 from pymax.mixins.utils import MixinsUtils
 from pymax.payloads import BaseWebSocketMessage, SyncPayload, UserAgentPayload
@@ -73,6 +73,11 @@ class WebSocketMixin(ClientProtocol):
     ) -> dict[str, Any] | None:
         """
         Устанавливает соединение WebSocket с сервером и выполняет handshake.
+
+        :param user_agent: Пользовательский агент для handshake. Если None, используется значение по умолчанию.
+        :type user_agent: UserAgentPayload | None
+        :return: Результат handshake.
+        :rtype: dict[str, Any] | None
         """
         if user_agent is None:
             user_agent = UserAgentPayload()
@@ -101,14 +106,13 @@ class WebSocketMixin(ClientProtocol):
     async def _handshake(self, user_agent: UserAgentPayload) -> dict[str, Any]:
         self.logger.debug(
             "Sending handshake with user_agent keys=%s",
-            user_agent.model_dump().keys(),
+            user_agent.model_dump(by_alias=True).keys(),
         )
+
+        user_agent_json = user_agent.model_dump(by_alias=True)
         resp = await self._send_and_wait(
             opcode=Opcode.SESSION_INIT,
-            payload={
-                "deviceId": str(self._device_id),
-                "userAgent": user_agent,  # TODO: вынести в статик мб
-            },
+            payload={"deviceId": str(self._device_id), "userAgent": user_agent_json},
         )
 
         if resp.get("payload", {}).get("error"):
@@ -120,12 +124,12 @@ class WebSocketMixin(ClientProtocol):
     async def _process_message_handler(
         self,
         handler: Callable[[Message], Any],
-        filter: Filter | None,
+        filter: BaseFilter[Message] | None,
         message: Message,
     ):
         result = None
         if filter:
-            if filter.match(message):
+            if filter(message):
                 result = handler(message)
             else:
                 return
@@ -134,6 +138,126 @@ class WebSocketMixin(ClientProtocol):
         if asyncio.iscoroutine(result):
             self._create_safe_task(result, name=f"handler-{handler.__name__}")
 
+    def _parse_json(self, raw: Any) -> dict[str, Any] | None:
+        try:
+            return json.loads(raw)
+        except Exception:
+            self.logger.warning("JSON parse error", exc_info=True)
+            return None
+
+    def _handle_pending(self, seq: int | None, data: dict) -> bool:
+        if isinstance(seq, int):
+            fut = self._pending.get(seq)
+            if fut and not fut.done():
+                fut.set_result(data)
+                self.logger.debug("Matched response for pending seq=%s", seq)
+                return True
+        return False
+
+    async def _handle_incoming_queue(self, data: dict[str, Any]) -> None:
+        if self._incoming:
+            try:
+                self._incoming.put_nowait(data)
+            except asyncio.QueueFull:
+                self.logger.warning(
+                    "Incoming queue full; dropping message seq=%s", data.get("seq")
+                )
+
+    async def _handle_file_upload(self, data: dict[str, Any]) -> None:
+        if data.get("opcode") != Opcode.NOTIF_ATTACH:
+            return
+        payload = data.get("payload", {})
+        for key in ("fileId", "videoId"):
+            id_ = payload.get(key)
+            if id_ is not None:
+                fut = self._file_upload_waiters.pop(id_, None)
+                if fut and not fut.done():
+                    fut.set_result(data)
+                    self.logger.debug(
+                        "Fulfilled file upload waiter for %s=%s", key, id_
+                    )
+
+    async def _handle_message_notifications(self, data: dict) -> None:
+        if data.get("opcode") != Opcode.NOTIF_MESSAGE.value:
+            return
+        payload = data.get("payload", {})
+        msg = Message.from_dict(payload)
+        if not msg:
+            return
+        handlers_map = {
+            MessageStatus.EDITED: self._on_message_edit_handlers,
+            MessageStatus.REMOVED: self._on_message_delete_handlers,
+        }
+        if msg.status and msg.status in handlers_map:
+            for handler, filter in handlers_map[msg.status]:
+                await self._process_message_handler(handler, filter, msg)
+        if msg.status is None:
+            for handler, filter in self._on_message_handlers:
+                await self._process_message_handler(handler, filter, msg)
+
+    async def _handle_reactions(self, data: dict):
+        if data.get("opcode") != Opcode.NOTIF_MSG_REACTIONS_CHANGED:
+            return
+
+        payload = data.get("payload", {})
+        chat_id = payload.get("chatId")
+        message_id = payload.get("messageId")
+
+        if not (chat_id and message_id):
+            return
+
+        total_count = payload.get("totalCount")
+        your_reaction = payload.get("yourReaction")
+        counters = [ReactionCounter.from_dict(c) for c in payload.get("counters", [])]
+
+        reaction_info = ReactionInfo(
+            total_count=total_count,
+            your_reaction=your_reaction,
+            counters=counters,
+        )
+
+        for handler in self._on_reaction_change_handlers:
+            try:
+                result = handler(message_id, chat_id, reaction_info)
+                if asyncio.iscoroutine(result):
+                    await result
+            except Exception as e:
+                self.logger.exception("Error in on_reaction_change_handler: %s", e)
+
+    async def _handle_chat_updates(self, data: dict) -> None:
+        if data.get("opcode") != Opcode.NOTIF_CHAT:
+            return
+
+        payload = data.get("payload", {})
+        chat_data = payload.get("chat", {})
+        chat = Chat.from_dict(chat_data)
+        if not chat:
+            return
+
+        for handler in self._on_chat_update_handlers:
+            try:
+                result = handler(chat)
+                if asyncio.iscoroutine(result):
+                    await result
+            except Exception as e:
+                self.logger.exception("Error in on_chat_update_handler: %s", e)
+
+    async def _handle_raw_receive(self, data: dict[str, Any]) -> None:
+        for handler in self._on_raw_receive_handlers:
+            try:
+                result = handler(data)
+                if asyncio.iscoroutine(result):
+                    await result
+            except Exception as e:
+                self.logger.exception("Error in on_raw_receive_handler: %s", e)
+
+    async def _dispatch_incoming(self, data: dict[str, Any]) -> None:
+        await self._handle_raw_receive(data)
+        await self._handle_file_upload(data)
+        await self._handle_message_notifications(data)
+        await self._handle_reactions(data)
+        await self._handle_chat_updates(data)
+
     async def _recv_loop(self) -> None:
         if self._ws is None:
             self.logger.warning("Recv loop started without websocket instance")
@@ -143,145 +267,22 @@ class WebSocketMixin(ClientProtocol):
         while True:
             try:
                 raw = await self._ws.recv()
-                try:
-                    data = json.loads(raw)
-                except Exception:
-                    self.logger.warning("JSON parse error", exc_info=True)
+                data = self._parse_json(raw)
+
+                if data is None:
                     continue
+
                 seq = data.get("seq")
-                fut = self._pending.get(seq) if isinstance(seq, int) else None
+                if self._handle_pending(seq, data):
+                    continue
 
-                if fut and not fut.done():
-                    fut.set_result(data)
-                    self.logger.debug("Matched response for pending seq=%s", seq)
-                else:
-                    if self._incoming is not None:
-                        try:
-                            self._incoming.put_nowait(data)
-                        except asyncio.QueueFull:
-                            self.logger.warning(
-                                "Incoming queue full; dropping message seq=%s",
-                                data.get("seq"),
-                            )
-
-                    try:  # TODO: переделать, временное решение
-                        if data.get("opcode") == Opcode.NOTIF_ATTACH:
-                            file_id = data.get("payload", {}).get("fileId", None)
-                            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)
-                                    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")
-
-                    if data.get("opcode") == Opcode.NOTIF_MESSAGE.value and (
-                        self._on_message_handlers
-                        or self._on_message_edit_handlers
-                        or self._on_message_delete_handlers
-                    ):
-                        try:
-                            for handler, filter in self._on_message_handlers:
-                                payload = data.get("payload", {})
-                                msg = Message.from_dict(payload)
-                                if msg:
-                                    if msg.status:
-                                        if msg.status == MessageStatus.EDITED:
-                                            for (
-                                                edit_handler,
-                                                edit_filter,
-                                            ) in self._on_message_edit_handlers:
-                                                await self._process_message_handler(
-                                                    edit_handler,
-                                                    edit_filter,
-                                                    msg,
-                                                )
-                                        elif msg.status == MessageStatus.REMOVED:
-                                            for (
-                                                remove_handler,
-                                                remove_filter,
-                                            ) in self._on_message_delete_handlers:
-                                                await self._process_message_handler(
-                                                    remove_handler,
-                                                    remove_filter,
-                                                    msg,
-                                                )
-                                    await self._process_message_handler(
-                                        handler, filter, msg
-                                    )
-                        except Exception:
-                            self.logger.exception("Error in on_message_handler")
-
-                    if data.get("opcode") == Opcode.NOTIF_MSG_REACTIONS_CHANGED:
-                        try:
-                            for (
-                                reaction_handler,
-                            ) in self._on_reaction_change_handlers:
-                                payload = data.get("payload", {})
-
-                                chat_id = payload.get("chatId")
-                                message_id = payload.get("messageId")
-
-                                total_count = payload.get("totalCount")
-                                your_reaction = payload.get("yourReaction")
-                                counters = [
-                                    ReactionCounter.from_dict(c)
-                                    for c in payload.get("counters", [])
-                                ]
-
-                                if (
-                                    chat_id
-                                    and message_id
-                                    and (
-                                        total_count is not None
-                                        or your_reaction
-                                        or counters
-                                    )
-                                ):
-                                    reaction_info = ReactionInfo(
-                                        total_count=total_count,
-                                        your_reaction=your_reaction,
-                                        counters=counters,
-                                    )
-                                    result = reaction_handler(
-                                        message_id, chat_id, reaction_info
-                                    )
-                                    if asyncio.iscoroutine(result):
-                                        await result
-
-                        except Exception as e:
-                            self.logger.exception(
-                                "Error in on_reaction_change_handler: %s", e
-                            )
-
-                    if data.get("opcode") == Opcode.NOTIF_CHAT:
-                        try:
-                            for (chat_update_handler,) in self._on_chat_update_handlers:
-                                payload = data.get("payload", {})
-                                chat = Chat.from_dict(payload.get("chat", {}))
-                                if chat:
-                                    result = chat_update_handler(chat)
-                                    if asyncio.iscoroutine(result):
-                                        await result
-                        except Exception as e:
-                            self.logger.exception(
-                                "Error in on_chat_update_handler: %s", e
-                            )
-
-            except websockets.exceptions.ConnectionClosed:
-                self.logger.info("WebSocket connection closed; exiting recv loop")
+                await self._handle_incoming_queue(data)
+                await self._dispatch_incoming(data)
+
+            except websockets.exceptions.ConnectionClosed as e:
+                self.logger.info(
+                    f"WebSocket connection closed with error: {e.code}, {e.reason}; exiting recv loop"
+                )
                 for fut in self._pending.values():
                     if not fut.done():
                         fut.set_exception(WebSocketNotConnectedError)
@@ -303,7 +304,6 @@ class WebSocketMixin(ClientProtocol):
             pass
         except Exception as e:
             self.logger.exception("Error retrieving task exception: %s", e)
-            pass
 
     async def _queue_message(
         self,

pymax/payloads.py

@@ -4,6 +4,8 @@ from pydantic import AliasChoices, BaseModel, Field
 
 from pymax.static.constant import (
     DEFAULT_APP_VERSION,
+    DEFAULT_BUILD_NUMBER,
+    DEFAULT_CLIENT_SESSION_ID,
     DEFAULT_DEVICE_LOCALE,
     DEFAULT_DEVICE_NAME,
     DEFAULT_DEVICE_TYPE,
@@ -284,6 +286,8 @@ class UserAgentPayload(CamelModel):
     app_version: str = Field(default=DEFAULT_APP_VERSION)
     screen: str = Field(default=DEFAULT_SCREEN)
     timezone: str = Field(default=DEFAULT_TIMEZONE)
+    client_session_id: int = Field(default=DEFAULT_CLIENT_SESSION_ID)
+    build_number: int = Field(default=DEFAULT_BUILD_NUMBER)
 
 
 class ReworkInviteLinkPayload(CamelModel):
@@ -328,3 +332,11 @@ class UpdateFolderPayload(CamelModel):
 
 class DeleteFolderPayload(CamelModel):
     folder_ids: list[str]
+
+
+class LeaveChatPayload(CamelModel):
+    chat_id: int
+
+
+class FetchChatsPayload(CamelModel):
+    marker: int

pymax/static/constant.py

@@ -8,17 +8,19 @@ WEBSOCKET_URI: Final[str] = "wss://ws-api.oneme.ru/websocket"
 WEBSOCKET_ORIGIN: Final[Origin] = Origin("https://web.max.ru")
 HOST: Final[str] = "api.oneme.ru"
 PORT: Final[int] = 443
-DEFAULT_TIMEOUT: Final[float] = 10.0
+DEFAULT_TIMEOUT: Final[float] = 20.0
 DEFAULT_DEVICE_TYPE: Final[str] = "WEB"
 DEFAULT_LOCALE: Final[str] = "ru"
 DEFAULT_DEVICE_LOCALE: Final[str] = "ru"
 DEFAULT_DEVICE_NAME: Final[str] = "Chrome"
-DEFAULT_APP_VERSION: Final[str] = "25.10.13"
+DEFAULT_APP_VERSION: Final[str] = "25.12.13"
 DEFAULT_SCREEN: Final[str] = "1080x1920 1.0x"
 DEFAULT_OS_VERSION: Final[str] = "Linux"
 DEFAULT_USER_AGENT: Final[str] = (
     "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36"
 )
+DEFAULT_BUILD_NUMBER: Final[int] = 0x97CB
+DEFAULT_CLIENT_SESSION_ID: Final[int] = 14
 DEFAULT_TIMEZONE: Final[str] = "Europe/Moscow"
 DEFAULT_CHAT_MEMBERS_LIMIT: Final[int] = 50
 DEFAULT_MARKER_VALUE: Final[int] = 0

pymax/static/enum.py

@@ -141,6 +141,10 @@ class Opcode(int, Enum):
     FOLDERS_DELETE = 276
     NOTIF_FOLDERS = 277
 
+    GET_QR = 288
+    GET_QR_STATUS = 289
+    LOGIN_BY_QR = 291
+
 
 class ChatType(str, Enum):
     DIALOG = "DIALOG"
@@ -170,6 +174,7 @@ class AuthType(str, Enum):
     START_AUTH = "START_AUTH"
     CHECK_CODE = "CHECK_CODE"
     REGISTER = "REGISTER"
+    RESEND = "RESEND"
 
 
 class AccessType(str, Enum):

maxapi_python-1.1.20.dist-info/RECORD

@@ -1,31 +0,0 @@
-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,,