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

pymax/config.py

@@ -84,6 +84,21 @@ class DeviceConfig(BaseModel):
     client_session_id: int = Field(default_factory=lambda: randint(1, 70))
 
 
+class RegistrationConfig(BaseModel):
+    """Данные профиля для регистрации нового аккаунта по SMS.
+
+    Передайте объект через ``ExtraConfig.registration_config``. Он используется
+    только если после подтверждения SMS-кода Max вернул токен регистрации.
+
+    Args:
+        first_name: Имя нового пользователя.
+        last_name: Фамилия нового пользователя.
+    """
+
+    first_name: str
+    last_name: str | None = None
+
+
 class ClientConfig(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -93,6 +108,7 @@ class ClientConfig(BaseModel):
     device: DeviceConfig
     token: str | None = None
     proxy: str | None = None
+    registration_config: RegistrationConfig | None = None
 
     host: str = "api.oneme.ru"
     port: int = 443
@@ -109,9 +125,7 @@ class ClientConfig(BaseModel):
 
     def ensure_config(self) -> None:
         if not self.phone:
-            raise ValueError(
-                "Phone must be provided when no saved session exists."
-            )
+            raise ValueError("Phone must be provided when no saved session exists.")
 
 
 class ExtraConfig(BaseModel):
@@ -122,6 +136,8 @@ class ExtraConfig(BaseModel):
 
     Args:
         token: Готовый token для создания сессии без SMS/QR.
+        registration_config: Имя и фамилия для автоматического завершения
+            регистрации нового аккаунта по SMS.
         host: TCP host Max API.
         port: TCP port Max API.
         url: WebSocket URL для ``WebClient``.
@@ -156,6 +172,7 @@ class ExtraConfig(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     token: str | None = None
+    registration_config: RegistrationConfig | None = None
 
     host: str = "api.oneme.ru"
     port: int = 443
@@ -221,3 +238,25 @@ class ExtraConfig(BaseModel):
             device_locale=locale,
             header_user_agent=DEFAULT_WEB_HEADER_USER_AGENT,
         )
+
+
+# ignore. for future upd
+
+# class TcpOptions(BaseModel):
+#     host: str = "api.oneme.ru"
+#     port: int = 443
+#     use_ssl: bool = True
+#     proxy: str | None = None
+
+
+# class RuntimeOptions(BaseModel):
+#     request_timeout: float = 30.0
+#     reconnect: bool = True
+#     reconnect_delay: float = 1.0
+
+
+# class DeviceOptions(BaseModel):
+#     device_id: str | None = None
+#     device_type: DeviceType = DeviceType.ANDROID
+#     user_agent: MobileUserAgentPayload | None = None
+#     mt_instance_id: str = Field(default_factory=lambda: str(uuid4()))

pymax/connection/connection.py

@@ -183,7 +183,9 @@ class ConnectionManager:
         except Exception as e:
             exc = ConnectionError(f"Connection error: {e}")
             logger.exception("connection receive loop failed")
+
             self.requests.cancel_all(exc=exc)
+
             self._connection_lost = True
             self._mark_closed(exc)
             raise e

pymax/connection/readers/tcp.py

@@ -8,9 +8,7 @@ logger = get_logger(__name__)
 
 
 class TCPReader(BaseReader):
-    def __init__(
-        self, transport: TCPTransport, framer: TcpPacketFramer
-    ) -> None:
+    def __init__(self, transport: TCPTransport, framer: TcpPacketFramer) -> None:
         super().__init__()
         self.transport = transport
         self.framer = framer

pymax/dispatch/__init__.py

@@ -1,10 +1,21 @@
 from .dispatcher import Dispatcher
 from .enums import EventType
-from .router import ClientRouter, Router
+from .router import (
+    ClientRouter,
+    DisconnectCallback,
+    DisconnectDecorator,
+    ErrorContext,
+    ErrorScope,
+    Router,
+)
 
 __all__ = (
     "ClientRouter",
+    "DisconnectCallback",
+    "DisconnectDecorator",
     "Dispatcher",
+    "ErrorContext",
+    "ErrorScope",
     "EventType",
     "Router",
 )

pymax/dispatch/dispatcher.py

@@ -9,15 +9,29 @@ from pymax.logging import get_logger
 from pymax.protocol import InboundFrame
 from pymax.types import Chat, MessageDeleteEvent
 from pymax.types.domain import Message
+from pymax.types.events import (
+    MessageReadEvent,
+    PresenceEvent,
+    ReactionUpdateEvent,
+    TypingEvent,
+)
 
 from .enums import EventType
 from .mapping import EventMapper, EventResolver
 from .router import (
+    DisconnectCallback,
+    DisconnectDecorator,
+    ErrorContext,
+    ErrorDecorator,
+    ErrorEntry,
+    ErrorScope,
+    ErrorSource,
     FilterCallback,
     HandlerCallback,
     HandlerDecorator,
     HandlerEntry,
     Router,
+    StartCallback,
     StartDecorator,
 )
 
@@ -25,17 +39,16 @@ if TYPE_CHECKING:
     from collections.abc import Generator
 
     from pymax.app import App
+    from pymax.base import BaseClient
 
 
 logger = get_logger(__name__)
 
-ClientT = TypeVar("ClientT")
+ClientT = TypeVar("ClientT", bound="BaseClient")
 
 
 class Dispatcher(Generic[ClientT]):
-    def __init__(
-        self, app: App, root_router: Router[ClientT] | None = None
-    ) -> None:
+    def __init__(self, app: App, root_router: Router[ClientT] | None = None) -> None:
         self.root_router: Router[ClientT] = root_router or Router()
         self.internal_router: Router[ClientT] = Router()
         self.resolver = EventResolver()
@@ -71,11 +84,16 @@ class Dispatcher(Generic[ClientT]):
         event: EventType,
         *filters: FilterCallback[Any],
     ) -> HandlerDecorator[Any, ClientT]:
-        logger.debug(
-            "registering handler event=%s filters=%s", event, len(filters)
-        )
+        logger.debug("registering handler event=%s filters=%s", event, len(filters))
         return self.root_router.on(event, *filters)
 
+    def on_error(self, scope: ErrorScope = ErrorScope.GLOBAL) -> ErrorDecorator[ClientT]:
+        return self.root_router.on_error(scope)
+
+    def on_disconnect(self) -> DisconnectDecorator:
+        """Регистрирует обработчик сетевого отключения на root router."""
+        return self.root_router.on_disconnect()
+
     def on_message(
         self,
         *filters: FilterCallback[Message],
@@ -87,9 +105,7 @@ class Dispatcher(Generic[ClientT]):
         self,
         *filters: FilterCallback[Message],
     ) -> HandlerDecorator[Message, ClientT]:
-        logger.debug(
-            "registering message edit handler filters=%s", len(filters)
-        )
+        logger.debug("registering message edit handler filters=%s", len(filters))
         return self.root_router.on_message_edit(*filters)
 
     def on_message_delete(
@@ -98,6 +114,30 @@ class Dispatcher(Generic[ClientT]):
     ) -> HandlerDecorator[MessageDeleteEvent, ClientT]:
         return self.root_router.on_message_delete(*filters)
 
+    def on_message_read(
+        self,
+        *filters: FilterCallback[MessageReadEvent],
+    ) -> HandlerDecorator[MessageReadEvent, ClientT]:
+        return self.root_router.on_message_read(*filters)
+
+    def on_typing(
+        self,
+        *filters: FilterCallback[TypingEvent],
+    ) -> HandlerDecorator[TypingEvent, ClientT]:
+        return self.root_router.on_typing(*filters)
+
+    def on_presence(
+        self,
+        *filters: FilterCallback[PresenceEvent],
+    ) -> HandlerDecorator[PresenceEvent, ClientT]:
+        return self.root_router.on_presence(*filters)
+
+    def on_reaction_update(
+        self,
+        *filters: FilterCallback[ReactionUpdateEvent],
+    ) -> HandlerDecorator[ReactionUpdateEvent, ClientT]:
+        return self.root_router.on_reaction_update(*filters)
+
     def on_chat_update(
         self,
         *filters: FilterCallback[Chat],
@@ -116,30 +156,68 @@ class Dispatcher(Generic[ClientT]):
     def iter_routers(self) -> Generator[Router[ClientT], Any, None]:
         yield from self._iter_router(self.root_router)
 
-    def _iter_router(
-        self, router: Router[ClientT]
-    ) -> Generator[Router[ClientT], Any, None]:
+    def _iter_router(self, router: Router[ClientT]) -> Generator[Router[ClientT], Any, None]:
         yield router
 
         for child in router.children:
             yield from self._iter_router(child)
 
-    async def emit_start(self, client: ClientT) -> None:
-        tasks: list[asyncio.Task[Any]] = []
+    def iter_error_entries(
+        self,
+    ) -> Generator[tuple[Router[ClientT], ErrorEntry[ClientT]], Any, None]:
+        for router in self.iter_routers():
+            for entry in router.error_handlers:
+                yield router, entry
 
+    def iter_disconnect_handlers(self) -> Generator[DisconnectCallback, Any, None]:
+        """Итерирует обработчики disconnect по root router и его детям."""
         for router in self.iter_routers():
-            handler = router.on_start_handler
-            if handler is None:
+            yield from router.disconnect_handlers
+
+    def iter_error_handlers(
+        self,
+        failed_router: Router[ClientT],
+    ) -> Generator[ErrorEntry[ClientT], Any, None]:
+        for owner_router, entry in self.iter_error_entries():
+            if entry.scope is ErrorScope.LOCAL and owner_router is not failed_router:
                 continue
 
-            result = handler(client)
+            yield entry
 
-            if inspect.iscoroutine(result):
-                task = asyncio.create_task(result)
+    async def emit_start(self, client: ClientT) -> None:
+        tasks: list[asyncio.Task[Any]] = []
+
+        for router in self.iter_routers():  # TODO: create iter_on_start_handlers
+            for handler in router.on_start_handlers:
+                task = asyncio.create_task(self._run_start_handler(router, handler, client))
                 task.add_done_callback(_log_task_error)
                 tasks.append(task)
 
-        self.startup_tasks = tasks
+        self.startup_tasks.extend(tasks)
+
+    async def _run_start_handler(
+        self,
+        router: Router[ClientT],
+        handler: StartCallback[ClientT],
+        client: ClientT,
+    ) -> None:
+        try:
+            result = handler(client)
+
+            if inspect.isawaitable(result):
+                await result
+
+        except Exception as e:
+            handled = await self.emit_error(
+                e,
+                EventType.ON_START,
+                None,
+                router,
+                handler,
+            )
+
+            if not handled:
+                raise
 
     async def stop_startup_tasks(self) -> None:
         if not self.startup_tasks:
@@ -161,9 +239,7 @@ class Dispatcher(Generic[ClientT]):
         if event_type is not None:
             logger.debug("dispatching event type=%s", event_type)
             event = self.mapper.map(event_type, frame)
-            await self._dispatch_to_router(
-                self.internal_router, event_type, event
-            )
+            await self._dispatch_to_router(self.internal_router, event_type, event)
             await self._dispatch_to_router(self.root_router, event_type, event)
         else:
             logger.debug(
@@ -181,13 +257,18 @@ class Dispatcher(Generic[ClientT]):
         event: Any,
     ) -> None:
         for entry in router.handlers.get(event_type, []):
-            if await self._matches(entry, event):
-                logger.debug(
-                    "calling handler event=%s callback=%s",
-                    event_type,
-                    _callback_name(entry.callback),
-                )
-                await self._call(entry.callback, event)
+            try:
+                if await self._matches(entry, event):
+                    logger.debug(
+                        "calling handler event=%s callback=%s",
+                        event_type,
+                        _callback_name(entry.callback),
+                    )
+                    await self._call(entry.callback, event)
+            except Exception as e:  # noqa: PERF203
+                handled = await self.emit_error(e, event_type, event, router, entry)
+                if not handled:
+                    raise
 
         for child in router.children:
             await self._dispatch_to_router(child, event_type, event)
@@ -209,9 +290,7 @@ class Dispatcher(Generic[ClientT]):
                 return False
         return True
 
-    async def _call(
-        self, callback: HandlerCallback[Any, ClientT], event: Any
-    ) -> Any:
+    async def _call(self, callback: HandlerCallback[Any, ClientT], event: Any) -> Any:
         if self.client is None:
             raise RuntimeError("client is not bound")
 
@@ -222,6 +301,63 @@ class Dispatcher(Generic[ClientT]):
 
         return result
 
+    async def emit_error(
+        self,
+        exception: Exception,
+        event_type: EventType,
+        event: Any,
+        router: Router[ClientT],
+        handler: ErrorSource[ClientT] | None,
+    ) -> bool:
+        client = self.client
+        handled = False
+
+        if client is None:
+            raise RuntimeError("client is not bound to dispatcher")
+
+        ctx = ErrorContext[ClientT](
+            client=client,
+            event_type=event_type,
+            event=event,
+            router=router,
+            handler=handler,
+        )
+        for entry in self.iter_error_handlers(router):
+            handled = True
+            try:
+                result = entry.callback(exception, ctx)
+
+                if inspect.isawaitable(result):
+                    await result
+            except Exception as e:
+                logger.exception("Error while error handling: %s", e)
+                return False
+
+        return handled
+
+    async def emit_disconnect(
+        self,
+        exception: Exception,
+        reconnect: bool,
+        delay: float,
+    ) -> None:
+        """Вызывает обработчики потери соединения.
+
+        Ошибки внутри disconnect-handler-ов логируются и не прерывают reconnect.
+        """
+
+        if self.client is None:
+            raise RuntimeError("client is not bound to dispatcher")
+
+        for handler in self.iter_disconnect_handlers():
+            try:
+                result = handler(exception, reconnect, delay)
+
+                if inspect.isawaitable(result):
+                    await result
+            except Exception as e:
+                logger.exception("Error during disconnect handling: %s", e)
+
 
 def _callback_name(callback: Any) -> str:
     return getattr(

pymax/dispatch/enums.py

@@ -5,8 +5,13 @@ class EventType(str, Enum):
     MESSAGE_NEW = "message_new"
     MESSAGE_EDIT = "message_edit"
     MESSAGE_DELETE = "message_delete"
+    MESSAGE_READ = "message_read"
+    TYPING = "typing"
+    PRESENCE = "presence"
+    REACTION_UPDATE = "reaction_update"
     CHAT_UPDATE = "chat_update"
     USER_UPDATE = "user_update"
     VIDEO_READY = "video_ready"
     FILE_READY = "file_ready"
     RAW = "raw"
+    ON_START = "on_start"

pymax/dispatch/mapping.py

@@ -3,11 +3,19 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import TYPE_CHECKING
 
+from pymax.api.binding import bind_api_model
 from pymax.protocol import InboundFrame, Opcode
 from pymax.protocol.enums import Command
 from pymax.types import Chat, MessageDeleteEvent
 from pymax.types.domain import Message
-from pymax.types.events import FileUploadSignal, VideoUploadSignal
+from pymax.types.events import (
+    FileUploadSignal,
+    MessageReadEvent,
+    PresenceEvent,
+    ReactionUpdateEvent,
+    TypingEvent,
+    VideoUploadSignal,
+)
 
 from .enums import EventType
 from .resolvers import (
@@ -15,6 +23,10 @@ from .resolvers import (
     resolve_chat,
     resolve_message,
     resolve_message_delete,
+    resolve_message_read,
+    resolve_presence,
+    resolve_reaction_update,
+    resolve_typing,
 )
 
 if TYPE_CHECKING:
@@ -28,6 +40,10 @@ EVENT_MAP: dict[Opcode, Resolver] = {
     Opcode.NOTIF_CHAT: resolve_chat,
     Opcode.NOTIF_MSG_DELETE: resolve_message_delete,
     Opcode.NOTIF_ATTACH: resolve_attach,
+    Opcode.NOTIF_TYPING: resolve_typing,
+    Opcode.NOTIF_MARK: resolve_message_read,
+    Opcode.NOTIF_PRESENCE: resolve_presence,
+    Opcode.NOTIF_MSG_REACTIONS_CHANGED: resolve_reaction_update,
 }
 
 
@@ -58,21 +74,28 @@ class EventMapper:
 
         if frame.payload:
             if event_type in (EventType.MESSAGE_NEW, EventType.MESSAGE_EDIT):
-                return Message.model_validate(frame.payload).bind(
-                    self.app.api.messages
+                return bind_api_model(
+                    self.app,
+                    Message.model_validate(frame.payload),
                 )
             elif event_type == EventType.CHAT_UPDATE:
-                return Chat.model_validate(frame.payload["chat"]).bind(
-                    self.app.api.messages,
-                    self.app.api.chats,
+                return bind_api_model(
+                    self.app,
+                    Chat.model_validate(frame.payload["chat"]),
                 )
             elif event_type == EventType.MESSAGE_DELETE:
-                model = MessageDeleteEvent.model_validate(frame.payload)
-                model.chat.bind(
-                    self.app.api.messages,
-                    self.app.api.chats,
+                return bind_api_model(
+                    self.app,
+                    MessageDeleteEvent.model_validate(frame.payload),
                 )
-                return model
+            elif event_type == EventType.MESSAGE_READ:
+                return MessageReadEvent.model_validate(frame.payload)
+            elif event_type == EventType.TYPING:
+                return TypingEvent.model_validate(frame.payload)
+            elif event_type == EventType.PRESENCE:
+                return PresenceEvent.model_validate(frame.payload)
+            elif event_type == EventType.REACTION_UPDATE:
+                return ReactionUpdateEvent.model_validate(frame.payload)
             elif event_type == EventType.VIDEO_READY:
                 return VideoUploadSignal.model_validate(frame.payload)
             elif event_type == EventType.FILE_READY:

pymax/dispatch/resolvers.py

@@ -20,6 +20,22 @@ def resolve_message_delete(_: InboundFrame) -> EventType | None:
     return EventType.MESSAGE_DELETE
 
 
+def resolve_message_read(_: InboundFrame) -> EventType | None:
+    return EventType.MESSAGE_READ
+
+
+def resolve_typing(_: InboundFrame) -> EventType | None:
+    return EventType.TYPING
+
+
+def resolve_presence(_: InboundFrame) -> EventType | None:
+    return EventType.PRESENCE
+
+
+def resolve_reaction_update(_: InboundFrame) -> EventType | None:
+    return EventType.REACTION_UPDATE
+
+
 def resolve_attach(frame: InboundFrame) -> EventType | None:
     try:
         FileUploadSignal.model_validate(frame.payload)
@@ -45,6 +61,8 @@ def resolve_message(frame: InboundFrame) -> EventType | None:
 
         if model.status == MessageStatus.EDITED:
             return EventType.MESSAGE_EDIT
+        if model.status == MessageStatus.REMOVED:
+            return EventType.MESSAGE_DELETE
         else:
             return EventType.MESSAGE_NEW
     except ValidationError: