maxapi-python 1.2.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

pymax/api/messages/service.py

@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, TypeAlias
+
+from pymax.api.response import (
+    parse_payload_list,
+    parse_payload_model,
+    payload_item,
+    require_payload_model,
+)
+from pymax.api.uploads.payloads import AttachFilePayload, AttachPhotoPayload, VideoAttachPayload
+from pymax.exceptions import UploadError
+from pymax.files import File, Photo, Video
+from pymax.formatting.markdown import Formatter
+from pymax.logging import get_logger
+from pymax.protocol import Opcode
+from pymax.types.domain import (
+    FileRequest,
+    Message,
+    ReactionInfo,
+    ReadState,
+    VideoRequest,
+)
+
+from .enums import ItemType, MessagePayloadKey, ReadAction
+from .payloads import (
+    AddReactionPayload,
+    ChatHistoryPayload,
+    DeleteMessagePayload,
+    GetFilePayload,
+    GetReactionsPayload,
+    GetVideoPayload,
+    PinMessagePayload,
+    ReactionInfoPayload,
+    ReadMessagesPayload,
+    RemoveReactionPayload,
+    ReplyLink,
+    SendMessagePayload,
+    SendMessagePayloadMessage,
+)
+
+if TYPE_CHECKING:
+    from pymax.app import App
+
+SendAttachment: TypeAlias = Photo | File | Video
+SendAttachments: TypeAlias = list[SendAttachment] | None
+
+logger = get_logger(__name__)
+
+
+class MessageService:
+    def __init__(self, app: App) -> None:
+        self.app = app
+
+        self._prev = int(time.time() * 1000)
+
+    def _next_cid(self) -> int:
+        now = int(time.time() * 1000)
+        e = max(now, self._prev + 1)
+        self._prev = e
+        logger.debug("generated message cid=%s", e)
+        return e
+
+    async def _upload_attachments(
+        self, attachments: SendAttachments
+    ) -> list[AttachPhotoPayload | VideoAttachPayload | AttachFilePayload]:
+        result: list[AttachPhotoPayload | VideoAttachPayload | AttachFilePayload] = []
+        if not attachments:
+            return result
+
+        for attachment in attachments:
+            if isinstance(attachment, Photo):
+                upload_result = await self.app.api.uploads.upload_photo(attachment)
+                if not upload_result:
+                    logger.error("Photo uploading failed")
+                    raise UploadError("Photo uploading failed")
+
+                result.append(upload_result)
+
+            elif isinstance(attachment, Video):
+                upload_result = await self.app.api.uploads.upload_video(attachment)
+                if not upload_result:
+                    logger.error("Video uploading failed")
+                    raise UploadError("Video uploading failed")
+
+                result.append(upload_result)
+
+            elif isinstance(attachment, File):
+                upload_result = await self.app.api.uploads.upload_file(attachment)
+                if not upload_result:
+                    logger.error("File uploading failed")
+                    raise UploadError("File uploading failed")
+
+                result.append(upload_result)
+
+        return result
+
+    async def send_message(
+        self,
+        chat_id: int,
+        text: str,
+        reply_to: int | None = None,
+        attachments: SendAttachments = None,
+        *,
+        notify: bool = True,
+    ) -> Message | None:
+        logger.info("sending message chat_id=%s text_len=%s", chat_id, len(text))
+
+        clean_text, elements = Formatter.format_markdown(text)
+
+        frame = SendMessagePayload(
+            chat_id=chat_id,
+            message=SendMessagePayloadMessage(
+                text=clean_text,
+                cid=self._next_cid(),
+                elements=elements,
+                attaches=await self._upload_attachments(attachments),
+                link=ReplyLink(message_id=reply_to) if reply_to else None,
+            ),
+            notify=notify,
+        )
+
+        response = await self.app.invoke(Opcode.MSG_SEND, frame.to_payload())
+
+        message = require_payload_model(response, Message).bind(self)
+        logger.info("message sent chat_id=%s", chat_id)
+        return message
+
+    async def fetch_history(
+        self,
+        chat_id: int,
+        forward: int = 0,
+        backward: int = 40,
+        backward_time: int = 0,
+        forward_time: int = 0,
+        from_: int | None = None,
+        item_type: ItemType = ItemType.REGULAR,
+        get_chat: bool = False,
+        get_messages: bool = True,
+        interactive: bool = False,
+    ) -> list[Message] | None:
+        frame = ChatHistoryPayload(
+            chat_id=chat_id,
+            forward=forward,
+            backward=backward,
+            backward_time=backward_time,
+            forward_time=forward_time,
+            from_=from_ or int(time.time() * 1000),
+            item_type=item_type,
+            get_chat=get_chat,
+            get_messages=get_messages,
+            interactive=interactive,
+        )
+
+        response = await self.app.invoke(
+            Opcode.CHAT_HISTORY,
+            payload=frame.to_payload(),
+        )
+        return parse_payload_list(response, MessagePayloadKey.MESSAGES, Message) or None
+
+    async def delete_message(
+        self,
+        chat_id: int,
+        message_ids: list[int],
+        for_me: bool,
+    ) -> bool:
+        logger.info(
+            "deleting messages chat_id=%s ids=%s for_me=%s",
+            chat_id,
+            message_ids,
+            for_me,
+        )
+        frame = DeleteMessagePayload(
+            chat_id=chat_id,
+            message_ids=message_ids,
+            for_me=for_me,
+        )
+
+        await self.app.invoke(Opcode.MSG_DELETE, frame.to_payload())
+        logger.info("messages deleted chat_id=%s count=%s", chat_id, len(message_ids))
+        return True
+
+    async def pin_message(
+        self,
+        chat_id: int,
+        message_id: int,
+        notify_pin: bool,
+    ) -> bool:
+        logger.info(
+            "pinning message chat_id=%s message_id=%s notify_pin=%s",
+            chat_id,
+            message_id,
+            notify_pin,
+        )
+        frame = PinMessagePayload(
+            chat_id=chat_id,
+            notify_pin=notify_pin,
+            pin_message_id=message_id,
+        )
+
+        await self.app.invoke(Opcode.CHAT_UPDATE, frame.to_payload())
+        logger.info("message pinned chat_id=%s message_id=%s", chat_id, message_id)
+        return True
+
+    async def get_video_by_id(
+        self,
+        chat_id: int,
+        message_id: int | str,
+        video_id: int,
+    ) -> VideoRequest | None:
+        logger.info(
+            "getting video chat_id=%s message_id=%s video_id=%s",
+            chat_id,
+            message_id,
+            video_id,
+        )
+        frame = GetVideoPayload(
+            chat_id=chat_id,
+            message_id=message_id,
+            video_id=video_id,
+        )
+
+        response = await self.app.invoke(Opcode.VIDEO_PLAY, frame.to_payload())
+        return parse_payload_model(response, VideoRequest)
+
+    async def get_file_by_id(
+        self,
+        chat_id: int,
+        message_id: int | str,
+        file_id: int,
+    ) -> FileRequest | None:
+        logger.info(
+            "getting file chat_id=%s message_id=%s file_id=%s",
+            chat_id,
+            message_id,
+            file_id,
+        )
+        frame = GetFilePayload(
+            chat_id=chat_id,
+            message_id=message_id,
+            file_id=file_id,
+        )
+
+        response = await self.app.invoke(Opcode.FILE_DOWNLOAD, frame.to_payload())
+        return parse_payload_model(response, FileRequest)
+
+    async def add_reaction(
+        self,
+        chat_id: int,
+        message_id: str,
+        reaction: str,
+    ) -> ReactionInfo | None:
+        logger.info(
+            "adding reaction chat_id=%s message_id=%s reaction=%s",
+            chat_id,
+            message_id,
+            reaction,
+        )
+        frame = AddReactionPayload(
+            chat_id=chat_id,
+            message_id=message_id,
+            reaction=ReactionInfoPayload(id=reaction),
+        )
+
+        response = await self.app.invoke(Opcode.MSG_REACTION, frame.to_payload())
+        reaction_info = payload_item(response, MessagePayloadKey.REACTION_INFO)
+        if reaction_info:
+            return ReactionInfo.model_validate(reaction_info)
+
+        return None
+
+    async def get_reactions(
+        self,
+        chat_id: int,
+        message_ids: list[str],
+    ) -> dict[str, ReactionInfo] | None:
+        logger.info(
+            "getting reactions chat_id=%s message_ids=%s",
+            chat_id,
+            message_ids,
+        )
+        frame = GetReactionsPayload(chat_id=chat_id, message_ids=message_ids)
+
+        response = await self.app.invoke(
+            Opcode.MSG_GET_REACTIONS,
+            frame.to_payload(),
+        )
+        messages_reactions = payload_item(
+            response,
+            MessagePayloadKey.MESSAGES_REACTIONS,
+        )
+        if messages_reactions is None:
+            return None
+
+        return {
+            message_id: ReactionInfo.model_validate(reaction_data)
+            for message_id, reaction_data in messages_reactions.items()
+        }
+
+    async def remove_reaction(
+        self,
+        chat_id: int,
+        message_id: str,
+    ) -> ReactionInfo | None:
+        logger.info(
+            "removing reaction chat_id=%s message_id=%s",
+            chat_id,
+            message_id,
+        )
+        frame = RemoveReactionPayload(chat_id=chat_id, message_id=message_id)
+
+        response = await self.app.invoke(
+            Opcode.MSG_CANCEL_REACTION,
+            frame.to_payload(),
+        )
+        reaction_info = payload_item(response, MessagePayloadKey.REACTION_INFO)
+        if reaction_info:
+            return ReactionInfo.model_validate(reaction_info)
+
+        return None
+
+    async def read_message(self, message_id: int, chat_id: int) -> ReadState:
+        logger.info(
+            "marking message as read chat_id=%s message_id=%s",
+            chat_id,
+            message_id,
+        )
+        frame = ReadMessagesPayload(
+            type=ReadAction.READ_MESSAGE,
+            chat_id=chat_id,
+            message_id=str(message_id),
+            mark=int(time.time() * 1000),
+        )
+
+        response = await self.app.invoke(Opcode.CHAT_MARK, frame.to_payload())
+        return require_payload_model(response, ReadState)

pymax/api/models.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+from pydantic.alias_generators import to_camel
+
+
+class CamelModel(BaseModel):
+    model_config = {
+        "alias_generator": to_camel,
+        "populate_by_name": True,
+        "arbitrary_types_allowed": True,
+    }
+
+    def to_payload(self) -> dict:
+        return self.model_dump(by_alias=True, exclude_none=True)

pymax/api/response.py

@@ -0,0 +1,123 @@
+from enum import Enum
+from typing import Any, TypeVar, overload
+
+from pydantic import BaseModel
+
+from pymax.exceptions import PyMaxError
+from pymax.protocol import InboundFrame
+
+T = TypeVar("T", bound=BaseModel)
+V = TypeVar("V")
+
+PayloadKey = str | Enum
+
+
+def _key_value(key: PayloadKey) -> str:
+    value = key.value if isinstance(key, Enum) else key
+    return str(value)
+
+
+def payload_dict(response: InboundFrame) -> dict[Any, Any]:
+    return response.payload or {}
+
+
+def payload_keys(response: InboundFrame) -> list[Any]:
+    return sorted(payload_dict(response))
+
+
+def require_payload_dict(response: InboundFrame) -> dict[Any, Any]:
+    if not isinstance(response.payload, dict):
+        raise PyMaxError("Invalid response payload")
+
+    return response.payload
+
+
+@overload
+def payload_item(
+    response: InboundFrame,
+    key: PayloadKey,
+) -> Any | None: ...
+
+
+@overload
+def payload_item(
+    response: InboundFrame,
+    key: PayloadKey,
+    validation_type: type[V],
+) -> V | None: ...
+
+
+def payload_item(
+    response: InboundFrame,
+    key: PayloadKey,
+    validation_type: type[V] | None = None,
+) -> V | Any | None:
+    data = payload_dict(response).get(_key_value(key))
+
+    if data is None:
+        return None
+
+    if validation_type is None:
+        return data
+
+    return validation_type(data)
+
+
+def require_payload_item(
+    response: InboundFrame,
+    key: PayloadKey,
+) -> Any:
+    item = payload_item(response, key)
+    if item is None:
+        raise PyMaxError(f"Missing `{_key_value(key)}` in response")
+
+    return item
+
+
+def parse_payload_model(
+    response: InboundFrame,
+    model: type[T],
+) -> T | None:
+    if response.payload:
+        return model.model_validate(response.payload)
+
+    return None
+
+
+def require_payload_model(
+    response: InboundFrame,
+    model: type[T],
+) -> T:
+    if not response.payload:
+        raise PyMaxError("Missing payload in response")
+
+    return model.model_validate(response.payload)
+
+
+def parse_payload_item_model(
+    response: InboundFrame,
+    key: PayloadKey,
+    model: type[T],
+) -> T | None:
+    item = payload_item(response, key)
+    if item:
+        return model.model_validate(item)
+
+    return None
+
+
+def require_payload_item_model(
+    response: InboundFrame,
+    key: PayloadKey,
+    model: type[T],
+) -> T:
+    return model.model_validate(require_payload_item(response, key))
+
+
+def parse_payload_list(
+    response: InboundFrame,
+    key: PayloadKey,
+    model: type[T],
+) -> list[T]:
+    items = payload_item(response, key) or []
+    return [model.model_validate(item) for item in items]

pymax/api/self/__init__.py

@@ -0,0 +1,2 @@
+from .enums import AvatarType, SelfPayloadKey
+from .service import SelfService

pymax/api/self/enums.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class AvatarType(str, Enum):
+    USER_AVATAR = "USER_AVATAR"
+
+
+class SelfPayloadKey(str, Enum):
+    PROFILE = "profile"
+    URL = "url"
+    TOKEN = "token"

pymax/api/self/payloads.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+from pymax.api.models import CamelModel
+
+from .enums import AvatarType
+
+
+class UploadPayload(CamelModel):
+    count: int = 1
+    profile: bool = False
+
+
+class ChangeProfilePayload(CamelModel):
+    first_name: str
+    last_name: str | None = None
+    description: str | None = None
+    photo_token: str | None = None
+    avatar_type: AvatarType = AvatarType.USER_AVATAR
+
+
+class CreateFolderPayload(CamelModel):
+    id: str
+    title: str
+    include: list[int]
+    filters: list[Any]
+
+
+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/api/self/service.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from uuid import uuid4
+
+from pymax.api.response import (
+    payload_item,
+    require_payload_item,
+    require_payload_item_model,
+    require_payload_model,
+)
+from pymax.logging import get_logger
+from pymax.protocol import Opcode
+from pymax.types.domain import FolderList, FolderUpdate, Profile
+
+from .enums import SelfPayloadKey
+from .payloads import (
+    ChangeProfilePayload,
+    CreateFolderPayload,
+    DeleteFolderPayload,
+    GetFolderPayload,
+    UpdateFolderPayload,
+    UploadPayload,
+)
+
+if TYPE_CHECKING:
+    from pymax.app import App
+
+
+logger = get_logger(__name__)
+
+
+class SelfService:
+    def __init__(self, app: App) -> None:
+        self.app = app
+
+    async def request_profile_photo_upload_url(self) -> str:
+        logger.info("requesting profile photo upload url")
+        frame = UploadPayload(profile=True)
+        response = await self.app.invoke(Opcode.PHOTO_UPLOAD, frame.to_payload())
+        return str(require_payload_item(response, SelfPayloadKey.URL))
+
+    async def change_profile(
+        self,
+        first_name: str,
+        last_name: str | None = None,
+        description: str | None = None,
+        photo: Any | None = None,
+        *,
+        photo_token: str | None = None,
+    ) -> bool:
+        if photo is not None:
+            raise NotImplementedError(
+                "Profile photo upload is not implemented without upload infra. "
+                "Pass photo_token instead."
+            )
+
+        frame = ChangeProfilePayload(
+            first_name=first_name,
+            last_name=last_name,
+            description=description,
+            photo_token=photo_token,
+        )
+        response = await self.app.invoke(Opcode.PROFILE, frame.to_payload())
+        profile = require_payload_item_model(
+            response,
+            SelfPayloadKey.PROFILE,
+            Profile,
+        )
+        self.app.me = profile
+        self.app.users[profile.contact.id] = profile.contact
+        return True
+
+    async def create_folder(
+        self,
+        title: str,
+        chat_include: list[int],
+        filters: list[Any] | None = None,
+    ) -> FolderUpdate:
+        logger.info("creating folder")
+        frame = CreateFolderPayload(
+            id=str(uuid4()),
+            title=title,
+            include=chat_include,
+            filters=filters or [],
+        )
+        response = await self.app.invoke(Opcode.FOLDERS_UPDATE, frame.to_payload())
+        return require_payload_model(response, FolderUpdate)
+
+    async def get_folders(self, folder_sync: int = 0) -> FolderList:
+        logger.info("fetching folders")
+        frame = GetFolderPayload(folder_sync=folder_sync)
+        response = await self.app.invoke(Opcode.FOLDERS_GET, frame.to_payload())
+        return require_payload_model(response, FolderList)
+
+    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,
+    ) -> FolderUpdate:
+        logger.info("updating folder")
+        frame = UpdateFolderPayload(
+            id=folder_id,
+            title=title,
+            include=chat_include or [],
+            filters=filters or [],
+            options=options or [],
+        )
+        response = await self.app.invoke(Opcode.FOLDERS_UPDATE, frame.to_payload())
+        return require_payload_model(response, FolderUpdate)
+
+    async def delete_folder(self, folder_id: str) -> FolderUpdate:
+        logger.info("deleting folder")
+        frame = DeleteFolderPayload(folder_ids=[folder_id])
+        response = await self.app.invoke(Opcode.FOLDERS_DELETE, frame.to_payload())
+        return require_payload_model(response, FolderUpdate)
+
+    async def close_all_sessions(self) -> bool:
+        logger.info("closing all other sessions")
+
+        if not self.app.session:
+            logger.warning("no session found, skipping closing sessions")
+            return False
+
+        response = await self.app.invoke(Opcode.SESSIONS_CLOSE, {})
+        token = payload_item(response, SelfPayloadKey.TOKEN, str)
+
+        if not token:
+            logger.warning("no token received after closing sessions, skipping token update")
+            return False
+
+        await self.app.store.update_token(self.app.session.token, token)
+
+        return True
+
+    async def logout(self) -> bool:
+        logger.info("logging out")
+        await self.app.invoke(Opcode.LOGOUT, {})
+        return True

pymax/api/session/__init__.py

@@ -0,0 +1 @@
+from .service import SessionService

pymax/api/session/enums.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class DeviceType(str, Enum):
+    """Тип устройства, который отправляется в handshake и login."""
+
+    WEB = "WEB"
+    ANDROID = "ANDROID"
+    IOS = "IOS"
+    DESKTOP = "DESKTOP"