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

pymax/api/auth/payloads.py

@@ -0,0 +1,129 @@
+from pydantic import Field, field_serializer
+
+from pymax.api.models import CamelModel
+from pymax.api.session.payloads import MobileUserAgentPayload
+from pymax.types.domain.sync import DEFAULT_CONFIG_HASH, ConfigHash, SyncState
+
+from .enums import AuthType, Capability
+
+
+class RequestCodePayload(CamelModel):
+    phone: str
+    type: AuthType = AuthType.START_AUTH
+    language: str = "ru"
+
+
+class SendCodePayload(CamelModel):
+    token: str
+    verify_code: str
+    auth_token_type: AuthType = AuthType.CHECK_CODE
+
+
+class CheckPasswordChallengePayload(CamelModel):
+    track_id: str
+    password: str
+
+
+class Exp(CamelModel):
+    chats_count_groups: bytearray = bytearray.fromhex("0a32")
+
+
+class WebSyncPayload(CamelModel):
+    token: str
+    chats_count: int = 40
+    interactive: bool = True
+    chats_sync: int = -1
+    contacts_sync: int = -1
+    presence_sync: int = -1
+    drafts_sync: int = -1
+
+    @classmethod
+    def from_sync_state(
+        cls,
+        token: str,
+        sync: SyncState,
+    ) -> "WebSyncPayload":
+        return cls(
+            token=token,
+            chats_sync=sync.chats_sync,
+            contacts_sync=sync.contacts_sync,
+            drafts_sync=sync.drafts_sync,
+        )
+
+
+class SyncPayload(CamelModel):
+    user_agent: MobileUserAgentPayload
+    token: str
+    chat_hash_fingerprint: str | None = None
+    chats_count: int | None = None
+    chats_sync: int = -1
+    contacts_sync: int = -1
+    drafts_sync: int = -1
+    interactive: bool = True
+    presence_sync: int = -1
+    exp: Exp = Field(default_factory=Exp)
+    config_hash: ConfigHash = DEFAULT_CONFIG_HASH
+
+    @classmethod
+    def from_sync_state(
+        cls,
+        user_agent: MobileUserAgentPayload,
+        token: str,
+        sync: SyncState,
+    ) -> "SyncPayload":
+        return cls(
+            user_agent=user_agent,
+            token=token,
+            chats_sync=sync.chats_sync,
+            contacts_sync=sync.contacts_sync,
+            drafts_sync=sync.drafts_sync,
+            presence_sync=sync.presence_sync,
+            config_hash=sync.config_hash,
+        )
+
+
+class CheckQrPayload(CamelModel):
+    track_id: str
+
+
+class ConfirmQrPayload(CamelModel):
+    track_id: str
+
+
+class CreateAuthTrackPayload(CamelModel):
+    type: int = 0
+
+
+class SetPasswordPayload(CamelModel):
+    track_id: str
+    password: str
+
+
+class RequestEmailCodePayload(CamelModel):
+    track_id: str
+    email: str
+
+
+class SendEmailCodePayload(CamelModel):
+    track_id: str
+    verify_code: str
+
+
+class SetHintPayload(CamelModel):
+    track_id: str
+    hint: str
+
+
+class SetTwoFactorPayload(CamelModel):
+    expected_capabilities: list[Capability]
+    track_id: str
+    password: str
+    hint: str | None = None
+
+
+class RemoveTwoFactorPayload(CamelModel):
+    track_id: str
+    remove2fa: bool = True
+    expected_capabilities: list[Capability] = Field(
+        default_factory=lambda: [Capability.REMOVE_2FA]
+    )

pymax/api/auth/service.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pymax.api.response import payload_item, payload_keys, require_payload_model
+from pymax.api.session.enums import DeviceType
+from pymax.auth import EmailCodeProvider
+from pymax.auth.providers import ConsoleEmailCodeProvider
+from pymax.logging import get_logger
+from pymax.protocol import Opcode
+from pymax.types.domain.auth import (
+    CheckCodeResponse,
+    CheckPasswordResponse,
+    CheckQrResponse,
+    RequestQrResponse,
+    StartAuthResponse,
+)
+from pymax.types.domain.login import LoginResponse
+
+from .enums import Capability
+from .payloads import (
+    CheckPasswordChallengePayload,
+    CheckQrPayload,
+    ConfirmQrPayload,
+    CreateAuthTrackPayload,
+    MobileUserAgentPayload,
+    RemoveTwoFactorPayload,
+    RequestCodePayload,
+    RequestEmailCodePayload,
+    SendCodePayload,
+    SendEmailCodePayload,
+    SetHintPayload,
+    SetPasswordPayload,
+    SetTwoFactorPayload,
+    SyncPayload,
+    WebSyncPayload,
+)
+from .types import MISSING, Missing
+
+if TYPE_CHECKING:
+    from pymax.app import App
+
+
+logger = get_logger(__name__)
+
+
+class AuthService:
+    def __init__(self, app: App) -> None:
+        self.app = app
+
+    async def request_code(self, phone: str) -> StartAuthResponse:
+        logger.info("requesting sms code phone_set=%s", bool(phone))
+        frame = RequestCodePayload(phone=phone)
+        response = await self.app.invoke(Opcode.AUTH_REQUEST, frame.to_payload())
+        logger.debug(
+            "sms code request accepted payload_keys=%s",
+            payload_keys(response),
+        )
+        return require_payload_model(response, StartAuthResponse)
+
+    async def send_code(self, token: str, verify_code: str) -> CheckCodeResponse:
+        logger.info(
+            "sending sms code token_set=%s code_set=%s",
+            bool(token),
+            bool(verify_code),
+        )
+        frame = SendCodePayload(token=token, verify_code=verify_code)
+        response = await self.app.invoke(Opcode.AUTH, frame.to_payload())
+        logger.debug(
+            "sms code response payload_keys=%s",
+            payload_keys(response),
+        )
+        return require_payload_model(response, CheckCodeResponse)
+
+    async def check_password(
+        self,
+        track_id: str,
+        password: str,
+    ) -> CheckPasswordResponse:
+        logger.info(
+            "checking 2fa password track_id_set=%s password_set=%s",
+            bool(track_id),
+            bool(password),
+        )
+        frame = CheckPasswordChallengePayload(
+            track_id=track_id,
+            password=password,
+        )
+        response = await self.app.invoke(
+            Opcode.AUTH_LOGIN_CHECK_PASSWORD,
+            frame.to_payload(),
+        )
+        logger.debug(
+            "2fa password response payload_keys=%s",
+            payload_keys(response),
+        )
+        return require_payload_model(response, CheckPasswordResponse)
+
+    async def login(self, user_agent: MobileUserAgentPayload) -> LoginResponse:
+        if user_agent.device_type == DeviceType.WEB:
+            return await self.web_login()
+
+        return await self.mobile_login()
+
+    async def mobile_login(self) -> LoginResponse:
+        session = self.app.session
+        if session is None:
+            logger.error("login requested without session")
+            raise RuntimeError("No session available for login")
+
+        logger.info("logging in")
+        sync = self.app.config.sync.resolve(session.sync)
+        frame = SyncPayload.from_sync_state(
+            user_agent=self.app.config.device.user_agent,
+            token=session.token,
+            sync=sync,
+        )
+        response = await self.app.invoke(Opcode.LOGIN, frame.to_payload())
+
+        logger.debug("login response payload_keys=%s", payload_keys(response))
+
+        login_response = require_payload_model(response, LoginResponse)
+        await self._update_session(login_response)
+        return login_response
+
+    async def web_login(self) -> LoginResponse:
+        session = self.app.session
+        if session is None:
+            logger.error("login requested without session")
+            raise RuntimeError("No session available for login")
+
+        logger.info("logging in")
+        sync = self.app.config.sync.resolve(session.sync)
+
+        frame = WebSyncPayload.from_sync_state(
+            token=session.token,
+            sync=sync,
+        )
+        response = await self.app.invoke(Opcode.LOGIN, frame.to_payload())
+
+        logger.debug("login response payload_keys=%s", payload_keys(response))
+
+        login_response = require_payload_model(response, LoginResponse)
+        await self._update_session(login_response)
+        return login_response
+
+    async def request_qr(self) -> RequestQrResponse:
+        response = await self.app.invoke(Opcode.GET_QR, {})
+
+        return require_payload_model(response, RequestQrResponse)
+
+    async def check_qr(self, track_id: str) -> CheckQrResponse:
+        frame = CheckQrPayload(track_id=track_id)
+
+        response = await self.app.invoke(Opcode.GET_QR_STATUS, frame.to_payload())
+
+        return require_payload_model(response, CheckQrResponse)
+
+    async def confirm_qr(self, track_id: str) -> CheckCodeResponse:
+        frame = ConfirmQrPayload(track_id=track_id)
+
+        response = await self.app.invoke(Opcode.LOGIN_BY_QR, frame.to_payload())
+
+        return require_payload_model(response, CheckCodeResponse)
+
+    async def _update_session(self, response: LoginResponse) -> None:
+        session = self.app.session
+        if session is None:
+            return
+
+        sync = response.update_sync_state(session.sync)
+        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)
+
+    async def _get_track_id(self) -> str | None:
+        logger.debug("creating auth track")
+        frame = CreateAuthTrackPayload()
+
+        response = await self.app.invoke(Opcode.AUTH_CREATE_TRACK, frame.to_payload())
+
+        return payload_item(response, "trackId", str)
+
+    async def _set_email(self, track_id: str, email: str, provider: EmailCodeProvider) -> bool:
+        logger.info("setting 2fa email email_set=%s", bool(email))
+
+        frame = RequestEmailCodePayload(
+            track_id=track_id,
+            email=email,
+        )
+
+        await self.app.invoke(Opcode.AUTH_VERIFY_EMAIL, frame.to_payload())
+
+        code = await provider.get_code(email)
+
+        frame = SendEmailCodePayload(
+            track_id=track_id,
+            verify_code=code,
+        )
+
+        await self.app.invoke(Opcode.AUTH_CHECK_EMAIL, frame.to_payload())
+
+        return True
+
+    async def _set_hint(self, track_id: str, hint: str) -> bool:
+        logger.info("setting 2fa hint hint_set=%s", bool(hint))
+
+        frame = SetHintPayload(
+            track_id=track_id,
+            hint=hint,
+        )
+        await self.app.invoke(Opcode.AUTH_VALIDATE_HINT, frame.to_payload())
+
+        return True
+
+    async def _set_password(self, track_id: str, password: str) -> bool:
+        logger.info("setting 2fa password password_set=%s", bool(password))
+
+        frame = SetPasswordPayload(
+            track_id=track_id,
+            password=password,
+        )
+        await self.app.invoke(Opcode.AUTH_VALIDATE_PASSWORD, frame.to_payload())
+
+        return True
+
+    async def set_2fa(
+        self,
+        password: str,
+        email: str | Missing = MISSING,
+        hint: str | Missing = MISSING,
+        email_code_provider: EmailCodeProvider | None = None,
+    ) -> bool:
+        logger.info(
+            "setting 2fa password password_set=%s email_set=%s hint_set=%s",
+            bool(password),
+            bool(email),
+            bool(hint),
+        )
+
+        track_id = await self._get_track_id()
+
+        if track_id is None:
+            logger.error("missing track_id in auth create track response")
+            raise RuntimeError("Failed to create auth track")
+
+        has_hint = False
+        has_email = False
+
+        await self._set_password(track_id, password)
+
+        if email is not MISSING:
+            provider = email_code_provider or ConsoleEmailCodeProvider()
+            await self._set_email(track_id, str(email), provider)
+            has_email = True
+
+        if hint is not MISSING:
+            await self._set_hint(track_id, str(hint))
+            has_hint = True
+
+        expected_capabilities = [Capability.DEFAULT]
+
+        if has_hint:
+            expected_capabilities.append(Capability.SECOND_FACTOR_HAS_HINT)
+
+        if has_email:
+            expected_capabilities.append(Capability.SECOND_FACTOR_HAS_EMAIL)
+
+        frame = SetTwoFactorPayload(
+            track_id=track_id,
+            password=password,
+            hint=str(hint) if has_hint else None,
+            expected_capabilities=expected_capabilities,
+        )
+
+        await self.app.invoke(Opcode.AUTH_SET_2FA, frame.to_payload())
+        logger.info("2fa password set successfully")
+        return True
+
+    async def _check_2fa_password(self, track_id: str, password: str) -> bool:
+        logger.info("entering 2fa password password_set=%s", bool(password))
+
+        frame = SetPasswordPayload(
+            track_id=track_id,
+            password=password,
+        )
+        await self.app.invoke(Opcode.AUTH_CHECK_PASSWORD, frame.to_payload())
+
+        return True
+
+    async def remove_2fa(self, password: str) -> bool:
+        logger.info("removing 2fa password_set=%s", bool(password))
+
+        track_id = await self._get_track_id()
+
+        if track_id is None:
+            logger.error("missing track_id in auth create track response")
+            raise RuntimeError("Failed to create auth track")
+
+        await self._check_2fa_password(track_id, password)
+
+        frame = RemoveTwoFactorPayload(
+            track_id=track_id,
+        )
+
+        await self.app.invoke(Opcode.AUTH_SET_2FA, frame.to_payload())
+
+        return True

pymax/api/auth/types.py

@@ -0,0 +1,13 @@
+from typing import Final, TypeAlias
+
+
+class MissingType:
+    __slots__ = ()
+
+    def __repr__(self) -> str:
+        return "MISSING"
+
+
+MISSING: Final = MissingType()
+
+Missing: TypeAlias = MissingType

pymax/api/chats/__init__.py

@@ -0,0 +1,8 @@
+from .enums import (
+    ChatLinkPrefix,
+    ChatMemberOperation,
+    ChatOption,
+    ChatPayloadKey,
+    ControlEvent,
+)
+from .service import ChatService

pymax/api/chats/enums.py

@@ -0,0 +1,27 @@
+from enum import Enum
+
+
+class ControlEvent(str, Enum):
+    NEW = "new"
+
+
+class ChatMemberOperation(str, Enum):
+    ADD = "add"
+    REMOVE = "remove"
+
+
+class ChatOption(str, Enum):
+    ONLY_OWNER_CAN_CHANGE_ICON_TITLE = "ONLY_OWNER_CAN_CHANGE_ICON_TITLE"
+    ALL_CAN_PIN_MESSAGE = "ALL_CAN_PIN_MESSAGE"
+    ONLY_ADMIN_CAN_ADD_MEMBER = "ONLY_ADMIN_CAN_ADD_MEMBER"
+    ONLY_ADMIN_CAN_CALL = "ONLY_ADMIN_CAN_CALL"
+    MEMBERS_CAN_SEE_PRIVATE_LINK = "MEMBERS_CAN_SEE_PRIVATE_LINK"
+
+
+class ChatPayloadKey(str, Enum):
+    CHAT = "chat"
+    CHATS = "chats"
+
+
+class ChatLinkPrefix(str, Enum):
+    JOIN = "join/"

pymax/api/chats/payloads.py

@@ -0,0 +1,103 @@
+from typing import Literal
+
+from pydantic import Field
+
+from pymax.api.models import CamelModel
+from pymax.types.domain.attachments.enums import AttachmentType
+from pymax.types.domain.enums import ChatType
+
+from .enums import ChatMemberOperation, ChatOption, ControlEvent
+
+
+class CreateGroupAttach(CamelModel):
+    type: Literal[AttachmentType.CONTROL] = Field(
+        default=AttachmentType.CONTROL,
+        alias="_type",
+    )
+    event: ControlEvent = ControlEvent.NEW
+    chat_type: Literal[ChatType.CHAT] = ChatType.CHAT
+    title: str
+    user_ids: list[int]
+
+
+class CreateGroupMessage(CamelModel):
+    cid: int
+    attaches: list[CreateGroupAttach]
+
+
+class CreateGroupPayload(CamelModel):
+    message: CreateGroupMessage
+    notify: bool = True
+
+
+class InviteUsersPayload(CamelModel):
+    chat_id: int
+    user_ids: list[int]
+    show_history: bool
+    operation: ChatMemberOperation = ChatMemberOperation.ADD
+
+
+class RemoveUsersPayload(CamelModel):
+    chat_id: int
+    user_ids: list[int]
+    operation: ChatMemberOperation = ChatMemberOperation.REMOVE
+    clean_msg_period: int
+
+
+class ChangeGroupSettingsOptions(CamelModel):
+    only_owner_can_change_icon_title: bool | None = Field(
+        default=None,
+        serialization_alias=ChatOption.ONLY_OWNER_CAN_CHANGE_ICON_TITLE.value,
+    )
+    all_can_pin_message: bool | None = Field(
+        default=None,
+        serialization_alias=ChatOption.ALL_CAN_PIN_MESSAGE.value,
+    )
+    only_admin_can_add_member: bool | None = Field(
+        default=None,
+        serialization_alias=ChatOption.ONLY_ADMIN_CAN_ADD_MEMBER.value,
+    )
+    only_admin_can_call: bool | None = Field(
+        default=None,
+        serialization_alias=ChatOption.ONLY_ADMIN_CAN_CALL.value,
+    )
+    members_can_see_private_link: bool | None = Field(
+        default=None,
+        serialization_alias=ChatOption.MEMBERS_CAN_SEE_PRIVATE_LINK.value,
+    )
+
+
+class ChangeGroupSettingsPayload(CamelModel):
+    chat_id: int
+    options: ChangeGroupSettingsOptions
+
+
+class ChangeGroupProfilePayload(CamelModel):
+    chat_id: int
+    theme: str | None
+    description: str | None = None
+
+
+class JoinChatPayload(CamelModel):
+    link: str
+
+
+class LinkInfoPayload(CamelModel):
+    link: str
+
+
+class ReworkInviteLinkPayload(CamelModel):
+    revoke_private_link: bool = True
+    chat_id: int
+
+
+class GetChatInfoPayload(CamelModel):
+    chat_ids: list[int]
+
+
+class LeaveChatPayload(CamelModel):
+    chat_id: int
+
+
+class FetchChatsPayload(CamelModel):
+    marker: int