maxapi-python 2.3.1__py3-none-any.whl → 2.4.1__py3-none-any.whl

pymax/api/messages/service.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+import asyncio
 import time
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, TypeAlias
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, TypeAlias, TypeVar
 
 from pymax.api.binding import bind_api_model, bind_api_models
 from pymax.api.response import (
@@ -16,15 +18,19 @@ from pymax.api.uploads.payloads import (
     AttachFilePayload,
     AttachPhotoPayload,
     VideoAttachPayload,
+    VideoNoteAttachPayload,
+    VoiceAttachPayload,
 )
-from pymax.exceptions import UploadError
-from pymax.files import File, Photo, Video
+from pymax.exceptions import ApiError, UploadError
+from pymax.files import File, Photo, Video, VideoNote, Voice
 from pymax.formatting.markdown import Formatter
 from pymax.logging import get_logger
 from pymax.protocol import Opcode
 from pymax.types.domain import (
     FileRequest,
     Message,
+    Poll,
+    PollState,
     ReactionInfo,
     ReadState,
     VideoRequest,
@@ -34,6 +40,7 @@ from .enums import ItemType, MessagePayloadKey, ReadAction
 from .payloads import (
     AddReactionPayload,
     ChatHistoryPayload,
+    DelayedAttributes,
     DeleteMessagePayload,
     EditMessagePayload,
     ForwardLink,
@@ -50,13 +57,17 @@ from .payloads import (
     ReplyLink,
     SendMessagePayload,
     SendMessagePayloadMessage,
+    VotePollPayload,
 )
 
 if TYPE_CHECKING:
     from pymax.app import App
 
-SendAttachment: TypeAlias = Photo | File | Video
+SendAttachment: TypeAlias = Photo | File | Video | Poll | Voice | VideoNote
 SendAttachments: TypeAlias = Sequence[SendAttachment] | None
+DateTimeUnion: TypeAlias = datetime | timedelta | int
+
+T = TypeVar("T")
 
 logger = get_logger(__name__)
 
@@ -76,13 +87,25 @@ class MessageService:
 
     async def _upload_attachments(
         self, attachments: SendAttachments
-    ) -> list[AttachPhotoPayload | VideoAttachPayload | AttachFilePayload]:
-        result: list[AttachPhotoPayload | VideoAttachPayload | AttachFilePayload] = []
+    ) -> list[
+        AttachPhotoPayload | VideoAttachPayload | AttachFilePayload | VoiceAttachPayload | Poll
+    ]:  # TODO: TypeAlias
+        result: list[
+            AttachPhotoPayload | VideoAttachPayload | AttachFilePayload | VoiceAttachPayload | Poll
+        ] = []
         if not attachments:
             return result
 
         for attachment in attachments:
-            if isinstance(attachment, Photo):
+            if isinstance(attachment, Voice):
+                upload_result = await self.app.api.uploads.upload_voice(attachment)
+                if not upload_result:
+                    logger.error("Voice uploading failed")
+                    raise UploadError("Voice uploading failed")
+
+                result.append(upload_result)
+
+            elif isinstance(attachment, Photo):
                 upload_result = await self.app.api.uploads.upload_photo(attachment)
                 if not upload_result:
                     logger.error("Photo uploading failed")
@@ -90,7 +113,7 @@ class MessageService:
 
                 result.append(upload_result)
 
-            elif isinstance(attachment, Video):
+            elif isinstance(attachment, (Video, VideoNote)):
                 upload_result = await self.app.api.uploads.upload_video(attachment)
                 if not upload_result:
                     logger.error("Video uploading failed")
@@ -106,20 +129,89 @@ class MessageService:
 
                 result.append(upload_result)
 
+            elif isinstance(attachment, Poll):
+                result.append(attachment)
+
         return result
 
+    def _convert_time(self, time: DateTimeUnion) -> int:
+        if isinstance(time, datetime):
+            return int(time.timestamp() * 1000)
+
+        if isinstance(time, timedelta):
+            return int((datetime.now() + time).timestamp() * 1000)
+
+        return time * 1000
+
+    async def _wait_for_upload_signal(
+        self,
+        waiters: dict[int, asyncio.Future[T]],
+        video_id: int,
+    ) -> None:
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[T] = loop.create_future()
+
+        waiters[video_id] = future
+        try:
+            await asyncio.wait_for(future, timeout=60)
+        except TimeoutError:
+            logger.warning(
+                "Timed out waiting for video processing notification video_id=%s",
+                video_id,
+            )
+            raise UploadError(f"Timed out waiting for video processing video_id={video_id}")
+        finally:
+            waiters.pop(video_id, None)
+
+    async def _process_attachment_error(
+        self,
+        attaches: list[
+            AttachPhotoPayload | VideoAttachPayload | AttachFilePayload | VoiceAttachPayload | Poll
+        ],
+    ):
+        attachment: VoiceAttachPayload | VideoNoteAttachPayload | None = None
+        for attach in attaches:
+            if isinstance(attach, (VoiceAttachPayload, VideoNoteAttachPayload)):
+                attachment = attach
+                break
+
+        if attachment is None:
+            raise ValueError(
+                "Unexpected internal state: Non voice/video_note attach is not ready. "
+                + "Please, report that issue"
+            )
+
+        if isinstance(attachment, VoiceAttachPayload):
+            await self._wait_for_upload_signal(
+                self.app.api.uploads.voice_upload_waiters, attachment.video_id
+            )
+        else:
+            await self._wait_for_upload_signal(
+                self.app.api.uploads.video_upload_waiters, attachment.video_id
+            )
+
     async def send_message(
         self,
         chat_id: int,
-        text: str,
+        text: str | None = None,
         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))
+        send_at: DateTimeUnion | None = None,
+    ) -> Message:
+        logger.info("sending message chat_id=%s text_len=%s", chat_id, len(text) if text else 0)
+
+        if not text and not attachments:
+            logger.error("send_message failed: no text or attachments provided")
+            raise ValueError("Either text or attachments must be provided")
+
+        if text:
+            clean_text, elements = Formatter.format_markdown(text)
+        else:
+            clean_text, elements = None, []
 
-        clean_text, elements = Formatter.format_markdown(text)
+        attaches = await self._upload_attachments(attachments)
 
         frame = SendMessagePayload(
             chat_id=chat_id,
@@ -127,13 +219,26 @@ class MessageService:
                 text=clean_text,
                 cid=self._next_cid(),
                 elements=elements,
-                attaches=await self._upload_attachments(attachments),
+                attaches=attaches,
                 link=ReplyLink(message_id=reply_to) if reply_to else None,
+                delayed_attributes=DelayedAttributes(
+                    time_to_fire=self._convert_time(send_at),
+                    notify_sender=notify,
+                )
+                if send_at
+                else None,
             ),
             notify=notify,
         )
 
-        response = await self.app.invoke(Opcode.MSG_SEND, frame.to_payload())
+        try:
+            response = await self.app.invoke(Opcode.MSG_SEND, frame.to_payload())
+        except ApiError as e:
+            if e.error == "attachment.not.ready":
+                await self._process_attachment_error(attaches)
+                response = await self.app.invoke(Opcode.MSG_SEND, frame.to_payload())
+            else:
+                raise
 
         message = bind_api_model(
             self.app,
@@ -149,7 +254,7 @@ class MessageService:
         source_chat_id: int | None = None,
         *,
         notify: bool = True,
-    ) -> Message | None:
+    ) -> Message:
         source_chat_id = chat_id if source_chat_id is None else source_chat_id
         logger.info(
             "forwarding message source_chat_id=%s chat_id=%s message_id=%s",
@@ -208,19 +313,37 @@ class MessageService:
         self,
         chat_id: int,
         message_id: int,
-        text: str,
+        text: str | None = None,
         attachments: SendAttachments = None,
     ) -> Message:
-        clean_text, elements = Formatter.format_markdown(text)
+        if not text and not attachments:
+            logger.error("edit_message failed: no text or attachments provided")
+            raise ValueError("Either text or attachments must be provided")
+
+        if text:
+            clean_text, elements = Formatter.format_markdown(text)
+        else:
+            clean_text, elements = None, []
+
+        attaches = await self._upload_attachments(attachments)
+
         frame = EditMessagePayload(
             chat_id=chat_id,
             message_id=message_id,
             text=clean_text,
             elements=elements,
-            attachments=await self._upload_attachments(attachments),
+            attachments=attaches,
         )
+        try:
+            response = await self.app.invoke(Opcode.MSG_EDIT, frame.to_payload())
+        except ApiError as e:
+            if e.error == "attachment.not.ready":
+                await self._process_attachment_error(attaches)
+
+                response = await self.app.invoke(Opcode.MSG_EDIT, frame.to_payload())
+            else:
+                raise
 
-        response = await self.app.invoke(Opcode.MSG_EDIT, frame.to_payload())
         message = require_payload_item_model(
             response,
             MessagePayloadKey.MESSAGE,
@@ -243,7 +366,7 @@ class MessageService:
         get_chat: bool = False,
         get_messages: bool = True,
         interactive: bool = False,
-    ) -> list[Message] | None:
+    ) -> list[Message]:
         frame = ChatHistoryPayload(
             chat_id=chat_id,
             forward=forward,
@@ -265,7 +388,7 @@ class MessageService:
             self.app,
             parse_payload_list(response, MessagePayloadKey.MESSAGES, Message),
         )
-        return messages or None
+        return messages
 
     async def delete_message(
         self,
@@ -356,7 +479,7 @@ class MessageService:
     async def add_reaction(
         self,
         chat_id: int,
-        message_id: str,
+        message_id: int,
         reaction: str,
     ) -> ReactionInfo | None:
         logger.info(
@@ -381,7 +504,7 @@ class MessageService:
     async def get_reactions(
         self,
         chat_id: int,
-        message_ids: list[str],
+        message_ids: list[int],
     ) -> dict[str, ReactionInfo] | None:
         logger.info(
             "getting reactions chat_id=%s message_ids=%s",
@@ -409,7 +532,7 @@ class MessageService:
     async def remove_reaction(
         self,
         chat_id: int,
-        message_id: str,
+        message_id: int,
     ) -> ReactionInfo | None:
         logger.info(
             "removing reaction chat_id=%s message_id=%s",
@@ -443,3 +566,17 @@ class MessageService:
 
         response = await self.app.invoke(Opcode.CHAT_MARK, frame.to_payload())
         return require_payload_model(response, ReadState)
+
+    async def vote_poll(
+        self,
+        chat_id: int,
+        message_id: int,
+        poll_id: int,
+        answer_ids: list[int],
+    ) -> PollState:
+        frame = VotePollPayload(
+            chat_id=chat_id, message_id=message_id, poll_id=poll_id, answers_ids=answer_ids
+        )
+        response = await self.app.invoke(Opcode.SEND_VOTE, frame.to_payload())
+
+        return require_payload_item_model(response, "state", PollState)

pymax/api/self/__init__.py

@@ -1,2 +1,3 @@
-from .enums import AvatarType, SelfPayloadKey
+from .enums import AvatarType, PrivacyAccess, SelfPayloadKey
+from .payloads import PrivacySettingsUpdate
 from .service import SelfService

pymax/api/self/enums.py

@@ -9,3 +9,12 @@ class SelfPayloadKey(str, Enum):
     PROFILE = "profile"
     URL = "url"
     TOKEN = "token"
+    HASH = "hash"
+
+
+class PrivacyAccess(str, Enum):
+    """Уровень доступа к данным и действиям аккаунта."""
+
+    ALL = "ALL"
+    CONTACTS = "CONTACTS"
+    NOBODY = "_NONE_"

pymax/api/self/payloads.py

@@ -1,8 +1,10 @@
 from typing import Any
 
+from pydantic import BaseModel, Field
+
 from pymax.api.models import CamelModel
 
-from .enums import AvatarType
+from .enums import AvatarType, PrivacyAccess
 
 
 class UploadPayload(CamelModel):
@@ -39,3 +41,40 @@ class UpdateFolderPayload(CamelModel):
 
 class DeleteFolderPayload(CamelModel):
     folder_ids: list[str]
+
+
+class PrivacySettingsUpdate(BaseModel):
+    """Изменяемые настройки приватности аккаунта.
+
+    Все поля необязательны: в запрос попадают только переданные настройки.
+
+    Args:
+        search_by_phone: Кто может найти аккаунт по номеру телефона.
+        incoming_calls: Кто может звонить аккаунту.
+        chat_invites: Кто может добавлять аккаунт в чаты.
+        phone_number_visibility: Кто может видеть номер телефона.
+        hide_online_status: Скрывать ли статус присутствия.
+        safe_content_only: Показывать только безопасный контент.
+    """
+
+    search_by_phone: PrivacyAccess | None = Field(
+        default=None, serialization_alias="SEARCH_BY_PHONE"
+    )
+    incoming_calls: PrivacyAccess | None = Field(default=None, serialization_alias="INCOMING_CALL")
+    chat_invites: PrivacyAccess | None = Field(default=None, serialization_alias="CHATS_INVITE")
+    phone_number_visibility: PrivacyAccess | None = Field(
+        default=None, serialization_alias="PHONE_NUMBER_PRIVACY"
+    )
+
+    hide_online_status: bool | None = Field(default=None, serialization_alias="HIDDEN")
+    safe_content_only: bool | None = Field(
+        default=None, serialization_alias="CONTENT_LEVEL_ACCESS"
+    )
+
+
+class ChangeProfileSettings(CamelModel):
+    user: PrivacySettingsUpdate
+
+
+class ChangeProfileSettingsPayload(CamelModel):
+    settings: ChangeProfileSettings

pymax/api/self/service.py

@@ -18,9 +18,12 @@ from pymax.types.domain import FolderList, FolderUpdate, Profile
 from .enums import SelfPayloadKey
 from .payloads import (
     ChangeProfilePayload,
+    ChangeProfileSettings,
+    ChangeProfileSettingsPayload,
     CreateFolderPayload,
     DeleteFolderPayload,
     GetFolderPayload,
+    PrivacySettingsUpdate,
     UpdateFolderPayload,
     UploadPayload,
 )
@@ -150,3 +153,37 @@ class SelfService:
         logger.info("logging out")
         await self.app.invoke(Opcode.LOGOUT, {})
         return True
+
+    def set_presence(self, online: bool) -> None:
+        logger.info("setting presence to %s", "online" if online else "offline")
+        self.app.config.interactive = online
+
+    async def change_profile_settings(self, settings: PrivacySettingsUpdate) -> bool:
+        logger.info("changing profile settings")
+
+        frame = ChangeProfileSettingsPayload(settings=ChangeProfileSettings(user=settings))
+
+        response = await self.app.invoke(
+            Opcode.CONFIG,
+            frame.to_payload(),
+        )
+        session = self.app.session
+
+        if not session:
+            logger.warning("no session found, skipping sync update")
+            return True
+
+        sync = session.sync.model_copy(
+            update={"config_hash": require_payload_item(response, SelfPayloadKey.HASH)}
+        )
+
+        updated = session.model_copy(
+            update={
+                "mt_instance_id": self.app.config.device.mt_instance_id,
+                "sync": sync,
+            },
+        )
+        self.app.session = updated
+        await self.app.store.save_session(updated)
+
+        return True

pymax/api/session/service.py

@@ -2,8 +2,10 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from pymax.api.response import require_payload_model
 from pymax.logging import get_logger
 from pymax.protocol import Opcode
+from pymax.types.domain import HandshakeResponse
 
 from .enums import DeviceType
 from .payloads import (
@@ -28,19 +30,18 @@ class SessionService:
         mt_instance_id: str,
         user_agent: MobileUserAgentPayload,
         device_id: str,
-    ) -> None:
+    ) -> HandshakeResponse:
         if user_agent.device_type == DeviceType.WEB:
-            await self.web_handshake(user_agent, device_id)
-            return
+            return await self.web_handshake(user_agent, device_id)
 
-        await self.mobile_handshake(mt_instance_id, user_agent, device_id)
+        return await self.mobile_handshake(mt_instance_id, user_agent, device_id)
 
     async def mobile_handshake(
         self,
         mt_instance_id: str,
         user_agent: MobileUserAgentPayload,
         device_id: str,
-    ) -> None:
+    ) -> HandshakeResponse:
         logger.debug(
             "mobile handshake mt_instance_id_set=%s device_id=%s app_version=%s",
             bool(mt_instance_id),
@@ -52,10 +53,17 @@ class SessionService:
             user_agent=user_agent,
             device_id=device_id,
         )
-        await self.app.invoke(Opcode.SESSION_INIT, frame.to_payload())
+        response = await self.app.invoke(Opcode.SESSION_INIT, frame.to_payload())
         logger.info("mobile handshake completed")
 
-    async def web_handshake(self, user_agent: MobileUserAgentPayload, device_id: str) -> None:
+        return require_payload_model(
+            response,
+            HandshakeResponse,
+        )
+
+    async def web_handshake(
+        self, user_agent: MobileUserAgentPayload, device_id: str
+    ) -> HandshakeResponse:
         logger.debug(
             "web handshake device_id=%s app_version=%s browser=%s",
             device_id,
@@ -66,5 +74,10 @@ class SessionService:
             user_agent=user_agent,
             device_id=device_id,
         )
-        await self.app.invoke(Opcode.SESSION_INIT, frame.to_payload())
+        response = await self.app.invoke(Opcode.SESSION_INIT, frame.to_payload())
         logger.info("web handshake completed")
+
+        return require_payload_model(
+            response,
+            HandshakeResponse,
+        )

pymax/api/uploads/payloads.py

@@ -1,4 +1,6 @@
-from pydantic import Field
+from typing import Any
+
+from pydantic import Field, SerializerFunctionWrapHandler, model_serializer
 
 from pymax.api.models import CamelModel
 from pymax.types import AttachmentType
@@ -13,6 +15,40 @@ class VideoAttachPayload(CamelModel):
     type: AttachmentType = Field(default=AttachmentType.VIDEO, serialization_alias="_type")
     video_id: int
     token: str
+    video_type: int = 0
+    thumbhash: bytes | None = None
+    duration: int | None = None
+    wave: bytes | None = None
+
+    @model_serializer(mode="wrap")
+    def serialize_attachment(self, handler: SerializerFunctionWrapHandler) -> dict[str, Any]:
+        payload = handler(self)
+
+        if self.type == AttachmentType.AUDIO:
+            payload.pop("videoId", None)
+            payload.pop("videoType", None)
+            if not self.token:
+                payload.pop("token", None)
+                payload["audioId"] = self.video_id
+        elif self.video_type == 1:
+            if self.token:
+                payload.pop("videoId", None)
+            else:
+                payload.pop("token", None)
+                payload["videoId"] = self.video_id
+
+        return payload
+
+
+class VoiceAttachPayload(VideoAttachPayload):
+    type: AttachmentType = Field(default=AttachmentType.AUDIO, serialization_alias="_type")
+    video_id: int = Field(exclude=True)
+    video_type: int = Field(default=0, exclude=True)
+
+
+class VideoNoteAttachPayload(VideoAttachPayload):
+    video_id: int = Field(exclude=True)
+    video_type: int = 1
 
 
 class AttachFilePayload(CamelModel):
@@ -22,4 +58,6 @@ class AttachFilePayload(CamelModel):
 
 class UploadPayload(CamelModel):
     count: int = 1
+    type: int = 0
+    uploader_type: int = 0
     profile: bool = False