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

pymax/api/stories/payloads.py

@@ -0,0 +1,64 @@
+from pydantic import Field
+
+from pymax.api.models import CamelModel
+from pymax.api.uploads.payloads import AttachPhotoPayload, StoryVideoAttachPayload
+from pymax.types.domain.story import StoryLayer, StoryOwner
+
+from .enums import StoryStatsFilter
+
+
+class SendStoryPayloadStory(CamelModel):
+    cid: int
+    media: AttachPhotoPayload | StoryVideoAttachPayload
+    settings: int = 1
+    expiration: int = 172_800_000
+    layers: list[StoryLayer] = Field(default_factory=list)
+
+
+class SendStoryPayload(CamelModel):
+    stories: list[SendStoryPayloadStory]
+
+
+class GetStoriesPayload(CamelModel):
+    owners: list[StoryOwner]
+
+
+class DeleteStoryPayload(CamelModel):
+    story_ids: list[int]
+
+
+class StoriesListPayload(CamelModel):
+    cursor: str = "0"
+    count: int = 15
+
+
+class GetStoriesByIdPayload(CamelModel):
+    owner: StoryOwner
+    story_ids: list[int]
+
+
+class GetStoryDetailedStatsPayload(CamelModel):
+    story_id: int
+    marker: int = 0
+    filter: StoryStatsFilter
+
+
+class MarkStoryPayload(CamelModel):
+    owner: StoryOwner
+    story_id: int
+
+
+class EditStoryPayload(CamelModel):
+    story_id: int
+    settings: int
+
+
+class StoryReactionPayload(CamelModel):
+    reaction_type: int = 0
+    id: str
+
+
+class ReactStoryPayload(CamelModel):
+    owner: StoryOwner
+    story_id: int
+    reaction: StoryReactionPayload | None = None

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,4 @@
-from typing import Any
+from typing import Any, Literal
 
 from pydantic import Field, SerializerFunctionWrapHandler, model_serializer
 
@@ -11,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

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
 
@@ -25,6 +27,7 @@ from .models import (
 from .payloads import (
     AttachFilePayload,
     AttachPhotoPayload,
+    StoryVideoAttachPayload,
     UploadPayload,
     VideoAttachPayload,
     VideoNoteAttachPayload,
@@ -49,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(
@@ -82,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)
@@ -132,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)
@@ -165,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:
@@ -270,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",
@@ -416,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",
@@ -489,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")
 
@@ -559,6 +645,7 @@ class UploadService:
                     url=upload_info.url,
                     headers=headers,
                     data=file.iter_chunks(1024 * 1024),
+                    ssl=self.ssl_ctx,
                 ) as response,
             ):
                 logger.debug(

pymax/app.py

@@ -9,6 +9,7 @@ from pymax.dispatch import Dispatcher
 from pymax.dispatch.router import EventType, Router
 from pymax.exceptions import ApiError
 from pymax.fingerprint import FingerprintGenerator
+from pymax.fsm import InMemoryFSMStorage
 from pymax.logging import get_logger
 from pymax.protocol import Command, InboundFrame, OutboundFrame
 from pymax.protocol.enums import Opcode
@@ -43,6 +44,7 @@ class App(Generic[ClientT]):
             if self.config.persist_session
             else InMemoryStore()
         )
+        self.fsm_storage: InMemoryFSMStorage = InMemoryFSMStorage()
         self.auth_flow = auth_flow
         self.fingerprint_generator: FingerprintGenerator | None = (
             FingerprintGenerator(self.config.fingering) if self.config.fingering else None
@@ -57,7 +59,7 @@ class App(Generic[ClientT]):
         self.session: SessionInfo | None = None
         self.handshake_response: HandshakeResponse | None = None
 
-        self.started = False
+        self.started: bool = False
         self._ping_task: asyncio.Task[None] | None = None
         self._telemetry = TelemetryService(self) if config.telemetry else None
 
@@ -186,7 +188,7 @@ class App(Generic[ClientT]):
             if not handled:
                 raise
 
-            await self.close()
+            await self.disconnect()
             return
 
         if login_response.token is not None and login_response.token != self.session.token:
@@ -208,6 +210,7 @@ class App(Generic[ClientT]):
         self.messages = login_response.messages
 
         self.started = True
+
         logger.info(
             "client started profile=%s chats=%s",
             self.me.contact.id,
@@ -249,7 +252,7 @@ class App(Generic[ClientT]):
         logger.debug("handshake completed device_id=%s", device_id)
         return response
 
-    async def close(self) -> None:
+    async def disconnect(self) -> None:
         if self._telemetry:
             await self._telemetry.stop()
 
@@ -258,6 +261,7 @@ class App(Generic[ClientT]):
             self._ping_task = None
             if not task.done():
                 task.cancel()
+
             try:
                 await task
             except asyncio.CancelledError:
@@ -267,10 +271,13 @@ class App(Generic[ClientT]):
 
         await self.dispatcher.stop_startup_tasks()
         await self.connection.close()
-        await self.store.close()
 
         self.started = False
 
+    async def close(self):
+        await self.disconnect()
+        await self.store.close()
+
     async def invoke(
         self,
         opcode: int,
@@ -374,6 +381,11 @@ class App(Generic[ClientT]):
         )
         return exc
 
+    def bind_connection(self, connection: ConnectionManager) -> None:
+        self.connection = connection
+        self.connection.on_event = self.on_event
+        self.connection.on_close = self.on_connection_lost
+
     async def on_event(self, frame: InboundFrame) -> None:
         logger.debug(
             "event received opcode=%s cmd=%s seq=%s",

pymax/auth/qr.py

@@ -5,6 +5,7 @@ import time
 from typing import TYPE_CHECKING
 
 from pymax.auth.base import AuthFlow
+from pymax.auth.exceptions import PasswordAttemptsExceededError
 from pymax.exceptions import ApiError
 from pymax.logging import get_logger
 
@@ -107,7 +108,10 @@ class QrAuthFlow(AuthFlow):
         hint: str | None,
     ) -> str:
         logger.info("starting 2fa password authentication")
-        while True:
+        attempt = 0
+        while (
+            app.config.password_max_attempts is None or app.config.password_max_attempts > attempt
+        ):
             password = await self.password_provider.get_password(hint)
             logger.debug(
                 "2fa password provider returned password_set=%s",
@@ -115,16 +119,19 @@ class QrAuthFlow(AuthFlow):
             )
             if not password:
                 logger.warning("2fa password is empty; retrying")
+                attempt += 1
                 continue
 
             try:
                 response = await app.api.auth.check_password(track_id, password)
             except ApiError as e:
                 logger.error("2fa password check failed: %s", e)
+                attempt += 1
                 continue
 
             if response.error:
                 logger.error("2fa password check failed error=%s", response.error)
+                attempt += 1
                 continue
 
             if response.login_token:
@@ -132,3 +139,6 @@ class QrAuthFlow(AuthFlow):
                 return response.login_token
 
             logger.error("2fa password response did not contain login token; retrying")
+            attempt += 1
+
+        raise PasswordAttemptsExceededError