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

pymax/api/uploads/service.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import base64
 from http import HTTPStatus
 from typing import TYPE_CHECKING
 from urllib.parse import parse_qs, quote, urlparse
@@ -11,9 +12,10 @@ from pydantic import ValidationError
 from pymax.api.response import payload_item
 from pymax.dispatch.enums import EventType
 from pymax.exceptions import UploadError
-from pymax.files import File, Photo, Video
+from pymax.files import File, Photo, Video, VideoNote, Voice
 from pymax.logging import get_logger
 from pymax.protocol import Opcode
+from pymax.types import AudioUploadSignal
 
 from .models import (
     FileUploadResponse,
@@ -25,6 +27,8 @@ from .payloads import (
     AttachPhotoPayload,
     UploadPayload,
     VideoAttachPayload,
+    VideoNoteAttachPayload,
+    VoiceAttachPayload,
 )
 
 if TYPE_CHECKING:
@@ -40,14 +44,16 @@ class UploadService:
         self.app = app
         self.video_upload_waiters: dict[int, asyncio.Future[VideoUploadSignal]] = {}
         self.file_upload_waiters: dict[int, asyncio.Future[FileUploadSignal]] = {}
+        self.voice_upload_waiters: dict[int, asyncio.Future[AudioUploadSignal]] = {}
         self.app.dispatcher.on_internal(EventType.VIDEO_READY)(self.on_video_attach)
         self.app.dispatcher.on_internal(EventType.FILE_READY)(self.on_file_attach)
+        self.app.dispatcher.on_internal(EventType.VOICE_READY)(self.on_voice_attach)
 
     async def upload_photo(self, photo: Photo, profile: bool = False) -> AttachPhotoPayload:
         logger.info("Uploading photo")
         logger.debug("Preparing photo upload payload")
 
-        payload = UploadPayload(profile=profile).model_dump()
+        payload = UploadPayload(profile=profile).to_payload()
 
         try:
             data = await self.app.invoke(
@@ -178,11 +184,160 @@ class UploadService:
         logger.debug("Photo upload complete photo_id=%s", photo_id)
         return AttachPhotoPayload(photo_token=token)
 
-    async def upload_video(self, video: Video) -> VideoAttachPayload:
+    async def upload_voice(self, voice: Voice) -> VoiceAttachPayload:
+        logger.info("Uploading voice")
+
+        payload = UploadPayload(
+            type=2,
+            uploader_type=1,
+        ).to_payload()
+
+        try:
+            data = await self.app.invoke(
+                Opcode.VIDEO_UPLOAD,
+                payload=payload,
+            )
+        except Exception as e:
+            logger.exception("Failed to request voice upload URL")
+            raise UploadError("Failed to request voice upload URL") from e
+
+        try:
+            response = VideoUploadResponse.model_validate(data.payload)
+        except ValidationError as e:
+            logger.exception("Invalid voice upload response model")
+            logger.debug("Invalid voice upload payload=%r", data.payload)
+            raise UploadError("Invalid voice upload response model") from e
+        except Exception as e:
+            logger.exception("Failed to parse voice upload response")
+            logger.debug("Invalid voice upload payload=%r", data.payload)
+            raise UploadError("Failed to parse voice upload response") from e
+
+        try:
+            upload_info = response.info[0]
+        except IndexError as e:
+            logger.error("voice upload response info is empty")
+            logger.debug("voice upload response=%r", response)
+            raise UploadError("voice upload response info is empty") from e
+        except Exception as e:
+            logger.exception("Failed to get voice upload info")
+            logger.debug("voice upload response=%r", response)
+            raise UploadError("Failed to get voice upload info") from e
+
+        try:
+            file_size = await voice.size()
+        except Exception as e:
+            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"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(
+            "Voice upload headers prepared content_range=%s",
+            headers["Content-Range"],
+        )
+
+        timeout = aiohttp.ClientTimeout(total=self.app.config.upload_timeout, sock_read=60)
+
+        video_id = upload_info.video_id
+        token = upload_info.token
+
+        logger.debug("Voice upload waiter registered voice_id=%s", video_id)
+
+        try:
+            async with aiohttp.ClientSession(
+                timeout=timeout, proxy=self.app.config.proxy
+            ) as session:
+                logger.debug("Starting voice upload HTTP request voice_id=%s", video_id)
+
+                async with session.post(
+                    url=upload_info.url,
+                    headers=headers,
+                    data=voice.iter_chunks(1024 * 1024),
+                ) as response:
+                    logger.debug(
+                        "Voice upload HTTP response status=%s voice_id=%s",
+                        response.status,
+                        video_id,
+                    )
+
+                    if response.status != HTTPStatus.OK:
+                        logger.error(
+                            "Voice upload failed with status %s video_id=%s",
+                            response.status,
+                            video_id,
+                        )
+                        raise UploadError(
+                            "Voice upload failed with status "
+                            f"{response.status} 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 VoiceAttachPayload(
+                        video_id=video_id,
+                        token=token,
+                        duration=await voice.get_duration(),
+                        wave=b"\x00" * 80,
+                    )
+
+        except UploadError:
+            raise
+        except aiohttp.ClientError as e:
+            logger.exception("HTTP error during voice upload voice_id=%s", video_id)
+            raise UploadError(f"HTTP error during voice upload voice_id={video_id}") from e
+        except asyncio.TimeoutError as e:
+            logger.exception("Timed out during voice upload voice_id=%s", video_id)
+            raise UploadError(f"Timed out during voice upload voice_id={video_id}") from e
+        except Exception as e:
+            logger.exception("Unexpected error during voice upload voice_id=%s", video_id)
+            raise UploadError(f"Unexpected error during voice upload voice_id={video_id}") from e
+        finally:
+            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 | VideoNoteAttachPayload:
         logger.info("Uploading video")
         logger.debug("Preparing video upload payload")
 
-        payload = UploadPayload().model_dump()
+        if isinstance(uploadable_video, VideoNote):
+            payload = UploadPayload(type=1, uploader_type=1).to_payload()
+        else:
+            payload = UploadPayload().to_payload()
 
         try:
             data = await self.app.invoke(
@@ -216,7 +371,7 @@ class UploadService:
             raise UploadError("Failed to get video upload info") from e
 
         try:
-            file_size = await video.size()
+            file_size = await uploadable_video.size()
         except Exception as e:
             logger.exception("Failed to get video size")
             raise UploadError("Failed to get video size") from e
@@ -227,11 +382,11 @@ 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(video.name)}",
-            "Content-Range": f"0-{file_size - 1}/{file_size}",
+            "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",
         }
@@ -240,15 +395,16 @@ class UploadService:
             "Video upload headers prepared content_range=%s",
             headers["Content-Range"],
         )
-
-        loop = asyncio.get_running_loop()
-        future: asyncio.Future[VideoUploadSignal] = loop.create_future()
-
-        video_id = upload_info.video_id
         token = upload_info.token
+        video_id = upload_info.video_id
+
+        future = None
+        if not isinstance(uploadable_video, VideoNote):
+            loop = asyncio.get_running_loop()
+            future = loop.create_future()
+            self.video_upload_waiters[video_id] = future
 
-        self.video_upload_waiters[video_id] = future
-        logger.debug("Video upload waiter registered video_id=%s", video_id)
+            logger.debug("Video upload waiter registered video_id=%s", video_id)
 
         try:
             async with aiohttp.ClientSession(
@@ -259,7 +415,7 @@ class UploadService:
                 async with session.post(
                     url=upload_info.url,
                     headers=headers,
-                    data=video.iter_chunks(1024 * 1024),
+                    data=uploadable_video.iter_chunks(1024 * 1024),
                 ) as response:
                     logger.debug(
                         "Video upload HTTP response status=%s video_id=%s",
@@ -279,11 +435,32 @@ class UploadService:
                         )
 
                     try:
-                        logger.debug(
-                            "Waiting for video processing notification video_id=%s",
-                            video_id,
-                        )
-                        await asyncio.wait_for(future, 60)
+                        if isinstance(uploadable_video, VideoNote):
+                            data = await response.json(content_type=None)
+
+                            thumbhash = data.get("thumbhash")
+                            if thumbhash:
+                                thumbhash += "=" * (-len(thumbhash) % 4)
+                                thumbhash = base64.b64decode(thumbhash)
+
+                            return VideoNoteAttachPayload(
+                                video_id=video_id,
+                                token=token,
+                                thumbhash=thumbhash,
+                                duration=await uploadable_video.get_duration(),
+                            )
+                        else:
+                            if future is None:
+                                raise ValueError(
+                                    "Unexpected internal state: "
+                                    + "future is missing in UploadService.upload_video."
+                                    + f" video type = {type(uploadable_video)}"
+                                )
+                            logger.debug(
+                                "Waiting for video processing notification video_id=%s",
+                                video_id,
+                            )
+                            await asyncio.wait_for(future, 60)
                     except asyncio.TimeoutError:
                         logger.warning(
                             "Timed out waiting for video processing notification video_id=%s",
@@ -294,6 +471,7 @@ class UploadService:
                         )
 
                     logger.debug("Video upload complete video_id=%s", video_id)
+
                     return VideoAttachPayload(video_id=video_id, token=token)
 
         except UploadError:
@@ -314,7 +492,7 @@ class UploadService:
     async def upload_file(self, file: File) -> AttachFilePayload:
         logger.info("Uploading file")
 
-        payload = UploadPayload().model_dump()
+        payload = UploadPayload().to_payload()
 
         try:
             data = await self.app.invoke(
@@ -369,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
@@ -430,6 +608,20 @@ class UploadService:
             self.file_upload_waiters.pop(file_id, None)
             logger.debug("File upload waiter removed file=%s", file_id)
 
+    async def on_voice_attach(self, attach: AudioUploadSignal, _: Client) -> None:
+        future = self.voice_upload_waiters.pop(attach.audio_id, None)
+
+        if not future:
+            logger.debug("No voice upload waiter found voice_id=%s", attach.audio_id)
+            return
+
+        if future.done():
+            logger.debug("Voice upload waiter already done voice_id=%s", attach.audio_id)
+            return
+
+        future.set_result(attach)
+        logger.debug("Voice upload waiter resolved voice_id=%s", attach.audio_id)
+
     async def on_video_attach(self, attach: VideoUploadSignal, _: Client) -> None:
         logger.debug("Received attach event video_id=%s", attach.video_id)
 

pymax/app.py

@@ -8,14 +8,16 @@ from pymax.connection import ConnectionManager
 from pymax.dispatch import Dispatcher
 from pymax.dispatch.router import EventType, Router
 from pymax.exceptions import ApiError
+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, Profile, User
+from pymax.types.domain import Chat, HandshakeResponse, Login2Response, Profile, User
+from pymax.types.domain.login import LoginResponse
 
 if TYPE_CHECKING:
     from pymax.base import BaseClient
@@ -36,8 +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 | None = (
+            FingerprintGenerator(self.config.fingering) if self.config.fingering else None
+        )
 
         self.me: Profile | None = None
         self.chats: list[Chat] | None = None
@@ -46,6 +55,7 @@ class App(Generic[ClientT]):
         self.messages: dict[int, list[Message]] = {}
 
         self.session: SessionInfo | None = None
+        self.handshake_response: HandshakeResponse | None = None
 
         self.started = False
         self._ping_task: asyncio.Task[None] | None = None
@@ -73,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()
@@ -81,12 +102,14 @@ class App(Generic[ClientT]):
                 session_data.device_id if session_data else self.config.device.device_id
             )
             logger.debug("running handshake")
-            await self.handshake(handshake_device_id)
+            handshake_response = await self.handshake(handshake_device_id)
         except (ConnectionError, EOFError, OSError, TimeoutError) as e:
             logger.exception("failed to connect or handshake")
             await self.connection.close()
             raise ConnectionError(f"Failed to connect and handshake: {e}") from e
 
+        self.handshake_response = handshake_response
+
         self._ping_task = asyncio.create_task(self._ping_loop())
 
         if not session_data:
@@ -99,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:
@@ -114,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")
@@ -129,10 +154,26 @@ class App(Generic[ClientT]):
         logger.debug("logging in")
 
         try:
-            response = await self.api.auth.login(
-                self.config.device.user_agent,
-            )
+            login_response, login2_response = await self.login()
+
+            if (
+                login2_response
+                and login_response.login2_flags
+                and login_response.login2_flags.profile_enabled
+                and login2_response.profile
+            ):
+                self.me = login2_response.profile
+            elif login_response.profile:
+                self.me = login_response.profile
+            elif login2_response and login2_response.profile:
+                self.me = login2_response.profile
+            else:
+                logger.error("Unexpected internal state: login response does not contain profile")
+                raise RuntimeError("Login response does not contain profile")
         except Exception as e:
+            if self._is_invalid_login_token_error(e):
+                raise
+
             handled = False
             if self.dispatcher.client is not None:
                 handled = await self.dispatcher.emit_error(
@@ -148,15 +189,23 @@ class App(Generic[ClientT]):
             await self.close()
             return
 
-        if response.token is not None and response.token != self.session.token:
-            await self.store.update_token(self.session.token, response.token)
-            self.session.token = response.token
+        if login_response.token is not None and login_response.token != self.session.token:
+            await self.store.update_token(self.session.token, login_response.token)
+            self.session.token = login_response.token
 
-        self.me = response.profile
-        self.chats = response.chats
+        self.chats = login_response.chats
         self.users[self.me.contact.id] = self.me.contact
-        self.contacts = response.contacts
-        self.messages = response.messages
+
+        if (
+            login2_response
+            and login_response.login2_flags
+            and login_response.login2_flags.contact_enabled
+        ):
+            self.contacts = login2_response.contacts
+        else:
+            self.contacts = login_response.contacts
+
+        self.messages = login_response.messages
 
         self.started = True
         logger.info(
@@ -168,13 +217,37 @@ class App(Generic[ClientT]):
         if self._telemetry:
             self._telemetry.start()
 
-    async def handshake(self, device_id: str) -> None:
-        await self.api.session.handshake(
+    @staticmethod
+    def _is_invalid_login_token_error(exc: Exception) -> bool:
+        return (
+            isinstance(exc, ApiError)
+            and exc.opcode == Opcode.LOGIN
+            and any(
+                err in (exc.error, exc.message) for err in ("FAIL_LOGIN_TOKEN", "FAIL_LOGOUT_ALL")
+            )
+        )
+
+    async def login(self) -> tuple[LoginResponse, Login2Response | None]:
+        login_response = await self.api.auth.login(
+            self.config.device.user_agent,
+        )
+
+        if login_response.login2_flags and login_response.login2_flags.enabled:
+            logger.debug("login2 required; proceeding with login2")
+            login2_response = await self.api.auth.mobile_login2(login_response.login2_flags)
+
+            return login_response, login2_response
+
+        return login_response, None
+
+    async def handshake(self, device_id: str) -> HandshakeResponse:
+        response = await self.api.session.handshake(
             self.config.device.mt_instance_id,
             self.config.device.user_agent,
             device_id,
         )
         logger.debug("handshake completed device_id=%s", device_id)
+        return response
 
     async def close(self) -> None:
         if self._telemetry:
@@ -246,7 +319,7 @@ class App(Generic[ClientT]):
             while True:
                 await self.invoke(
                     opcode=Opcode.PING,
-                    payload={"interactive": True},
+                    payload={"interactive": self.config.interactive},
                     timeout=self.config.request_timeout,
                 )
                 await asyncio.sleep(30)

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()