maxapi-python 2.1.3__py3-none-any.whl → 2.3.0__py3-none-any.whl

pymax/api/uploads/service.py

@@ -38,22 +38,12 @@ 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
-        )
+        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, profile: bool = False
-    ) -> AttachPhotoPayload:
+    async def upload_photo(self, photo: Photo, profile: bool = False) -> AttachPhotoPayload:
         logger.info("Uploading photo")
         logger.debug("Preparing photo upload payload")
 
@@ -72,9 +62,7 @@ class UploadService:
             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
+            raise UploadError("Failed to parse photo upload URL from response") from e
 
         if not url:
             logger.error("No upload URL received")
@@ -92,15 +80,11 @@ class UploadService:
         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
+            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
+            raise UploadError("Failed to parse photo id from upload URL") from e
 
         logger.debug("Photo upload id parsed photo_id=%s", photo_id)
 
@@ -144,27 +128,17 @@ class UploadService:
                     data=form,
                 ) as response,
             ):
-                logger.debug(
-                    "Photo upload HTTP response status=%s", response.status
-                )
+                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}"
-                    )
+                    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
+                    logger.exception("Failed to decode photo upload response JSON")
+                    raise UploadError("Failed to decode photo upload response JSON") from e
 
         except UploadError:
             raise
@@ -280,9 +254,7 @@ class UploadService:
             async with aiohttp.ClientSession(
                 timeout=timeout, proxy=self.app.config.proxy
             ) as session:
-                logger.debug(
-                    "Starting video upload HTTP request video_id=%s", video_id
-                )
+                logger.debug("Starting video upload HTTP request video_id=%s", video_id)
 
                 async with session.post(
                     url=upload_info.url,
@@ -327,26 +299,14 @@ class UploadService:
         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
+            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
+            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
+            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)
@@ -458,70 +418,44 @@ class UploadService:
         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
+            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
+            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
+            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:
+    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
-            )
+            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
-            )
+            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
-        )
+        logger.debug("Video upload waiter resolved video_id=%s", attach.video_id)
 
-    async def on_file_attach(
-        self, attach: FileUploadSignal, _: Client
-    ) -> None:
+    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
-            )
+            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
-            )
+            logger.debug("File upload waiter already done file_id=%s", attach.file_id)
             return
 
         future.set_result(attach)

pymax/api/users/payloads.py

@@ -1,4 +1,7 @@
+from collections.abc import Iterable
+
 from pymax.api.models import CamelModel
+from pymax.types.domain import ContactInfo
 
 from .enums import ContactAction
 
@@ -14,3 +17,22 @@ class SearchByPhonePayload(CamelModel):
 class ContactActionPayload(CamelModel):
     contact_id: int
     action: ContactAction
+
+
+class _ContactPayload(CamelModel):
+    first_name: str
+
+
+class ImportContactsPayload(CamelModel):
+    contact_list: dict[str, _ContactPayload]  # phone -> contact payload
+
+    @classmethod
+    def from_contacts(cls, contacts: Iterable[ContactInfo]) -> "ImportContactsPayload":
+        return cls(
+            contact_list={
+                contact.phone: _ContactPayload(
+                    first_name=contact.first_name,
+                )
+                for contact in contacts
+            }
+        )

pymax/api/users/service.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Literal
 
+from pymax.api.binding import bind_api_model
 from pymax.api.response import (
     parse_payload_list,
     require_payload_dict,
@@ -9,12 +10,13 @@ from pymax.api.response import (
 )
 from pymax.logging import get_logger
 from pymax.protocol import InboundFrame, Opcode
-from pymax.types.domain import Session, User
+from pymax.types.domain import ContactInfo, Session, User
 
 from .enums import ContactAction, UserPayloadKey
 from .payloads import (
     ContactActionPayload,
     FetchContactsPayload,
+    ImportContactsPayload,
     SearchByPhonePayload,
 )
 
@@ -30,13 +32,14 @@ class UserService:
         self.app = app
 
     def _cache_user(self, user: User) -> User:
+        user = bind_api_model(self.app, user)
         self.app.users[user.id] = user
         return user
 
     def get_cached_user(self, user_id: int) -> User | None:
         user = self.app.users.get(user_id)
         logger.debug("get_cached_user id=%s hit=%s", user_id, bool(user))
-        return user
+        return bind_api_model(self.app, user) if user is not None else None
 
     async def get_users(self, user_ids: list[int]) -> list[User]:
         cached = {
@@ -44,9 +47,7 @@ class UserService:
             for user_id in user_ids
             if (user := self.get_cached_user(user_id)) is not None
         }
-        missing_ids = [
-            user_id for user_id in user_ids if user_id not in cached
-        ]
+        missing_ids = [user_id for user_id in user_ids if user_id not in cached]
 
         if missing_ids:
             for user in await self.fetch_users(missing_ids):
@@ -64,15 +65,11 @@ class UserService:
     async def fetch_users(self, user_ids: list[int]) -> list[User]:
         logger.info("fetching users count=%s", len(user_ids))
         frame = FetchContactsPayload(contact_ids=user_ids)
-        response = await self.app.invoke(
-            Opcode.CONTACT_INFO, frame.to_payload()
-        )
+        response = await self.app.invoke(Opcode.CONTACT_INFO, frame.to_payload())
 
         users = [
             self._cache_user(user)
-            for user in parse_payload_list(
-                response, UserPayloadKey.CONTACTS, User
-            )
+            for user in parse_payload_list(response, UserPayloadKey.CONTACTS, User)
         ]
         logger.debug("fetched users count=%s", len(users))
         return users
@@ -97,12 +94,8 @@ class UserService:
         response = await self.app.invoke(Opcode.SESSIONS_INFO, {})
         return parse_payload_list(response, UserPayloadKey.SESSIONS, Session)
 
-    async def _contact_action(
-        self, payload: ContactActionPayload
-    ) -> InboundFrame:
-        response = await self.app.invoke(
-            Opcode.CONTACT_UPDATE, payload.to_payload()
-        )
+    async def _contact_action(self, payload: ContactActionPayload) -> InboundFrame:
+        response = await self.app.invoke(Opcode.CONTACT_UPDATE, payload.to_payload())
         require_payload_dict(response)
         return response
 
@@ -130,5 +123,17 @@ class UserService:
         self.app.users.pop(contact_id, None)
         return True
 
+    async def import_contacts(self, contacts: list[ContactInfo]) -> list[User]:
+        frame = ImportContactsPayload.from_contacts(contacts)
+
+        response = await self.app.invoke(Opcode.SYNC, frame.to_payload())
+
+        users = parse_payload_list(
+            response, UserPayloadKey.CONTACTS, User
+        )  # TODO: maybe also return phone mapping?
+
+        # {contacts: [...], phones: {data[0]: server_phone}}
+        return [self._cache_user(user) for user in users]
+
     def get_chat_id(self, first_user_id: int, second_user_id: int) -> int:
         return first_user_id ^ second_user_id

pymax/app.py

@@ -1,12 +1,12 @@
 import asyncio
-from typing import Any, Generic, TypeVar
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
 from pymax.api import ApiFacade
 from pymax.auth import AuthFlow
 from pymax.config import ClientConfig
 from pymax.connection import ConnectionManager
 from pymax.dispatch import Dispatcher
-from pymax.dispatch.router import Router
+from pymax.dispatch.router import EventType, Router
 from pymax.exceptions import ApiError
 from pymax.logging import get_logger
 from pymax.protocol import Command, InboundFrame, OutboundFrame
@@ -17,8 +17,11 @@ from pymax.telemetry import TelemetryService
 from pymax.types import MaxApiError, Message
 from pymax.types.domain import Chat, Profile, User
 
+if TYPE_CHECKING:
+    from pymax.base import BaseClient
+
 logger = get_logger(__name__)
-ClientT = TypeVar("ClientT")
+ClientT = TypeVar("ClientT", bound="BaseClient")
 
 
 class App(Generic[ClientT]):
@@ -124,9 +127,26 @@ class App(Generic[ClientT]):
         self.session = session_data
 
         logger.debug("logging in")
-        response = await self.api.auth.login(
-            self.config.device.user_agent,
-        )
+
+        try:
+            response = await self.api.auth.login(
+                self.config.device.user_agent,
+            )
+        except Exception as e:
+            handled = False
+            if self.dispatcher.client is not None:
+                handled = await self.dispatcher.emit_error(
+                    e,
+                    EventType.ON_START,
+                    None,
+                    self.dispatcher.root_router,
+                    None,
+                )
+            if not handled:
+                raise
+
+            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)
@@ -205,8 +225,10 @@ class App(Generic[ClientT]):
             payload_keys,
         )
         logger.debug("Request data=%s", frame.model_dump())
+
         request_timeout = self.config.request_timeout if timeout is None else timeout
         response = await self.connection.request(frame, timeout=request_timeout)
+
         response_keys = sorted(response.payload.keys()) if response.payload else []
         logger.debug(
             "response opcode=%s cmd=%s seq=%s payload_keys=%s",

pymax/auth/qr.py

@@ -118,23 +118,17 @@ class QrAuthFlow(AuthFlow):
                 continue
 
             try:
-                response = await app.api.auth.check_password(
-                    track_id, password
-                )
+                response = await app.api.auth.check_password(track_id, password)
             except ApiError as e:
                 logger.error("2fa password check failed: %s", e)
                 continue
 
             if response.error:
-                logger.error(
-                    "2fa password check failed error=%s", response.error
-                )
+                logger.error("2fa password check failed error=%s", response.error)
                 continue
 
             if response.login_token:
                 logger.info("2fa password authentication completed")
                 return response.login_token
 
-            logger.error(
-                "2fa password response did not contain login token; retrying"
-            )
+            logger.error("2fa password response did not contain login token; retrying")

pymax/auth/sms.py

@@ -75,13 +75,31 @@ class SmsAuthFlow(AuthFlow):
         logger.debug("sms code provider returned code_set=%s", bool(code))
         result = await app.api.auth.send_code(start.token, code)
 
-        token = result.login_token
-        if not token and result.password_challenge:
+        if result.login_token:
+            token = result.login_token
+        elif not result.login_token and result.password_challenge:
             token = await self._authenticate_with_password(
                 app,
                 track_id=result.password_challenge.track_id,
                 hint=result.password_challenge.hint,
             )
+        elif result.register_token:
+            if not app.config.registration_config:
+                raise RuntimeError("RegistrationConfig is required to register a new account")
+            else:
+                registration_config = app.config.registration_config
+                response = await app.api.auth.confirm_registration(
+                    first_name=registration_config.first_name,
+                    last_name=registration_config.last_name,
+                    token=result.register_token,
+                )
+                token = response.token
+        else:
+            logger.error(
+                "Authentication failed: server returned no login token, "
+                "password challenge, or registration token"
+            )
+            token = None
 
         logger.info(
             "sms authentication completed token_set=%s",
@@ -109,23 +127,17 @@ class SmsAuthFlow(AuthFlow):
                 continue
 
             try:
-                response = await app.api.auth.check_password(
-                    track_id, password
-                )
+                response = await app.api.auth.check_password(track_id, password)
             except ApiError as e:
                 logger.error("2fa password check failed: %s", e)
                 continue
 
             if response.error:
-                logger.error(
-                    "2fa password check failed error=%s", response.error
-                )
+                logger.error("2fa password check failed error=%s", response.error)
                 continue
 
             if response.login_token:
                 logger.info("2fa password authentication completed")
                 return response.login_token
 
-            logger.error(
-                "2fa password response did not contain login token; retrying"
-            )
+            logger.error("2fa password response did not contain login token; retrying")

pymax/base.py

@@ -5,7 +5,8 @@ from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Generic, TypeVar
 from uuid import uuid4
 
-from pymax.dispatch import Router
+from pymax.dispatch import ErrorScope, Router
+from pymax.dispatch.router import DisconnectDecorator, ErrorDecorator
 from pymax.infra import BaseMixin
 from pymax.logging import get_logger
 
@@ -22,7 +23,15 @@ if TYPE_CHECKING:
         StartDecorator,
     )
     from pymax.protocol import InboundFrame
-    from pymax.types import Chat, MessageDeleteEvent, User
+    from pymax.types import (
+        Chat,
+        MessageDeleteEvent,
+        MessageReadEvent,
+        PresenceEvent,
+        ReactionUpdateEvent,
+        TypingEvent,
+        User,
+    )
     from pymax.types.domain import Message, Profile
 
 logger = get_logger(__name__)
@@ -83,6 +92,7 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
             sync=self.extra_config.sync,
             store=self.extra_config.store,
             proxy=self.extra_config.proxy,
+            registration_config=self.extra_config.registration_config,
             device=DeviceConfig(
                 mt_instance_id=self.extra_config.mt_instance_id,
                 device_id=self.extra_config.device_id or str(uuid4()),
@@ -119,6 +129,10 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
         while True:
             try:
                 await self._app.start()
+                if not self._app.started:
+                    await self.close()
+                    return
+
                 await self._app.dispatcher.emit_start(self)
                 await self._connection.wait_closed()
             except asyncio.CancelledError:
@@ -129,14 +143,21 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
                 EOFError,
                 OSError,
                 TimeoutError,
-            ):
+            ) as e:
                 await self.close()
+                await self._app.dispatcher.emit_disconnect(
+                    e,
+                    self.extra_config.reconnect,
+                    self.extra_config.reconnect_delay,
+                )
+
                 if not self.extra_config.reconnect:
                     raise
 
-                logger.exception(
+                logger.debug(
                     "client connection failed; reconnecting in %s seconds",
                     self.extra_config.reconnect_delay,
+                    exc_info=True,
                 )
                 await asyncio.sleep(self.extra_config.reconnect_delay)
                 self._reset_runtime()
@@ -186,6 +207,34 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
         """Регистрирует обработчик удаления сообщений."""
         return self._router.on_message_delete(*filters)
 
+    def on_message_read(
+        self,
+        *filters: FilterCallback[MessageReadEvent],
+    ) -> HandlerDecorator[MessageReadEvent, ClientT]:
+        """Регистрирует обработчик изменения отметки прочтения."""
+        return self._router.on_message_read(*filters)
+
+    def on_typing(
+        self,
+        *filters: FilterCallback[TypingEvent],
+    ) -> HandlerDecorator[TypingEvent, ClientT]:
+        """Регистрирует обработчик набора текста."""
+        return self._router.on_typing(*filters)
+
+    def on_presence(
+        self,
+        *filters: FilterCallback[PresenceEvent],
+    ) -> HandlerDecorator[PresenceEvent, ClientT]:
+        """Регистрирует обработчик изменения присутствия пользователя."""
+        return self._router.on_presence(*filters)
+
+    def on_reaction_update(
+        self,
+        *filters: FilterCallback[ReactionUpdateEvent],
+    ) -> HandlerDecorator[ReactionUpdateEvent, ClientT]:
+        """Регистрирует обработчик обновления реакций сообщения."""
+        return self._router.on_reaction_update(*filters)
+
     def on_chat_update(
         self,
         *filters: FilterCallback[Chat],
@@ -200,6 +249,39 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
         """Регистрирует обработчик исходных входящих frame-ов."""
         return self._router.on_raw(*filters)
 
+    def on_error(self, scope: ErrorScope = ErrorScope.GLOBAL) -> ErrorDecorator[ClientT]:
+        """Регистрирует обработчик ошибок dispatch-а и запуска клиента."""
+        return self._router.on_error(scope)
+
+    def on_disconnect(self) -> DisconnectDecorator:
+        """Регистрирует обработчик сетевого отключения перед reconnect."""
+        return self._router.on_disconnect()
+
     def include_router(self, router: Router[ClientT]) -> None:
         """Подключает дочерний router к root router клиента."""
         self._router.include_router(router)
+
+    async def relogin(self: ClientT, drop_config_token: bool = True, start: bool = True) -> None:  # noqa: PYI019
+        """Удаляет текущую локальную сессию и запускает авторизацию заново.
+
+        Args:
+            drop_config_token: Сбросить token, переданный через ``ExtraConfig``.
+            start: Сразу запустить клиента после сброса runtime.
+        """
+        store = self._app.store
+        session = self._app.session
+
+        if session is None:
+            raise RuntimeError("Cannot relogin before session is loaded")
+
+        await store.delete_session(session.token)
+        await self.close()
+
+        if drop_config_token:
+            self.extra_config.token = None
+            self._config.token = None
+
+        self._reset_runtime()
+
+        if start:
+            await self.start()

pymax/client.py

@@ -39,7 +39,7 @@ class Client(BaseClient["Client"]):
         password_provider: Провайдер пароля 2FA, если аккаунт его требует.
     """
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         phone: str,
         session_name: str = "session.db",
@@ -49,6 +49,7 @@ class Client(BaseClient["Client"]):
         sms_code_provider: SmsCodeProvider | None = None,
         password_provider: PasswordProvider | None = None,
     ) -> None:
+
         self.phone = phone
         self.extra_config = extra_config or ExtraConfig()
         self.session_name = session_name

pymax/client_web.py

@@ -54,8 +54,7 @@ class WebClient(BaseClient["WebClient"]):
         self._config = self._build_config(
             phone=None,
             user_agent=(
-                self.extra_config.user_agent
-                or self.extra_config.generate_web_user_agent()
+                self.extra_config.user_agent or self.extra_config.generate_web_user_agent()
             ),
         )