maxapi-python 2.4.0__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,8 +18,10 @@ from pymax.api.uploads.payloads import (
     AttachFilePayload,
     AttachPhotoPayload,
     VideoAttachPayload,
+    VideoNoteAttachPayload,
+    VoiceAttachPayload,
 )
-from pymax.exceptions import UploadError
+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
@@ -36,6 +40,7 @@ from .enums import ItemType, MessagePayloadKey, ReadAction
 from .payloads import (
     AddReactionPayload,
     ChatHistoryPayload,
+    DelayedAttributes,
     DeleteMessagePayload,
     EditMessagePayload,
     ForwardLink,
@@ -60,6 +65,9 @@ if TYPE_CHECKING:
 
 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__)
 
@@ -79,8 +87,12 @@ class MessageService:
 
     async def _upload_attachments(
         self, attachments: SendAttachments
-    ) -> list[AttachPhotoPayload | VideoAttachPayload | AttachFilePayload | Poll]:
-        result: list[AttachPhotoPayload | VideoAttachPayload | AttachFilePayload | Poll] = []
+    ) -> list[
+        AttachPhotoPayload | VideoAttachPayload | AttachFilePayload | VoiceAttachPayload | Poll
+    ]:  # TODO: TypeAlias
+        result: list[
+            AttachPhotoPayload | VideoAttachPayload | AttachFilePayload | VoiceAttachPayload | Poll
+        ] = []
         if not attachments:
             return result
 
@@ -101,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")
@@ -122,6 +134,62 @@ class MessageService:
 
         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,
@@ -130,6 +198,7 @@ class MessageService:
         attachments: SendAttachments = None,
         *,
         notify: bool = True,
+        send_at: DateTimeUnion | None = None,
     ) -> Message:
         logger.info("sending message chat_id=%s text_len=%s", chat_id, len(text) if text else 0)
 
@@ -142,19 +211,34 @@ class MessageService:
         else:
             clean_text, elements = None, []
 
+        attaches = await self._upload_attachments(attachments)
+
         frame = SendMessagePayload(
             chat_id=chat_id,
             message=SendMessagePayloadMessage(
                 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,
@@ -241,15 +325,25 @@ class MessageService:
         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,
@@ -385,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(
@@ -410,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",
@@ -438,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",

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
@@ -18,6 +20,36 @@ class VideoAttachPayload(CamelModel):
     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):
     type: AttachmentType = Field(default=AttachmentType.FILE, serialization_alias="_type")

pymax/api/uploads/service.py

@@ -15,7 +15,7 @@ from pymax.exceptions import UploadError
 from pymax.files import File, Photo, Video, VideoNote, Voice
 from pymax.logging import get_logger
 from pymax.protocol import Opcode
-from pymax.types import AttachmentType, AudioUploadSignal
+from pymax.types import AudioUploadSignal
 
 from .models import (
     FileUploadResponse,
@@ -27,6 +27,8 @@ from .payloads import (
     AttachPhotoPayload,
     UploadPayload,
     VideoAttachPayload,
+    VideoNoteAttachPayload,
+    VoiceAttachPayload,
 )
 
 if TYPE_CHECKING:
@@ -182,7 +184,7 @@ class UploadService:
         logger.debug("Photo upload complete photo_id=%s", photo_id)
         return AttachPhotoPayload(photo_token=token)
 
-    async def upload_voice(self, voice: Voice) -> VideoAttachPayload:
+    async def upload_voice(self, voice: Voice) -> VoiceAttachPayload:
         logger.info("Uploading voice")
 
         payload = UploadPayload(
@@ -227,12 +229,23 @@ class UploadService:
             logger.exception("Failed to get voice size")
             raise UploadError("Failed to get voice size") from e
 
+        #     ("Samsung SM-A525F", "Android 13", "405dpi 405dpi 1080x2400", "arm64-v8a"),
+        # OKMessages/{app_version} ({os_version}; {device_name}; {screen})
+
+        user_agent = (
+            f"OKMessages/{self.app.config.app_version}"
+            + f" ({self.app.config.device.user_agent.os_version};"
+            + f" {self.app.config.device.user_agent.device_name};"
+            + f" {self.app.config.device.user_agent.screen})"
+        )
+
         headers = {
             "Content-Disposition": f"attachment; filename={quote(voice.name)}",
-            "Content-Range": f"0-{file_size - 1}/{file_size}",
+            "Content-Range": f"bytes 0-{file_size - 1}/{file_size}",
             "Content-Length": str(file_size),
             "Connection": "keep-alive",
             "Content-Type": "application/octet-stream",
+            "User-Agent": quote(user_agent),
         }
 
         logger.debug(
@@ -240,15 +253,11 @@ class UploadService:
             headers["Content-Range"],
         )
 
-        loop = asyncio.get_running_loop()
-        future: asyncio.Future[AudioUploadSignal] = loop.create_future()
-
-        timeout = aiohttp.ClientTimeout(total=900, sock_read=60)
+        timeout = aiohttp.ClientTimeout(total=self.app.config.upload_timeout, sock_read=60)
 
         video_id = upload_info.video_id
         token = upload_info.token
 
-        self.voice_upload_waiters[video_id] = future
         logger.debug("Voice upload waiter registered voice_id=%s", video_id)
 
         try:
@@ -279,24 +288,29 @@ class UploadService:
                             f"{response.status} voice_id={video_id}"
                         )
 
-                    try:
-                        logger.debug(
-                            "Waiting for voice processing notification voice_id=%s",
-                            video_id,
-                        )
-                        await asyncio.wait_for(future, 60)
-                    except asyncio.TimeoutError:
-                        logger.warning(
-                            "Timed out waiting for voice processing notification voice_id=%s",
-                            video_id,
-                        )
-                        raise UploadError(
-                            f"Timed out waiting for voice processing voice_id={video_id}"
-                        )
+                    # print(await response.read()) # TODO: Error handing (yes, with 200 status 💔)
+
+                    # try:
+                    #     logger.debug(
+                    #         "Waiting for voice processing notification voice_id=%s",
+                    #         video_id,
+                    #     )
+                    #     await asyncio.wait_for(future, 60)
+                    # except asyncio.TimeoutError:
+                    #     logger.warning(
+                    #         "Timed out waiting for voice processing notification voice_id=%s",
+                    #         video_id,
+                    #     )
+                    #     raise UploadError(
+                    #         f"Timed out waiting for voice processing voice_id={video_id}"
+                    #     )
 
                     logger.debug("Voice upload complete voice_id=%s", video_id)
-                    return VideoAttachPayload(
-                        type=AttachmentType.AUDIO, video_id=video_id, token=token
+                    return VoiceAttachPayload(
+                        video_id=video_id,
+                        token=token,
+                        duration=await voice.get_duration(),
+                        wave=b"\x00" * 80,
                     )
 
         except UploadError:
@@ -314,7 +328,9 @@ class UploadService:
             self.voice_upload_waiters.pop(video_id, None)
             logger.debug("Voice upload waiter removed voice_id=%s", video_id)
 
-    async def upload_video(self, uploadable_video: Video | VideoNote) -> VideoAttachPayload:
+    async def upload_video(
+        self, uploadable_video: Video | VideoNote
+    ) -> VideoAttachPayload | VideoNoteAttachPayload:
         logger.info("Uploading video")
         logger.debug("Preparing video upload payload")
 
@@ -366,10 +382,10 @@ class UploadService:
             file_size,
         )
 
-        timeout = aiohttp.ClientTimeout(total=900, sock_read=60)
+        timeout = aiohttp.ClientTimeout(total=self.app.config.upload_timeout, sock_read=60)
 
         headers = {
-            "Content-Disposition": f"attachment; filename={quote(uploadable_video.name)}",
+            "Content-Disposition": f"attachment; filename={quote(str(uploadable_video.name))}",
             "Content-Range": f"bytes 0-{file_size - 1}/{file_size}",
             "Content-Length": str(file_size),
             "Connection": "keep-alive",
@@ -427,10 +443,9 @@ class UploadService:
                                 thumbhash += "=" * (-len(thumbhash) % 4)
                                 thumbhash = base64.b64decode(thumbhash)
 
-                            return VideoAttachPayload(
+                            return VideoNoteAttachPayload(
                                 video_id=video_id,
                                 token=token,
-                                video_type=1,
                                 thumbhash=thumbhash,
                                 duration=await uploadable_video.get_duration(),
                             )
@@ -532,51 +547,51 @@ class UploadService:
 
         file_id = upload_info.file_id
 
+        timeout = aiohttp.ClientTimeout(total=self.app.config.upload_timeout, sock_read=60)
+
         self.file_upload_waiters[file_id] = future
         logger.debug("File upload waiter registered file_id=%s", file_id)
 
         try:
-            async with aiohttp.ClientSession(
-                proxy=self.app.config.proxy,
-            ) as session:
-                async with session.post(
+            async with (
+                aiohttp.ClientSession(proxy=self.app.config.proxy, timeout=timeout) as session,
+                session.post(
                     url=upload_info.url,
                     headers=headers,
                     data=file.iter_chunks(1024 * 1024),
-                ) as response:
-                    logger.debug(
-                        "File upload HTTP response status=%s file_id=%s",
+                ) as response,
+            ):
+                logger.debug(
+                    "File upload HTTP response status=%s file_id=%s",
+                    response.status,
+                    file_id,
+                )
+
+                if response.status != HTTPStatus.OK:
+                    logger.error(
+                        "File upload failed with status %s file_id=%s",
                         response.status,
                         file_id,
                     )
+                    raise UploadError(
+                        f"File upload failed with status {response.status} file_id={file_id}"
+                    )
 
-                    if response.status != HTTPStatus.OK:
-                        logger.error(
-                            "File upload failed with status %s file_id=%s",
-                            response.status,
-                            file_id,
-                        )
-                        raise UploadError(
-                            f"File upload failed with status {response.status} file_id={file_id}"
-                        )
-
-                    try:
-                        logger.debug(
-                            "Waiting for file processing notification file_id=%s",
-                            file_id,
-                        )
-                        await asyncio.wait_for(future, 60)
-                    except asyncio.TimeoutError:
-                        logger.warning(
-                            "Timed out waiting for file processing notification file_id=%s",
-                            file_id,
-                        )
-                        raise UploadError(
-                            f"Timed out waiting for file processing file_id={file_id}"
-                        )
+                try:
+                    logger.debug(
+                        "Waiting for file processing notification file_id=%s",
+                        file_id,
+                    )
+                    await asyncio.wait_for(future, 60)
+                except asyncio.TimeoutError:
+                    logger.warning(
+                        "Timed out waiting for file processing notification file_id=%s",
+                        file_id,
+                    )
+                    raise UploadError(f"Timed out waiting for file processing file_id={file_id}")
 
-                    logger.debug("File upload complete file_id=%s", file_id)
-                    return AttachFilePayload(file_id=file_id)
+                logger.debug("File upload complete file_id=%s", file_id)
+                return AttachFilePayload(file_id=file_id)
 
         except UploadError:
             raise

pymax/app.py

@@ -12,8 +12,8 @@ from pymax.fingerprint import FingerprintGenerator
 from pymax.logging import get_logger
 from pymax.protocol import Command, InboundFrame, OutboundFrame
 from pymax.protocol.enums import Opcode
-from pymax.session import SessionStore
-from pymax.session.models import SessionInfo
+from pymax.session import InMemoryStore, SessionStore
+from pymax.session.models import SessionInfo, resolve_session_user_agent
 from pymax.telemetry import TelemetryService
 from pymax.types import MaxApiError, Message
 from pymax.types.domain import Chat, HandshakeResponse, Login2Response, Profile, User
@@ -38,9 +38,15 @@ class App(Generic[ClientT]):
         self.dispatcher: Dispatcher[ClientT] = Dispatcher(self, root_router)
         self.api = ApiFacade(self)
         self.config = config
-        self.store = self.config.store or SessionStore(config.work_dir, config.session_name)
+        self.store = (
+            (self.config.store or SessionStore(config.work_dir, config.session_name))
+            if self.config.persist_session
+            else InMemoryStore()
+        )
         self.auth_flow = auth_flow
-        self.fingerprint_generator = FingerprintGenerator()
+        self.fingerprint_generator: FingerprintGenerator | None = (
+            FingerprintGenerator(self.config.fingering) if self.config.fingering else None
+        )
 
         self.me: Profile | None = None
         self.chats: list[Chat] | None = None
@@ -77,6 +83,17 @@ class App(Generic[ClientT]):
             else:
                 session_data.mt_instance_id = self.config.device.mt_instance_id
 
+            if self.config.restore_user_agent_from_session:
+                user_agent = resolve_session_user_agent(
+                    self.config.device.user_agent,
+                    session_data.user_agent,
+                )
+            else:
+                user_agent = self.config.device.user_agent
+            self.config.device.user_agent = user_agent
+            if session_data.user_agent != user_agent:
+                session_data = session_data.model_copy(update={"user_agent": user_agent})
+
         try:
             logger.debug("opening connection")
             await self.connection.open()
@@ -105,6 +122,7 @@ class App(Generic[ClientT]):
                         device_id=self.config.device.device_id,
                         phone=self.config.phone or "",
                         mt_instance_id=self.config.device.mt_instance_id,
+                        user_agent=self.config.device.user_agent,
                     )
                 )
             else:
@@ -120,6 +138,7 @@ class App(Generic[ClientT]):
                         device_id=self.config.device.device_id,
                         phone=self.config.phone or "",
                         mt_instance_id=self.config.device.mt_instance_id,
+                        user_agent=self.config.device.user_agent,
                     )
                 )
                 logger.info("new session saved")

pymax/auth/__init__.py

@@ -1,4 +1,5 @@
 from .base import AuthFlow
+from .exceptions import PasswordAttemptsExceededError
 from .providers import (
     ConsolePasswordProvider,
     ConsoleQrHandler,
@@ -17,6 +18,7 @@ __all__ = (
     "ConsoleQrHandler",
     "ConsoleSmsCodeProvider",
     "EmailCodeProvider",
+    "PasswordAttemptsExceededError",
     "PasswordProvider",
     "QrAuthFlow",
     "QrHandler",

pymax/auth/exceptions.py

@@ -0,0 +1,9 @@
+class PasswordAttemptsExceededError(Exception):
+    """Исчерпан лимит попыток ввода пароля 2FA.
+
+    Наследуется напрямую от ``Exception`` и не перехватывается как
+    ``PyMaxError``.
+    """
+
+    def __init__(self) -> None:
+        super().__init__("2FA password attempts exhausted")

pymax/auth/providers.py

@@ -113,7 +113,11 @@ class EmailCodeProvider(Protocol):
 
 
 class ConsoleEmailCodeProvider:
-    """Консольный provider кода подтверждения email для 2FA."""
+    """Консольный provider кода подтверждения email для 2FA.
+
+    Блокирующий ``input()`` выполняется в worker thread и не останавливает
+    asyncio event loop.
+    """
 
     async def get_code(self, email: str) -> str:
         """Запрашивает email-код в консоли.
@@ -124,4 +128,4 @@ class ConsoleEmailCodeProvider:
         Returns:
             Введенный пользователем код.
         """
-        return input(f"Enter 2FA email code for {email}: ").strip()
+        return (await asyncio.to_thread(input, f"Enter 2FA email code for {email}: ")).strip()

pymax/auth/sms.py

@@ -6,6 +6,7 @@ from pymax.auth.base import AuthFlow
 from pymax.exceptions import ApiError
 from pymax.logging import get_logger
 
+from .exceptions import PasswordAttemptsExceededError
 from .models import AuthResult
 from .providers import (
     ConsolePasswordProvider,
@@ -116,7 +117,10 @@ class SmsAuthFlow(AuthFlow):
         hint: str | None,
     ) -> str:
         logger.info("starting 2fa password authentication")
-        while True:
+        attempt = 0
+        while (
+            app.config.password_max_attempts is None or app.config.password_max_attempts > attempt
+        ):
             password = await self.password_provider.get_password(hint)
             logger.debug(
                 "2fa password provider returned password_set=%s",
@@ -124,16 +128,19 @@ class SmsAuthFlow(AuthFlow):
             )
             if not password:
                 logger.warning("2fa password is empty; retrying")
+                attempt += 1
                 continue
 
             try:
                 response = await app.api.auth.check_password(track_id, password)
             except ApiError as e:
                 logger.error("2fa password check failed: %s", e)
+                attempt += 1
                 continue
 
             if response.error:
                 logger.error("2fa password check failed error=%s", response.error)
+                attempt += 1
                 continue
 
             if response.login_token:
@@ -141,3 +148,6 @@ class SmsAuthFlow(AuthFlow):
                 return response.login_token
 
             logger.error("2fa password response did not contain login token; retrying")
+            attempt += 1
+
+        raise PasswordAttemptsExceededError