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

pymax/api/stories/service.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+from pymax.api.response import parse_payload_list, payload_item, require_payload_item_model
+from pymax.api.uploads.payloads import AttachPhotoPayload, StoryVideoAttachPayload
+from pymax.exceptions import PyMaxError
+from pymax.files import Photo, Video
+from pymax.logging import get_logger
+from pymax.protocol import Opcode
+from pymax.types.domain.story import (
+    Story,
+    StoryClickableLink,
+    StoryCoordinates,
+    StoryDetailedStats,
+    StoryLayer,
+    StoryOwner,
+    StoryPreview,
+)
+
+from .enums import StoryPayloadKey, StoryStatsFilter
+from .payloads import (
+    DeleteStoryPayload,
+    EditStoryPayload,
+    GetStoriesByIdPayload,
+    GetStoriesPayload,
+    GetStoryDetailedStatsPayload,
+    MarkStoryPayload,
+    ReactStoryPayload,
+    SendStoryPayload,
+    SendStoryPayloadStory,
+    StoriesListPayload,
+    StoryReactionPayload,
+)
+
+if TYPE_CHECKING:
+    from pymax.app import App
+
+
+logger = get_logger(__name__)
+
+
+class StoriesService:
+    def __init__(self, app: App) -> None:
+        self.app = app
+        self._prev = int(time.time() * 1000)
+
+    def _next_cid(self) -> int:
+        now = int(time.time() * 1000)
+        cid = max(now, self._prev + 1)
+        self._prev = cid
+        return cid
+
+    async def send_story(
+        self,
+        media: Photo | Video,
+        *,
+        duration: int | None = None,
+        link: str | None = None,
+    ) -> Story:
+        logger.info("sending story media_type=%s", type(media).__name__)
+
+        attachment: AttachPhotoPayload | StoryVideoAttachPayload
+        if isinstance(media, Photo):
+            attachment = await self.app.api.uploads.upload_photo(media, upload_type=1)
+        elif isinstance(media, Video):
+            if duration is None or duration <= 0:
+                raise ValueError("Video story duration must be greater than zero")
+            attachment = await self.app.api.uploads.upload_story_video(media, duration)
+        else:
+            raise TypeError("Story media must be Photo or Video")
+
+        layers: list[StoryLayer] = []
+        if link is not None:
+            layers.append(
+                StoryLayer(
+                    coordinates=StoryCoordinates(x=0.5, y=0.9, w=0.78, h=0.055),
+                    clickable_link=StoryClickableLink(url=link),
+                )
+            )
+
+        frame = SendStoryPayload(
+            stories=[
+                SendStoryPayloadStory(
+                    cid=self._next_cid(),
+                    media=attachment,
+                    layers=layers,
+                )
+            ]
+        )
+        response = await self.app.invoke(Opcode.STORIES_SEND, frame.to_payload())
+        stories = parse_payload_list(response, StoryPayloadKey.STORIES, Story)
+        if not stories:
+            raise PyMaxError("Story response does not contain a story")
+        return stories[0]
+
+    async def get_stories(self, owner_id: int, owner_type: int = 0) -> list[Story]:
+        logger.info("getting stories owner_id=%s", owner_id)
+        frame = GetStoriesPayload(owners=[StoryOwner(owner_id=owner_id, type=owner_type)])
+        response = await self.app.invoke(Opcode.STORIES_GET_BY_OWNER_ID, frame.to_payload())
+        peers = payload_item(response, StoryPayloadKey.PEER_STORIES) or []
+        return [
+            Story.model_validate(story) for peer in peers for story in peer.get("stories") or []
+        ]
+
+    async def delete_story(self, story_id: int) -> bool:
+        logger.info("deleting story story_id=%s", story_id)
+        frame = DeleteStoryPayload(story_ids=[story_id])
+        await self.app.invoke(Opcode.STORIES_DELETE, frame.to_payload())
+        return True
+
+    async def get_stories_feed(
+        self,
+        cursor: str = "0",
+        count: int = 15,
+    ) -> tuple[list[StoryPreview], str]:
+        logger.info("getting stories feed cursor=%s count=%s", cursor, count)
+        frame = StoriesListPayload(cursor=cursor, count=count)
+        response = await self.app.invoke(Opcode.STORIES_LIST, frame.to_payload())
+        previews = parse_payload_list(response, StoryPayloadKey.STORIES_PREVIEWS, StoryPreview)
+        next_cursor = payload_item(response, StoryPayloadKey.CURSOR, str) or ""
+        return previews, next_cursor
+
+    async def get_stories_by_id(
+        self,
+        owner_id: int,
+        story_ids: list[int],
+        owner_type: int = 0,
+    ) -> list[Story]:
+        logger.info("getting stories by id owner_id=%s count=%s", owner_id, len(story_ids))
+        frame = GetStoriesByIdPayload(
+            owner=StoryOwner(owner_id=owner_id, type=owner_type),
+            story_ids=story_ids,
+        )
+        response = await self.app.invoke(Opcode.STORIES_GET_BY_STORY_ID, frame.to_payload())
+        return parse_payload_list(response, StoryPayloadKey.STORIES, Story)
+
+    async def get_story_detailed_stats(
+        self,
+        story_id: int,
+        filter: StoryStatsFilter,
+        marker: int = 0,
+    ) -> tuple[list[StoryDetailedStats], int]:
+        logger.info("getting story detailed stats story_id=%s marker=%s", story_id, marker)
+        frame = GetStoryDetailedStatsPayload(story_id=story_id, filter=filter, marker=marker)
+        response = await self.app.invoke(Opcode.STORIES_GET_DETAILED_STATS, frame.to_payload())
+        stats = parse_payload_list(
+            response, StoryPayloadKey.STORY_DETAILED_STATS, StoryDetailedStats
+        )
+        next_marker = payload_item(response, StoryPayloadKey.MARKER, int) or 0
+        return stats, next_marker
+
+    async def read_story(self, story_id: int, owner_id: int, owner_type: int = 0) -> bool:
+        logger.info("marking story as read story_id=%s owner_id=%s", story_id, owner_id)
+        frame = MarkStoryPayload(
+            owner=StoryOwner(owner_id=owner_id, type=owner_type),
+            story_id=story_id,
+        )
+        await self.app.invoke(Opcode.STORIES_MARK, frame.to_payload())
+        return True
+
+    async def edit_story(self, story_id: int, settings: int) -> Story:
+        logger.info("editing story settings story_id=%s", story_id)
+        frame = EditStoryPayload(story_id=story_id, settings=settings)
+        response = await self.app.invoke(Opcode.STORIES_EDIT, frame.to_payload())
+        return require_payload_item_model(response, StoryPayloadKey.STORY, Story)
+
+    async def add_story_reaction(
+        self,
+        owner_id: int,
+        story_id: int,
+        reaction: str,
+        reaction_type: int = 0,
+        owner_type: int = 0,
+    ) -> bool:
+        logger.info("adding story reaction owner_id=%s story_id=%s", owner_id, story_id)
+        frame = ReactStoryPayload(
+            owner=StoryOwner(owner_id=owner_id, type=owner_type),
+            story_id=story_id,
+            reaction=StoryReactionPayload(reaction_type=reaction_type, id=reaction),
+        )
+        response = await self.app.invoke(Opcode.STORIES_REACT, frame.to_payload())
+        return bool(payload_item(response, StoryPayloadKey.SUCCESS, bool))
+
+    async def remove_story_reaction(
+        self,
+        owner_id: int,
+        story_id: int,
+        owner_type: int = 0,
+    ) -> bool:
+        logger.info("removing story reaction owner_id=%s story_id=%s", owner_id, story_id)
+        frame = ReactStoryPayload(
+            owner=StoryOwner(owner_id=owner_id, type=owner_type),
+            story_id=story_id,
+        )
+        response = await self.app.invoke(Opcode.STORIES_REACT, frame.to_payload())
+        return bool(payload_item(response, StoryPayloadKey.SUCCESS, bool))

pymax/api/uploads/payloads.py

@@ -1,4 +1,6 @@
-from pydantic import Field
+from typing import Any, Literal
+
+from pydantic import Field, SerializerFunctionWrapHandler, model_serializer
 
 from pymax.api.models import CamelModel
 from pymax.types import AttachmentType
@@ -9,6 +11,15 @@ class AttachPhotoPayload(CamelModel):
     photo_token: str
 
 
+class StoryVideoAttachPayload(CamelModel):
+    type: Literal[AttachmentType.VIDEO] = Field(
+        default=AttachmentType.VIDEO, serialization_alias="_type"
+    )
+    video_type: Literal[2] = 2
+    duration: int
+    token: str
+
+
 class VideoAttachPayload(CamelModel):
     type: AttachmentType = Field(default=AttachmentType.VIDEO, serialization_alias="_type")
     video_id: int
@@ -18,6 +29,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

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import asyncio
 import base64
+import ssl
 from http import HTTPStatus
+from importlib import resources
 from typing import TYPE_CHECKING
 from urllib.parse import parse_qs, quote, urlparse
 
@@ -15,7 +17,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,
@@ -25,8 +27,11 @@ from .models import (
 from .payloads import (
     AttachFilePayload,
     AttachPhotoPayload,
+    StoryVideoAttachPayload,
     UploadPayload,
     VideoAttachPayload,
+    VideoNoteAttachPayload,
+    VoiceAttachPayload,
 )
 
 if TYPE_CHECKING:
@@ -47,11 +52,22 @@ class UploadService:
         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:
+        self.ssl_ctx = ssl.create_default_context()
+        self.ssl_ctx.load_verify_locations(
+            str(resources.files("pymax._data") / "rootca_ssl_rsa2022.crt")
+        )
+
+    async def upload_photo(
+        self,
+        photo: Photo,
+        profile: bool = False,
+        *,
+        upload_type: int = 0,
+    ) -> AttachPhotoPayload:
         logger.info("Uploading photo")
         logger.debug("Preparing photo upload payload")
 
-        payload = UploadPayload(profile=profile).to_payload()
+        payload = UploadPayload(profile=profile, type=upload_type).to_payload()
 
         try:
             data = await self.app.invoke(
@@ -80,11 +96,9 @@ class UploadService:
 
         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
+            query = parse_qs(parsed_url.query)
+            photo_ids = query.get("photos") or query.get("photoIds")
+            photo_id = str(photo_ids[0]) if photo_ids else None
         except Exception as e:
             logger.exception("Failed to parse photo id from upload URL")
             logger.debug("Invalid photo upload URL=%s", url)
@@ -130,6 +144,7 @@ class UploadService:
                 session.post(
                     url=url,
                     data=form,
+                    ssl=self.ssl_ctx,
                 ) as response,
             ):
                 logger.debug("Photo upload HTTP response status=%s", response.status)
@@ -163,6 +178,12 @@ class UploadService:
             logger.debug("Invalid photo upload response=%r", result)
             raise UploadError("Invalid photo upload response model") from e
 
+        if photo_id is None:
+            if len(model.photos) != 1:
+                logger.error("Expected one photo in upload response without a photo id")
+                raise UploadError("Expected one photo in upload response without a photo id")
+            photo_id = next(iter(model.photos))
+
         try:
             token = model.photos[photo_id].token
         except KeyError as e:
@@ -182,7 +203,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 +248,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 +272,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:
@@ -261,6 +289,7 @@ class UploadService:
                     url=upload_info.url,
                     headers=headers,
                     data=voice.iter_chunks(1024 * 1024),
+                    ssl=self.ssl_ctx,
                 ) as response:
                     logger.debug(
                         "Voice upload HTTP response status=%s voice_id=%s",
@@ -279,24 +308,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 +348,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 +402,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",
@@ -400,6 +436,7 @@ class UploadService:
                     url=upload_info.url,
                     headers=headers,
                     data=uploadable_video.iter_chunks(1024 * 1024),
+                    ssl=self.ssl_ctx,
                 ) as response:
                     logger.debug(
                         "Video upload HTTP response status=%s video_id=%s",
@@ -427,10 +464,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(),
                             )
@@ -474,6 +510,71 @@ class UploadService:
             self.video_upload_waiters.pop(video_id, None)
             logger.debug("Video upload waiter removed video_id=%s", video_id)
 
+    async def upload_story_video(self, video: Video, duration: int) -> StoryVideoAttachPayload:
+        logger.info("Uploading story video")
+        payload = UploadPayload(type=3).to_payload()
+
+        try:
+            data = await self.app.invoke(Opcode.VIDEO_UPLOAD, payload=payload)
+        except Exception as e:
+            logger.exception("Failed to request story video upload URL")
+            raise UploadError("Failed to request story video upload URL") from e
+
+        try:
+            upload_info = VideoUploadResponse.model_validate(data.payload).info[0]
+        except (ValidationError, IndexError) as e:
+            logger.exception("Invalid story video upload response")
+            raise UploadError("Invalid story video upload response") from e
+
+        try:
+            file_size = await video.size()
+        except Exception as e:
+            logger.exception("Failed to get story video size")
+            raise UploadError("Failed to get story video size") from e
+
+        headers = {
+            "Content-Type": "application/octet-stream",
+            "Content-Disposition": f"attachment; filename={quote(str(video.name))}",
+            "Content-Range": f"bytes 0-{file_size - 1}/{file_size}",
+            "Content-Length": str(file_size),
+        }
+        timeout = aiohttp.ClientTimeout(total=self.app.config.upload_timeout, sock_read=60)
+
+        try:
+            async with (
+                aiohttp.ClientSession(timeout=timeout, proxy=self.app.config.proxy) as session,
+                session.post(
+                    url=upload_info.url,
+                    headers=headers,
+                    data=video.iter_chunks(1024 * 1024),
+                    ssl=self.ssl_ctx,
+                ) as response,
+            ):
+                logger.debug("Story video upload HTTP response status=%s", response.status)
+                if response.status != HTTPStatus.OK:
+                    raise UploadError(f"Story video upload failed with status {response.status}")
+
+                result = await response.json(content_type=None)
+                attachment = StoryVideoAttachPayload(
+                    duration=duration,
+                    token=result[0]["token"],
+                )
+
+        except UploadError:
+            raise
+        except aiohttp.ClientError as e:
+            logger.exception("HTTP error during story video upload")
+            raise UploadError("HTTP error during story video upload") from e
+        except asyncio.TimeoutError as e:
+            logger.exception("Timed out during story video upload")
+            raise UploadError("Timed out during story video upload") from e
+        except Exception as e:
+            logger.exception("Unexpected error during story video upload")
+            raise UploadError("Unexpected error during story video upload") from e
+
+        logger.debug("Story video upload complete video_id=%s", upload_info.video_id)
+        return attachment
+
     async def upload_file(self, file: File) -> AttachFilePayload:
         logger.info("Uploading file")
 
@@ -532,51 +633,52 @@ 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",
+                    ssl=self.ssl_ctx,
+                ) 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