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

pymax/api/session/payloads.py

@@ -0,0 +1,76 @@
+from random import randint
+
+from pydantic import Field
+
+from pymax.api.models import CamelModel
+
+from .enums import DeviceType
+
+DEFAULT_WEB_HEADER_USER_AGENT = (
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36"
+)
+WEB_USER_AGENT_ALIASES = (
+    "deviceType",
+    "locale",
+    "deviceLocale",
+    "osVersion",
+    "deviceName",
+    "headerUserAgent",
+    "appVersion",
+    "screen",
+    "timezone",
+)
+
+
+class MobileUserAgentPayload(CamelModel):
+    """User-agent payload, который PyMax отправляет в Max.
+
+    Обычно его создает ``ExtraConfig.generate_user_agent()`` или
+    ``ExtraConfig.generate_web_user_agent()``. Передавайте собственный объект
+    в ``ExtraConfig(user_agent=...)`` только если нужно явно управлять
+    device/app параметрами.
+    """
+
+    device_type: DeviceType
+    app_version: str
+    os_version: str
+    timezone: str
+    screen: str
+    push_device_type: str | None = None
+    arch: str | None = None
+    locale: str
+    build_number: int | None = None
+    device_name: str
+    device_locale: str
+    release: int | None = None
+    header_user_agent: str | None = None
+
+    def to_web_payload(self) -> dict:
+        """Возвращает payload в формате, который ожидает web-login."""
+        payload = self.model_dump(
+            by_alias=True,
+            exclude_none=True,
+        )
+        if self.device_type == DeviceType.WEB and "headerUserAgent" not in payload:
+            payload["headerUserAgent"] = DEFAULT_WEB_HEADER_USER_AGENT
+
+        return {alias: payload[alias] for alias in WEB_USER_AGENT_ALIASES if alias in payload}
+
+
+class MobileHandshakePayload(CamelModel):
+    mt_instance_id: str = Field(..., alias="mt_instanceid")
+    user_agent: MobileUserAgentPayload
+    client_session_id: int = Field(default_factory=lambda: randint(1, 70))
+    device_id: str
+
+
+class WebHandshakePayload(CamelModel):
+    user_agent: MobileUserAgentPayload
+    device_id: str
+
+    def to_payload(self) -> dict:
+        return {
+            "userAgent": self.user_agent.to_web_payload(),
+            "deviceId": self.device_id,
+        }

pymax/api/session/service.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pymax.logging import get_logger
+from pymax.protocol import Opcode
+
+from .enums import DeviceType
+from .payloads import (
+    MobileHandshakePayload,
+    MobileUserAgentPayload,
+    WebHandshakePayload,
+)
+
+if TYPE_CHECKING:
+    from pymax.app import App
+
+
+logger = get_logger(__name__)
+
+
+class SessionService:
+    def __init__(self, app: App) -> None:
+        self.app = app
+
+    async def handshake(
+        self,
+        mt_instance_id: str,
+        user_agent: MobileUserAgentPayload,
+        device_id: str,
+    ) -> None:
+        if user_agent.device_type == DeviceType.WEB:
+            await self.web_handshake(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:
+        logger.debug(
+            "mobile handshake mt_instance_id_set=%s device_id=%s app_version=%s",
+            bool(mt_instance_id),
+            device_id,
+            user_agent.app_version,
+        )
+        frame = MobileHandshakePayload(
+            mt_instanceid=mt_instance_id,
+            user_agent=user_agent,
+            device_id=device_id,
+        )
+        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:
+        logger.debug(
+            "web handshake device_id=%s app_version=%s browser=%s",
+            device_id,
+            user_agent.app_version,
+            user_agent.device_name,
+        )
+        frame = WebHandshakePayload(
+            user_agent=user_agent,
+            device_id=device_id,
+        )
+        await self.app.invoke(Opcode.SESSION_INIT, frame.to_payload())
+        logger.info("web handshake completed")

pymax/api/uploads/__init__.py

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

pymax/api/uploads/models.py

@@ -0,0 +1,49 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from pymax.api.models import CamelModel
+from pymax.types import AttachmentType
+
+
+class PhotoPayloadResponse(BaseModel):
+    token: str
+
+
+class PhotoUploadResponse(BaseModel):
+    photos: dict[str, PhotoPayloadResponse]
+
+
+class VideoPayloadResponse(CamelModel):
+    url: str
+    video_id: int
+    token: str
+
+
+class VideoUploadResponse(BaseModel):
+    info: list[VideoPayloadResponse]
+
+
+class FilePayloadResponse(CamelModel):
+    url: str
+    file_id: int
+    token: str
+
+
+class FileUploadResponse(BaseModel):
+    info: list[FilePayloadResponse]
+
+
+# class PhotoUploadResult(CamelModel):
+#     type: Literal[AttachmentType.PHOTO] = Field(
+#         serialization_alias="_type", default=AttachmentType.PHOTO
+#     )
+#     photo_token: str
+
+
+# class VideoUploadResult(CamelModel):
+#     type: Literal[AttachmentType.VIDEO] = Field(
+#         serialization_alias="_type", default=AttachmentType.VIDEO
+#     )
+#     video_id: int
+#     token: str

pymax/api/uploads/payloads.py

@@ -0,0 +1,25 @@
+from pydantic import Field
+
+from pymax.api.models import CamelModel
+from pymax.types import AttachmentType
+
+
+class AttachPhotoPayload(CamelModel):
+    type: AttachmentType = Field(default=AttachmentType.PHOTO, serialization_alias="_type")
+    photo_token: str
+
+
+class VideoAttachPayload(CamelModel):
+    type: AttachmentType = Field(default=AttachmentType.VIDEO, serialization_alias="_type")
+    video_id: int
+    token: str
+
+
+class AttachFilePayload(CamelModel):
+    type: AttachmentType = Field(default=AttachmentType.FILE, serialization_alias="_type")
+    file_id: int
+
+
+class UploadPayload(CamelModel):
+    count: int = 1
+    profile: bool = False

pymax/api/uploads/service.py

@@ -0,0 +1,458 @@
+from __future__ import annotations
+
+import asyncio
+from http import HTTPStatus
+from typing import TYPE_CHECKING
+from urllib.parse import parse_qs, quote, urlparse
+
+import aiohttp
+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.logging import get_logger
+from pymax.protocol import Opcode
+
+from .models import (
+    FileUploadResponse,
+    PhotoUploadResponse,
+    VideoUploadResponse,
+)
+from .payloads import (
+    AttachFilePayload,
+    AttachPhotoPayload,
+    UploadPayload,
+    VideoAttachPayload,
+)
+
+if TYPE_CHECKING:
+    from pymax import Client
+    from pymax.app import App
+    from pymax.types.events import FileUploadSignal, VideoUploadSignal
+
+logger = get_logger(__name__)
+
+
+class UploadService:
+    def __init__(self, app: App) -> None:
+        self.app = app
+        self.video_upload_waiters: dict[int, asyncio.Future[VideoUploadSignal]] = {}
+        self.file_upload_waiters: dict[int, asyncio.Future[FileUploadSignal]] = {}
+        self.app.dispatcher.on_internal(EventType.VIDEO_READY)(self.on_video_attach)
+        self.app.dispatcher.on_internal(EventType.FILE_READY)(self.on_file_attach)
+
+    async def upload_photo(self, photo: Photo) -> AttachPhotoPayload:
+        logger.info("Uploading photo")
+        logger.debug("Preparing photo upload payload")
+
+        payload = UploadPayload().model_dump()
+
+        try:
+            data = await self.app.invoke(
+                Opcode.PHOTO_UPLOAD,
+                payload=payload,
+            )
+        except Exception as e:
+            logger.exception("Failed to request photo upload URL")
+            raise UploadError("Failed to request photo upload URL") from e
+
+        try:
+            url = payload_item(data, "url", str)  # TODO: ENUM!!!!
+        except Exception as e:
+            logger.exception("Failed to parse photo upload URL from response")
+            raise UploadError("Failed to parse photo upload URL from response") from e
+
+        if not url:
+            logger.error("No upload URL received")
+            logger.debug(
+                "Photo upload URL response payload=%r",
+                getattr(data, "payload", None),
+            )
+            raise UploadError("No upload URL received")
+
+        logger.debug("Photo upload URL received")
+
+        try:
+            parsed_url = urlparse(url)
+            photo_id = str(parse_qs(parsed_url.query)["photoIds"][0])
+        except (KeyError, IndexError) as e:
+            logger.exception("Photo upload URL does not contain photoIds")
+            logger.debug("Invalid photo upload URL=%s", url)
+            raise UploadError("Photo upload URL does not contain photoIds") from e
+        except Exception as e:
+            logger.exception("Failed to parse photo id from upload URL")
+            logger.debug("Invalid photo upload URL=%s", url)
+            raise UploadError("Failed to parse photo id from upload URL") from e
+
+        logger.debug("Photo upload id parsed photo_id=%s", photo_id)
+
+        try:
+            photo_data = photo.validate_photo()
+        except Exception as e:
+            logger.exception("Photo validation crashed")
+            raise UploadError("Photo validation crashed") from e
+
+        if not photo_data:
+            logger.error("Photo validation failed")
+            raise UploadError("Photo validation failed")
+
+        logger.debug(
+            "Photo validated extension=%s content_type=%s",
+            photo_data[0],
+            photo_data[1],
+        )
+
+        try:
+            photo_bytes = await photo.read()
+        except Exception as e:
+            logger.exception("Failed to read photo bytes")
+            raise UploadError("Failed to read photo bytes") from e
+
+        logger.debug("Photo read complete size=%s", len(photo_bytes))
+
+        form = aiohttp.FormData()
+        form.add_field(
+            name="file",
+            value=photo_bytes,
+            filename=f"image.{quote(photo_data[0])}",
+            content_type=photo_data[1],
+        )
+
+        try:
+            async with (
+                aiohttp.ClientSession() as session,
+                session.post(
+                    url=url,
+                    data=form,
+                ) as response,
+            ):
+                logger.debug("Photo upload HTTP response status=%s", response.status)
+
+                if response.status != HTTPStatus.OK:
+                    logger.error("Photo upload failed with status %s", response.status)
+                    raise UploadError(f"Photo upload failed with status {response.status}")
+
+                try:
+                    result = await response.json()
+                except Exception as e:
+                    logger.exception("Failed to decode photo upload response JSON")
+                    raise UploadError("Failed to decode photo upload response JSON") from e
+
+        except UploadError:
+            raise
+        except aiohttp.ClientError as e:
+            logger.exception("HTTP error during photo upload")
+            raise UploadError("HTTP error during photo upload") from e
+        except asyncio.TimeoutError as e:
+            logger.exception("Timed out during photo upload")
+            raise UploadError("Timed out during photo upload") from e
+        except Exception as e:
+            logger.exception("Unexpected error during photo upload")
+            raise UploadError("Unexpected error during photo upload") from e
+
+        try:
+            model = PhotoUploadResponse.model_validate(result)
+        except ValidationError as e:
+            logger.exception("Invalid photo upload response model")
+            logger.debug("Invalid photo upload response=%r", result)
+            raise UploadError("Invalid photo upload response model") from e
+
+        try:
+            token = model.photos[photo_id].token
+        except KeyError as e:
+            logger.exception(
+                "Photo upload response does not contain token for photo_id=%s",
+                photo_id,
+            )
+            logger.debug("Photo upload model=%r", model)
+            raise UploadError(
+                f"Photo upload response does not contain token for photo_id={photo_id}"
+            ) from e
+        except Exception as e:
+            logger.exception("Failed to extract photo token")
+            logger.debug("Photo upload model=%r", model)
+            raise UploadError("Failed to extract photo token") from e
+
+        logger.debug("Photo upload complete photo_id=%s", photo_id)
+        return AttachPhotoPayload(photo_token=token)
+
+    async def upload_video(self, video: Video) -> VideoAttachPayload:
+        logger.info("Uploading video")
+        logger.debug("Preparing video upload payload")
+
+        payload = UploadPayload().model_dump()
+
+        try:
+            data = await self.app.invoke(
+                Opcode.VIDEO_UPLOAD,
+                payload=payload,
+            )
+        except Exception as e:
+            logger.exception("Failed to request video upload URL")
+            raise UploadError("Failed to request video upload URL") from e
+
+        try:
+            response = VideoUploadResponse.model_validate(data.payload)
+        except ValidationError as e:
+            logger.exception("Invalid video upload response model")
+            logger.debug("Invalid video upload payload=%r", data.payload)
+            raise UploadError("Invalid video upload response model") from e
+        except Exception as e:
+            logger.exception("Failed to parse video upload response")
+            logger.debug("Invalid video upload payload=%r", data.payload)
+            raise UploadError("Failed to parse video upload response") from e
+
+        try:
+            upload_info = response.info[0]
+        except IndexError as e:
+            logger.error("Video upload response info is empty")
+            logger.debug("Video upload response=%r", response)
+            raise UploadError("Video upload response info is empty") from e
+        except Exception as e:
+            logger.exception("Failed to get video upload info")
+            logger.debug("Video upload response=%r", response)
+            raise UploadError("Failed to get video upload info") from e
+
+        try:
+            file_size = await video.size()
+        except Exception as e:
+            logger.exception("Failed to get video size")
+            raise UploadError("Failed to get video size") from e
+
+        logger.debug(
+            "Video upload info received video_id=%s file_size=%s",
+            upload_info.video_id,
+            file_size,
+        )
+
+        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-Length": str(file_size),
+            "Connection": "keep-alive",
+        }
+
+        logger.debug(
+            "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
+
+        self.video_upload_waiters[video_id] = future
+        logger.debug("Video upload waiter registered video_id=%s", video_id)
+
+        try:
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                logger.debug("Starting video upload HTTP request video_id=%s", video_id)
+
+                async with session.post(
+                    url=upload_info.url,
+                    headers=headers,
+                    data=video.iter_chunks(1024 * 1024),
+                ) as response:
+                    logger.debug(
+                        "Video upload HTTP response status=%s video_id=%s",
+                        response.status,
+                        video_id,
+                    )
+
+                    if response.status != HTTPStatus.OK:
+                        logger.error(
+                            "Video upload failed with status %s video_id=%s",
+                            response.status,
+                            video_id,
+                        )
+                        raise UploadError(
+                            "Video upload failed with status "
+                            f"{response.status} video_id={video_id}"
+                        )
+
+                    try:
+                        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",
+                            video_id,
+                        )
+                        raise UploadError(
+                            f"Timed out waiting for video processing video_id={video_id}"
+                        )
+
+                    logger.debug("Video upload complete video_id=%s", video_id)
+                    return VideoAttachPayload(video_id=video_id, token=token)
+
+        except UploadError:
+            raise
+        except aiohttp.ClientError as e:
+            logger.exception("HTTP error during video upload video_id=%s", video_id)
+            raise UploadError(f"HTTP error during video upload video_id={video_id}") from e
+        except asyncio.TimeoutError as e:
+            logger.exception("Timed out during video upload video_id=%s", video_id)
+            raise UploadError(f"Timed out during video upload video_id={video_id}") from e
+        except Exception as e:
+            logger.exception("Unexpected error during video upload video_id=%s", video_id)
+            raise UploadError(f"Unexpected error during video upload video_id={video_id}") from e
+        finally:
+            self.video_upload_waiters.pop(video_id, None)
+            logger.debug("Video upload waiter removed video_id=%s", video_id)
+
+    async def upload_file(self, file: File) -> AttachFilePayload:
+        logger.info("Uploading file")
+
+        payload = UploadPayload().model_dump()
+
+        try:
+            data = await self.app.invoke(
+                Opcode.FILE_UPLOAD,
+                payload=payload,
+            )
+        except Exception as e:
+            logger.exception("Failed to request file upload URL")
+            raise UploadError("Failed to request file upload URL") from e
+
+        try:
+            response = FileUploadResponse.model_validate(data.payload)
+        except ValidationError as e:
+            logger.exception("Invalid file upload response model")
+            logger.debug("Invalid file upload payload=%r", data.payload)
+            raise UploadError("Invalid file upload response model") from e
+        except Exception as e:
+            logger.exception("Failed to parse file upload response")
+            logger.debug("Invalid File upload payload=%r", data.payload)
+            raise UploadError("Failed to parse file upload response") from e
+
+        try:
+            upload_info = response.info[0]
+        except IndexError as e:
+            logger.error("File upload response info is empty")
+            logger.debug("File upload response=%r", response)
+            raise UploadError("File upload response info is empty") from e
+        except Exception as e:
+            logger.exception("Failed to get file upload info")
+            logger.debug("File upload response=%r", response)
+            raise UploadError("Failed to get file upload info") from e
+
+        try:
+            file_size = await file.size()
+        except Exception as e:
+            logger.exception("Failed to get file size")
+            raise UploadError("Failed to get file size") from e
+
+        headers = {
+            "Content-Disposition": f"attachment; filename={quote(file.name)}",
+            "Content-Length": str(file_size),
+            "Content-Range": f"0-{file_size - 1}/{file_size}",
+        }
+
+        logger.debug(
+            "File upload headers prepared content_range=%s",
+            headers["Content-Range"],
+        )
+
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future[FileUploadSignal] = loop.create_future()
+
+        file_id = upload_info.file_id
+
+        self.file_upload_waiters[file_id] = future
+        logger.debug("File upload waiter registered file_id=%s", file_id)
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with 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",
+                        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}"
+                        )
+
+                    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)
+
+        except UploadError:
+            raise
+        except aiohttp.ClientError as e:
+            logger.exception("HTTP error during file upload file_id=%s", file_id)
+            raise UploadError(f"HTTP error during file upload file_id={file_id}") from e
+        except asyncio.TimeoutError as e:
+            logger.exception("Timed out during file upload file_id=%s", file_id)
+            raise UploadError(f"Timed out during file upload file_id={file_id}") from e
+        except Exception as e:
+            logger.exception("Unexpected error during file upload file_id=%s", file_id)
+            raise UploadError(f"Unexpected error during file upload file_id={file_id}") from e
+        finally:
+            self.file_upload_waiters.pop(file_id, None)
+            logger.debug("File upload waiter removed file=%s", file_id)
+
+    async def on_video_attach(self, attach: VideoUploadSignal, _: Client) -> None:
+        logger.debug("Received attach event video_id=%s", attach.video_id)
+
+        future = self.video_upload_waiters.pop(attach.video_id, None)
+
+        if not future:
+            logger.debug("No video upload waiter found video_id=%s", attach.video_id)
+            return
+
+        if future.done():
+            logger.debug("Video upload waiter already done video_id=%s", attach.video_id)
+            return
+
+        future.set_result(attach)
+        logger.debug("Video upload waiter resolved video_id=%s", attach.video_id)
+
+    async def on_file_attach(self, attach: FileUploadSignal, _: Client) -> None:
+        logger.debug("Received attach event file_id=%s", attach.file_id)
+        future = self.file_upload_waiters.pop(attach.file_id, None)
+
+        if not future:
+            logger.debug("No file upload waiter found file_id=%s", attach.file_id)
+            return
+
+        if future.done():
+            logger.debug("File upload waiter already done file_id=%s", attach.file_id)
+            return
+
+        future.set_result(attach)
+        logger.debug("File upload waiter resolved file_id=%s", attach.file_id)

pymax/api/users/__init__.py

@@ -0,0 +1,2 @@
+from .enums import ContactAction, UserPayloadKey
+from .service import UserService