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

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

@@ -13,6 +13,10 @@ 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
 
 
 class AttachFilePayload(CamelModel):
@@ -22,4 +26,6 @@ class AttachFilePayload(CamelModel):
 
 class UploadPayload(CamelModel):
     count: int = 1
+    type: int = 0
+    uploader_type: int = 0
     profile: bool = False

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 AttachmentType, AudioUploadSignal
 
 from .models import (
     FileUploadResponse,
@@ -40,14 +42,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 +182,146 @@ 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) -> VideoAttachPayload:
+        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
+
+        headers = {
+            "Content-Disposition": f"attachment; filename={quote(voice.name)}",
+            "Content-Range": f"0-{file_size - 1}/{file_size}",
+            "Content-Length": str(file_size),
+            "Connection": "keep-alive",
+            "Content-Type": "application/octet-stream",
+        }
+
+        logger.debug(
+            "Voice upload headers prepared content_range=%s",
+            headers["Content-Range"],
+        )
+
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[AudioUploadSignal] = loop.create_future()
+
+        timeout = aiohttp.ClientTimeout(total=900, 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:
+            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}"
+                        )
+
+                    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
+                    )
+
+        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:
         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 +355,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
@@ -230,8 +369,8 @@ class UploadService:
         timeout = aiohttp.ClientTimeout(total=900, 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(uploadable_video.name)}",
+            "Content-Range": f"bytes 0-{file_size - 1}/{file_size}",
             "Content-Length": str(file_size),
             "Connection": "keep-alive",
         }
@@ -240,15 +379,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 +399,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 +419,33 @@ 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 VideoAttachPayload(
+                                video_id=video_id,
+                                token=token,
+                                video_type=1,
+                                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 +456,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 +477,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(
@@ -430,6 +593,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,6 +8,7 @@ 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
@@ -15,7 +16,8 @@ from pymax.session import SessionStore
 from pymax.session.models import SessionInfo
 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
@@ -38,6 +40,7 @@ class App(Generic[ClientT]):
         self.config = config
         self.store = self.config.store or SessionStore(config.work_dir, config.session_name)
         self.auth_flow = auth_flow
+        self.fingerprint_generator = FingerprintGenerator()
 
         self.me: Profile | None = None
         self.chats: list[Chat] | None = None
@@ -46,6 +49,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
@@ -81,12 +85,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:
@@ -129,10 +135,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 +170,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 +198,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 +300,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/base.py

@@ -7,6 +7,7 @@ from uuid import uuid4
 
 from pymax.dispatch import ErrorScope, Router
 from pymax.dispatch.router import DisconnectDecorator, ErrorDecorator
+from pymax.exceptions import ApiError
 from pymax.infra import BaseMixin
 from pymax.logging import get_logger
 
@@ -138,6 +139,13 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
             except asyncio.CancelledError:
                 await self.close()
                 raise
+            except ApiError as e:
+                if not self._app._is_invalid_login_token_error(e):
+                    await self.close()
+                    raise
+
+                logger.warning("login token was revoked; starting authentication again")
+                await self.relogin(start=False)
             except (  # noqa: PERF203
                 ConnectionError,
                 EOFError,

pymax/client_web.py

@@ -6,7 +6,7 @@ from pymax.auth.qr import QrAuthFlow
 from pymax.connection import ConnectionManager
 from pymax.connection.readers import WSReader
 from pymax.logging import configure_logging, get_logger
-from pymax.protocol.ws import WsProtocol
+from pymax.protocol.tcp import TcpProtocol
 from pymax.transport.websocket import WebSocketTransport
 
 from .base import BaseClient
@@ -80,5 +80,5 @@ class WebClient(BaseClient["WebClient"]):
         return ConnectionManager(
             reader=reader,
             transport=transport,
-            protocol=WsProtocol(),
+            protocol=TcpProtocol(),
         )