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

pymax/base.py

@@ -4,9 +4,10 @@ import asyncio
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
-from pymax.dispatch import ErrorScope, Router
+from pymax.dispatch import ErrorScope, Middleware, Router
 from pymax.dispatch.router import DisconnectDecorator, ErrorDecorator
 from pymax.exceptions import ApiError
+from pymax.filters import Filter
 from pymax.fingerprint.models import ApkBuildFingerprint
 from pymax.infra import BaseMixin
 from pymax.logging import get_logger
@@ -19,7 +20,6 @@ if TYPE_CHECKING:
     from pymax.auth import AuthFlow
     from pymax.connection import ConnectionManager
     from pymax.dispatch.router import (
-        FilterCallback,
         HandlerDecorator,
         StartDecorator,
     )
@@ -30,6 +30,7 @@ if TYPE_CHECKING:
         MessageReadEvent,
         PresenceEvent,
         ReactionUpdateEvent,
+        StoryPreview,
         TypingEvent,
         User,
     )
@@ -125,7 +126,6 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
 
     @abstractmethod
     def _build_connection(self) -> ConnectionManager:
-
         raise NotImplementedError
 
     @abstractmethod
@@ -140,7 +140,10 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
             return
 
         self._connection = self._build_connection()
-        self._app = self._build_app()
+        if self.__app is not None:
+            self._app.bind_connection(self._connection)
+        else:
+            self._app = self._build_app()
 
     def _init_runtime(self: ClientT, *, auth_flow: AuthFlow) -> None:  # noqa: PYI019
         self._connection = self._build_connection()
@@ -158,14 +161,16 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
         app.dispatcher.bind_client(self)
         return app
 
-    def _reset_runtime(self: ClientT) -> None:  # noqa: PYI019
+    def _reset_connection(self: ClientT) -> None:  # noqa: PYI019
         self._connection = self._build_connection()
-        self._app = self._build_app()
+        self._app.bind_connection(self._connection)
+        # self._app = self._build_app()
 
     async def connect(self: ClientT) -> None:  # noqa: PYI019
-        """Подключает клиента один раз и возвращается после ``on_start``.
+        """Подключает клиента один раз и запускает ``on_start``-обработчики.
 
-        После возврата соединение остается открытым. В отличие от
+        Обработчики старта выполняются в отдельных задачах; метод не ждет
+        их завершения. После возврата соединение остается открытым. В отличие от
         :meth:`start`, метод не ожидает закрытия соединения и не запускает
         reconnect loop; завершите работу через :meth:`stop` или :meth:`close`.
         """
@@ -181,6 +186,9 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
             await self.close()
             raise
         except (ConnectionError, EOFError, OSError, TimeoutError, ApiError) as e:
+            if self.__app is None:
+                raise
+
             await self.close()
 
             await self._app.dispatcher.emit_disconnect(
@@ -189,13 +197,18 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
                 self.extra_config.reconnect_delay,
             )
             raise
+        except Exception:
+            await self.close()
+            raise
 
     async def start(self: ClientT) -> None:  # noqa: PYI019
         """Запускает клиента и слушает события до закрытия соединения.
 
         При сетевых ошибках повторяет подключение, если ``reconnect=True``.
         Отозванный login token автоматически сбрасывается при ``relogin=True``.
+        Если новый token тоже отклонен, ошибка передается вызывающему коду.
         """
+        relogin_attempted = False
         while True:
             try:
                 await self._ensure_runtime()
@@ -204,26 +217,38 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
                     await self.close()
                     return
 
+                relogin_attempted = False
                 await self._app.dispatcher.emit_start(self)
                 await self._connection.wait_closed()
             except asyncio.CancelledError:
                 await self.close()
                 raise
             except ApiError as e:
-                if not self._app._is_invalid_login_token_error(e):
+                if (
+                    not self._app._is_invalid_login_token_error(e)
+                    or not self.extra_config.relogin
+                    or relogin_attempted
+                ):
                     await self.close()
                     raise
 
                 logger.warning("login token was revoked; starting authentication again")
-                if self.extra_config.relogin:
-                    await self.relogin(start=False)
+                relogin_attempted = True
+                await self.relogin(start=False)
             except (
                 ConnectionError,
                 EOFError,
                 OSError,
                 TimeoutError,
             ) as e:
-                await self.close()
+                if self.__app is None:
+                    raise
+
+                if self.extra_config.reconnect:
+                    await self._app.disconnect()
+                else:
+                    await self.close()
+
                 await self._app.dispatcher.emit_disconnect(
                     e,
                     self.extra_config.reconnect,
@@ -239,7 +264,7 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
                     exc_info=True,
                 )
                 await asyncio.sleep(self.extra_config.reconnect_delay)
-                self._reset_runtime()
+                self._reset_connection()
             except Exception:
                 await self.close()
                 raise
@@ -270,63 +295,70 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
 
     def on_message(
         self,
-        *filters: FilterCallback[Message],
+        *filters: Filter[Message, ClientT],
     ) -> HandlerDecorator[Message, ClientT]:
         """Регистрирует обработчик новых сообщений."""
         return self._router.on_message(*filters)
 
     def on_message_edit(
         self,
-        *filters: FilterCallback[Message],
+        *filters: Filter[Message, ClientT],
     ) -> HandlerDecorator[Message, ClientT]:
         """Регистрирует обработчик редактирования сообщений."""
         return self._router.on_message_edit(*filters)
 
     def on_message_delete(
         self,
-        *filters: FilterCallback[MessageDeleteEvent],
+        *filters: Filter[MessageDeleteEvent, ClientT],
     ) -> HandlerDecorator[MessageDeleteEvent, ClientT]:
         """Регистрирует обработчик удаления сообщений."""
         return self._router.on_message_delete(*filters)
 
     def on_message_read(
         self,
-        *filters: FilterCallback[MessageReadEvent],
+        *filters: Filter[MessageReadEvent, ClientT],
     ) -> HandlerDecorator[MessageReadEvent, ClientT]:
         """Регистрирует обработчик изменения отметки прочтения."""
         return self._router.on_message_read(*filters)
 
     def on_typing(
         self,
-        *filters: FilterCallback[TypingEvent],
+        *filters: Filter[TypingEvent, ClientT],
     ) -> HandlerDecorator[TypingEvent, ClientT]:
         """Регистрирует обработчик набора текста."""
         return self._router.on_typing(*filters)
 
     def on_presence(
         self,
-        *filters: FilterCallback[PresenceEvent],
+        *filters: Filter[PresenceEvent, ClientT],
     ) -> HandlerDecorator[PresenceEvent, ClientT]:
         """Регистрирует обработчик изменения присутствия пользователя."""
         return self._router.on_presence(*filters)
 
     def on_reaction_update(
         self,
-        *filters: FilterCallback[ReactionUpdateEvent],
+        *filters: Filter[ReactionUpdateEvent, ClientT],
     ) -> HandlerDecorator[ReactionUpdateEvent, ClientT]:
         """Регистрирует обработчик обновления реакций сообщения."""
         return self._router.on_reaction_update(*filters)
 
     def on_chat_update(
         self,
-        *filters: FilterCallback[Chat],
+        *filters: Filter[Chat, ClientT],
     ) -> HandlerDecorator[Chat, ClientT]:
         """Регистрирует обработчик обновления чата."""
         return self._router.on_chat_update(*filters)
 
+    def on_story_update(
+        self,
+        *filters: Filter[StoryPreview, ClientT],
+    ) -> HandlerDecorator[StoryPreview, ClientT]:
+        """Регистрирует обработчик обновления превью сторис владельца."""
+        return self._router.on_story_update(*filters)
+
     def on_raw(
         self,
-        *filters: FilterCallback[InboundFrame],
+        *filters: Filter[InboundFrame, ClientT],
     ) -> HandlerDecorator[InboundFrame, ClientT]:
         """Регистрирует обработчик исходных входящих frame-ов."""
         return self._router.on_raw(*filters)
@@ -343,12 +375,23 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
         """Подключает дочерний router к root router клиента."""
         self._router.include_router(router)
 
+    def add_middleware(self, middleware: Middleware[ClientT]) -> None:
+        """Добавляет middleware в цепочку обработчиков клиента.
+
+        Middleware вызываются в порядке регистрации после проверки фильтров.
+        Регистрация доступна до запуска клиента и сохраняется при reconnect.
+        """
+        if middleware not in self._router.middlewares:
+            self._router.middlewares.append(middleware)
+        else:
+            logger.warning(f"Middleware {middleware.__class__.__name__} is already registered")
+
     async def relogin(self: ClientT, drop_config_token: bool = True, start: bool = True) -> None:  # noqa: PYI019
         """Удаляет текущую локальную сессию и запускает авторизацию заново.
 
         Args:
             drop_config_token: Сбросить token, переданный через ``ExtraConfig``.
-            start: Сразу запустить клиента после сброса runtime.
+            start: Сразу запустить клиента после сброса сессии.
         """
         store = self._app.store
         session = self._app.session
@@ -357,13 +400,15 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
             raise RuntimeError("Cannot relogin before session is loaded")
 
         await store.delete_session(session.token)
-        await self.close()
+        await self._app.disconnect()
 
         if drop_config_token:
             self.extra_config.token = None
             self._config.token = None
 
-        self._reset_runtime()
+        self._reset_connection()
+
+        self._app.session = None
 
         if start:
             await self.start()

pymax/client.py

@@ -63,7 +63,6 @@ class Client(BaseClient["Client"]):
         app_version: str = VersionCatalog.RECOMMENDED_APP_VERSION,
         catalog: VersionCatalog | None = None,
     ) -> None:
-
         self.phone: str = phone
         self.extra_config: ExtraConfig = extra_config or ExtraConfig()
         self.session_name: str = session_name

pymax/config.py

@@ -57,42 +57,48 @@ APP_VERSIONS: tuple[tuple[str, int], ...] = (
     # ("26.9.1", 6643),
 )
 ANDROID_DEVICES: tuple[tuple[str, str, str, str], ...] = (
-    ("Samsung SM-A525F", "Android 13", "405dpi 405dpi 1080x2400", "arm64-v8a"),
-    ("Samsung SM-A536B", "Android 14", "405dpi 405dpi 1080x2400", "arm64-v8a"),
-    ("Samsung SM-A546E", "Android 14", "405dpi 405dpi 1080x2340", "arm64-v8a"),
-    ("Samsung SM-G991B", "Android 14", "421dpi 421dpi 1080x2400", "arm64-v8a"),
-    ("Samsung SM-G998B", "Android 13", "515dpi 515dpi 1440x3200", "arm64-v8a"),
-    ("Samsung SM-S901B", "Android 14", "425dpi 425dpi 1080x2340", "arm64-v8a"),
-    ("Samsung SM-S911B", "Android 14", "425dpi 425dpi 1080x2340", "arm64-v8a"),
-    ("Xiaomi 2109119DG", "Android 13", "395dpi 395dpi 1080x2400", "arm64-v8a"),
-    ("Xiaomi 2201117TG", "Android 13", "395dpi 395dpi 1080x2400", "arm64-v8a"),
-    ("Xiaomi 2201123G", "Android 14", "526dpi 526dpi 1440x3200", "arm64-v8a"),
-    ("Xiaomi 2210132G", "Android 14", "446dpi 446dpi 1220x2712", "arm64-v8a"),
     (
-        "Xiaomi 23049PCD8G",
+        "Google Pixel 6a",
+        "Android 13",
+        "420dpi 420dpi 1080x2400",
+        "arm64-v8a",
+    ),
+    (
+        "Google Pixel 7",
+        "Android 13",
+        "420dpi 420dpi 1080x2400",
+        "arm64-v8a",
+    ),
+    (
+        "Google Pixel 7 Pro",
+        "Android 13",
+        "560dpi 560dpi 1440x3120",
+        "arm64-v8a",
+    ),
+    (
+        "Google Pixel 8",
         "Android 14",
-        "446dpi 446dpi 1220x2712",
+        "420dpi 420dpi 1080x2400",
+        "arm64-v8a",
+    ),
+    (
+        "samsung SM-G991B",
+        "Android 14",
+        "xxhdpi 480dpi 1080x2400",
+        "arm64-v8a",
+    ),
+    (
+        "samsung SM-S911B",
+        "Android 15",
+        "xxhdpi 480dpi 1080x2340",
+        "arm64-v8a",
+    ),
+    (
+        "Xiaomi 2201117TG",
+        "Android 13",
+        "440dpi 440dpi 1080x2400",
         "arm64-v8a",
     ),
-    ("Redmi 2201116TG", "Android 13", "395dpi 395dpi 1080x2400", "arm64-v8a"),
-    ("Redmi 22101316G", "Android 13", "395dpi 395dpi 1080x2400", "arm64-v8a"),
-    ("Redmi 23021RAA2Y", "Android 14", "395dpi 395dpi 1080x2400", "arm64-v8a"),
-    ("POCO 22011211G", "Android 13", "395dpi 395dpi 1080x2400", "arm64-v8a"),
-    ("POCO 23049PCD8G", "Android 14", "446dpi 446dpi 1220x2712", "arm64-v8a"),
-    ("Pixel 6", "Android 14", "411dpi 411dpi 1080x2400", "arm64-v8a"),
-    ("Pixel 6a", "Android 14", "429dpi 429dpi 1080x2400", "arm64-v8a"),
-    ("Pixel 7", "Android 14", "416dpi 416dpi 1080x2400", "arm64-v8a"),
-    ("Pixel 7 Pro", "Android 14", "512dpi 512dpi 1440x3120", "arm64-v8a"),
-    ("Pixel 8", "Android 14", "428dpi 428dpi 1080x2400", "arm64-v8a"),
-    ("OnePlus NE2213", "Android 14", "525dpi 525dpi 1440x3216", "arm64-v8a"),
-    ("OnePlus CPH2449", "Android 14", "451dpi 451dpi 1240x2772", "arm64-v8a"),
-    ("realme RMX3085", "Android 13", "409dpi 409dpi 1080x2400", "arm64-v8a"),
-    ("realme RMX3370", "Android 13", "409dpi 409dpi 1080x2400", "arm64-v8a"),
-    ("realme RMX3630", "Android 13", "400dpi 400dpi 1080x2412", "arm64-v8a"),
-    ("HUAWEI ELS-NX9", "Android 12", "441dpi 441dpi 1080x2340", "arm64-v8a"),
-    ("HUAWEI VOG-L29", "Android 12", "398dpi 398dpi 1080x2340", "arm64-v8a"),
-    ("HONOR RMO-NX1", "Android 13", "391dpi 391dpi 1080x2388", "arm64-v8a"),
-    ("HONOR REA-NX9", "Android 13", "435dpi 435dpi 1200x2664", "arm64-v8a"),
 )
 LOCALE_TIMEZONES: tuple[tuple[str, str], ...] = (
     ("ru", "Europe/Moscow"),

pymax/di/__init__.py

@@ -0,0 +1,2 @@
+from .context import DiContext
+from .resolver import DiResolver

pymax/di/context.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+if TYPE_CHECKING:
+    from pymax.app import App
+    from pymax.base import BaseClient
+    from pymax.dispatch.mapping import DispatchEvent
+
+ClientT = TypeVar("ClientT", bound="BaseClient")
+
+
+@dataclass(slots=True)
+class DiContext(Generic[ClientT]):
+    app: App[ClientT]
+    event: DispatchEvent
+    client: ClientT

pymax/di/resolver.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from logging import getLogger
+from typing import Any, TypeAlias
+
+from pymax.fsm import FSMContext
+from pymax.types import Message
+
+from .context import DiContext
+
+logger = getLogger()
+
+
+async def resolve_fsm(ctx: DiContext) -> FSMContext | None:
+    if not isinstance(ctx.event, Message):
+        raise ValueError("Fsm is not currently working for non-message handlers.")
+
+    if not ctx.event.chat_id or not ctx.event.sender:
+        logger.warning("Not enough data in message event. Skipping fsm")
+        return None
+
+    return ctx.app.fsm_storage.get_context(ctx.client, ctx.event)
+
+
+Resolver: TypeAlias = Callable[[DiContext], Awaitable[Any]]
+
+DI_MAP: dict[type, Resolver] = {FSMContext: resolve_fsm}
+
+
+class DiResolver:
+    async def resolve(self, annotation: Any, ctx: DiContext) -> None | Any:
+        resolver = DI_MAP.get(annotation)
+
+        if resolver is None:
+            return None
+
+        return await resolver(ctx)

pymax/dispatch/__init__.py

@@ -1,11 +1,14 @@
 from .dispatcher import Dispatcher
 from .enums import EventType
+from .mapping import DispatchEvent
+from .middleware import Middleware, MiddlewareNext
 from .router import (
     ClientRouter,
     DisconnectCallback,
     DisconnectDecorator,
     ErrorContext,
     ErrorScope,
+    HandlerCallback,
     Router,
 )
 
@@ -13,9 +16,13 @@ __all__ = (
     "ClientRouter",
     "DisconnectCallback",
     "DisconnectDecorator",
+    "DispatchEvent",
     "Dispatcher",
     "ErrorContext",
     "ErrorScope",
     "EventType",
+    "HandlerCallback",
+    "Middleware",
+    "MiddlewareNext",
     "Router",
 )