maxapi-python 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

pymax/mixins/self.py

@@ -0,0 +1,38 @@
+from pymax.interfaces import ClientProtocol
+from pymax.payloads import ChangeProfilePayload
+from pymax.static import Opcode
+
+
+class SelfMixin(ClientProtocol):
+    async def change_profile(
+        self,
+        first_name: str,
+        last_name: str | None = None,
+        description: str | None = None,
+    ) -> bool:
+        """
+        Изменяет профиль
+
+        Args:
+            first_name (str): Имя.
+            last_name (str | None, optional): Фамилия. Defaults to None.
+            description (str | None, optional): Описание. Defaults to None.
+
+        Returns:
+            bool: True, если профиль изменен
+        """
+
+        payload = ChangeProfilePayload(
+            first_name=first_name,
+            last_name=last_name,
+            description=description,
+        ).model_dump(
+            by_alias=True,
+            exclude_none=True,
+        )
+
+        data = await self._send_and_wait(opcode=Opcode.PROFILE, payload=payload)
+        if error := data.get("payload", {}).get("error"):
+            self.logger.error("Change profile error: %s", error)
+            return False
+        return True

pymax/mixins/user.py

@@ -0,0 +1,82 @@
+from pymax.interfaces import ClientProtocol
+from pymax.payloads import FetchContactsPayload
+from pymax.static import Opcode
+from pymax.types import User
+
+
+class UserMixin(ClientProtocol):
+    def get_cached_user(self, user_id: int) -> User | None:
+        """
+        Получает юзера из кеша по его ID
+
+        Args:
+            user_id (int): ID пользователя.
+
+        Returns:
+            User | None: Объект User или None при ошибке.
+        """
+        user = self._users.get(user_id)
+        self.logger.debug("get_cached_user id=%s hit=%s", user_id, bool(user))
+        return user
+
+    async def get_users(self, user_ids: list[int]) -> list[User]:
+        """
+        Получает информацию о пользователях по их ID (с кешем).
+        """
+        self.logger.debug("get_users ids=%s", user_ids)
+        cached = {uid: self._users[uid] for uid in user_ids if uid in self._users}
+        missing_ids = [uid for uid in user_ids if uid not in self._users]
+
+        if missing_ids:
+            self.logger.debug("Fetching missing users: %s", missing_ids)
+            fetched_users = await self.fetch_users(missing_ids)
+            if fetched_users:
+                for user in fetched_users:
+                    self._users[user.id] = user
+                    cached[user.id] = user
+
+        ordered = [cached[uid] for uid in user_ids if uid in cached]
+        self.logger.debug("get_users result_count=%d", len(ordered))
+        return ordered
+
+    async def get_user(self, user_id: int) -> User | None:
+        """
+        Получает информацию о пользователе по его ID (с кешем).
+        """
+        self.logger.debug("get_user id=%s", user_id)
+        if user_id in self._users:
+            return self._users[user_id]
+
+        users = await self.fetch_users([user_id])
+        if users:
+            self._users[user_id] = users[0]
+            return users[0]
+        return None
+
+    async def fetch_users(self, user_ids: list[int]) -> None | list[User]:
+        """
+        Получает информацию о пользователях по их ID.
+        """
+        try:
+            self.logger.info("Fetching users count=%d", len(user_ids))
+
+            payload = FetchContactsPayload(contact_ids=user_ids).model_dump(
+                by_alias=True
+            )
+
+            data = await self._send_and_wait(
+                opcode=Opcode.CONTACT_INFO, payload=payload
+            )
+            if error := data.get("payload", {}).get("error"):
+                self.logger.error("Fetch users error: %s", error)
+                return None
+
+            users = [User.from_dict(u) for u in data["payload"].get("contacts", [])]
+            for user in users:
+                self._users[user.id] = user
+
+            self.logger.debug("Fetched users: %d", len(users))
+            return users
+        except Exception:
+            self.logger.exception("Fetch users failed")
+            return []

pymax/mixins/websocket.py

@@ -0,0 +1,242 @@
+import asyncio
+import json
+from typing import Any, override
+
+import websockets
+
+from pymax.exceptions import WebSocketNotConnectedError
+from pymax.interfaces import ClientProtocol
+from pymax.payloads import BaseWebSocketMessage, SyncPayload
+from pymax.static import ChatType, Constants, Opcode
+from pymax.types import Channel, Chat, Dialog, Me, Message
+
+
+class WebSocketMixin(ClientProtocol):
+    @property
+    def ws(self) -> websockets.ClientConnection:
+        if self._ws is None or not self.is_connected:
+            self.logger.critical("WebSocket not connected when access attempted")
+            raise WebSocketNotConnectedError
+        return self._ws
+
+    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
+
+    async def _send_interactive_ping(self) -> None:
+        while self.is_connected:
+            try:
+                await self._send_and_wait(
+                    opcode=1,
+                    payload={"interactive": True},
+                    cmd=0,
+                )
+                self.logger.debug("Interactive ping sent successfully")
+            except Exception:
+                self.logger.warning("Interactive ping failed", exc_info=True)
+            await asyncio.sleep(30)
+
+    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.is_connected = True
+            self._incoming = asyncio.Queue()
+            self._pending = {}
+            self._recv_task = asyncio.create_task(self._recv_loop())
+            self.logger.info("WebSocket 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._ws is None:
+            self.logger.warning("Recv loop started without websocket instance")
+            return
+
+        self.logger.debug("Receive loop started")
+        while True:
+            try:
+                raw = await self._ws.recv()
+                try:
+                    data = json.loads(raw)
+                except Exception:
+                    self.logger.warning("JSON parse error", exc_info=True)
+                    continue
+
+                seq = data.get("seq")
+                fut = self._pending.get(seq) if isinstance(seq, int) else None
+
+                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"),
+                            )
+
+                    if (
+                        data.get("opcode") == Opcode.NOTIF_MESSAGE
+                        and self._on_message_handlers
+                    ):
+                        try:
+                            for handler, filter in self._on_message_handlers:
+                                payload = data.get("payload", {})
+                                msg = Message.from_dict(payload.get("message"))
+                                if msg:
+                                    if msg.status:
+                                        continue  # TODO: заглушка! сделать отдельный хендлер
+                                    if filter:
+                                        if filter.match(msg):
+                                            result = handler(msg)
+                                        else:
+                                            continue
+                                    else:
+                                        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 websockets.exceptions.ConnectionClosed:
+                self.logger.info("WebSocket connection closed; exiting recv loop")
+                break
+            except Exception:
+                self.logger.exception("Error in recv_loop; backing off briefly")
+                await asyncio.sleep(0.5)
+
+    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
+
+    @override
+    async def _send_and_wait(
+        self,
+        opcode: int,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = Constants.DEFAULT_TIMEOUT.value,
+    ) -> dict[str, Any]:
+        ws = self.ws
+
+        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"]
+            )
+            await ws.send(json.dumps(msg))
+            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 Exception:
+            self.logger.exception(
+                "Send and wait failed (opcode=%s, seq=%s)", opcode, msg["seq"]
+            )
+            raise RuntimeError("Send and wait failed")
+        finally:
+            self._pending.pop(msg["seq"], None)
+
+    async def _sync(self) -> None:
+        try:
+            self.logger.info("Starting initial sync")
+
+            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=19, 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") == ChatType.DIALOG.value:
+                        self.dialogs.append(Dialog.from_dict(raw_chat))
+                    elif raw_chat.get("type") == ChatType.CHAT.value:
+                        self.chats.append(Chat.from_dict(raw_chat))
+                    elif raw_chat.get("type") == ChatType.CHANNEL.value:
+                        self.channels.append(Channel.from_dict(raw_chat))
+                except Exception:
+                    self.logger.exception("Error parsing chat entry")
+
+            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")
+
+    @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

pymax/models.py

@@ -0,0 +1,8 @@
+from uuid import UUID, uuid4
+
+from sqlmodel import Field, SQLModel
+
+
+class Auth(SQLModel, table=True):
+    token: str | None = None
+    device_id: UUID = Field(default_factory=uuid4, primary_key=True)

pymax/payloads.py

@@ -0,0 +1,175 @@
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+from pymax.static import AttachType, AuthType
+
+
+def to_camel(string: str) -> str:
+    parts = string.split("_")
+    return parts[0] + "".join(word.capitalize() for word in parts[1:])
+
+
+class CamelModel(BaseModel):
+    model_config = {
+        "alias_generator": to_camel,
+        "populate_by_name": True,
+    }
+
+
+class BaseWebSocketMessage(BaseModel):
+    ver: int = 11
+    cmd: int
+    seq: int
+    opcode: int
+    payload: dict[str, Any]
+
+
+class RequestCodePayload(CamelModel):
+    phone: str
+    type: AuthType = AuthType.START_AUTH
+    language: str = "ru"
+
+
+class SendCodePayload(CamelModel):
+    token: str
+    verify_code: str
+    auth_token_type: AuthType = AuthType.CHECK_CODE
+
+
+class SyncPayload(CamelModel):
+    interactive: bool = True
+    token: str
+    chats_sync: int = 0
+    contacts_sync: int = 0
+    presence_sync: int = 0
+    drafts_sync: int = 0
+    chats_count: int = 40
+
+
+class ReplyLink(CamelModel):
+    type: str = "REPLY"
+    message_id: str
+
+
+class UploadPhotoPayload(CamelModel):
+    count: int = 1
+
+
+class AttachPhotoPayload(CamelModel):
+    type: AttachType = Field(AttachType.PHOTO, alias="_type")
+    photo_token: str
+
+
+class SendMessagePayloadMessage(CamelModel):
+    text: str
+    cid: int
+    elements: list[Any]
+    attaches: list[dict[str, Any]]
+    link: ReplyLink | None = None
+
+
+class SendMessagePayload(CamelModel):
+    chat_id: int
+    message: SendMessagePayloadMessage
+    notify: bool = False
+
+
+class EditMessagePayload(CamelModel):
+    chat_id: int
+    message_id: int
+    text: str
+    elements: list[Any]
+    attaches: list[Any]
+
+
+class DeleteMessagePayload(CamelModel):
+    chat_id: int
+    message_ids: list[int]
+    for_me: bool = False
+
+
+class FetchContactsPayload(CamelModel):
+    contact_ids: list[int]
+
+
+class FetchHistoryPayload(CamelModel):
+    chat_id: int
+    from_time: int = Field(alias="from")
+    forward: int
+    backward: int = 200
+    get_messages: bool = True
+
+
+class ChangeProfilePayload(CamelModel):
+    first_name: str
+    last_name: str | None = None
+    description: str | None = None
+
+
+class ResolveLinkPayload(CamelModel):
+    link: str
+
+
+class PinMessagePayload(CamelModel):
+    chat_id: int
+    notify_pin: bool
+    pin_message_id: int
+
+
+class CreateGroupAttach(CamelModel):
+    type: Literal["CONTROL"] = Field("CONTROL", alias="_type")
+    event: str = "new"
+    chat_type: str = "CHAT"
+    title: str
+    user_ids: list[int]
+
+
+class CreateGroupMessage(CamelModel):
+    cid: int
+    attaches: list[CreateGroupAttach]
+
+
+class CreateGroupPayload(CamelModel):
+    message: CreateGroupMessage
+    notify: bool = True
+
+
+class InviteUsersPayload(CamelModel):
+    chat_id: int
+    user_ids: list[int]
+    show_history: bool
+    operation: str = "add"
+
+
+class RemoveUsersPayload(CamelModel):
+    chat_id: int
+    user_ids: list[int]
+    operation: str = "remove"
+    clean_msg_period: int
+
+
+class ChangeGroupSettingsOptions(BaseModel):
+    ONLY_OWNER_CAN_CHANGE_ICON_TITLE: bool | None
+    ALL_CAN_PIN_MESSAGE: bool | None
+    ONLY_ADMIN_CAN_ADD_MEMBER: bool | None
+    ONLY_ADMIN_CAN_CALL: bool | None
+    MEMBERS_CAN_SEE_PRIVATE_LINK: bool | None
+
+
+class ChangeGroupSettingsPayload(CamelModel):
+    chat_id: int
+    options: ChangeGroupSettingsOptions
+
+
+class ChangeGroupProfilePayload(CamelModel):
+    chat_id: int
+    theme: str | None
+    description: str | None
+
+
+class GetGroupMembersPayload(CamelModel):
+    type: str = "MEMBER"
+    marker: int
+    chat_id: int
+    count: int