telegrinder 0.1.dev168__py3-none-any.whl → 0.1.dev170__py3-none-any.whl

telegrinder/bot/dispatch/view/abc.py

@@ -16,12 +16,12 @@ from telegrinder.msgspec_utils import Option
 from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
 from telegrinder.types.objects import Update
 
-EventType = typing.TypeVar("EventType", bound=BaseCute)
+Event = typing.TypeVar("Event", bound=BaseCute)
 ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler)
 MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
 
 FuncType: typing.TypeAlias = typing.Callable[
-    typing.Concatenate[EventType, ...],
+    typing.Concatenate[Event, ...],
     typing.Coroutine[typing.Any, typing.Any, typing.Any],
 ]
 
@@ -46,20 +46,24 @@ class ABCView(ABC):
         pass
 
 
-class ABCStateView(ABCView, typing.Generic[EventType]):
+class ABCStateView(ABCView, typing.Generic[Event]):
     @abstractmethod
-    def get_state_key(self, event: EventType) -> int | None:
+    def get_state_key(self, event: Event) -> int | None:
         pass
 
 
-class BaseView(ABCView, typing.Generic[EventType]):
-    auto_rules: list[ABCRule[EventType]]
-    handlers: list[ABCHandler[EventType]]
-    middlewares: list[ABCMiddleware[EventType]]
-    return_manager: ABCReturnManager[EventType] | None
+class BaseView(ABCView, typing.Generic[Event]):
+    auto_rules: list[ABCRule]
+    handlers: list[ABCHandler[Event]]
+    middlewares: list[ABCMiddleware[Event]]
+    return_manager: ABCReturnManager[Event] | None = None
+
+    @staticmethod
+    def get_raw_event(update: Update) -> Option[Model]:
+        return getattr(update, update.update_type.value)
 
     @classmethod
-    def get_event_type(cls) -> Option[type[EventType]]:
+    def get_event_type(cls) -> Option[type[Event]]:
         for base in cls.__dict__.get("__orig_bases__", ()):
             if issubclass(typing.get_origin(base) or base, ABCView):
                 for generic_type in typing.get_args(base):
@@ -67,55 +71,45 @@ class BaseView(ABCView, typing.Generic[EventType]):
                         return Some(generic_type)
         return Nothing()
 
-    @staticmethod
-    def get_raw_event(update: Update) -> Option[Model]:
-        match update.update_type:
-            case Some(update_type):
-                return getattr(update, update_type.value)
-            case _:
-                return Nothing()
-    
     @typing.overload
     @classmethod
     def to_handler(
         cls,
-        *rules: ABCRule[EventType],
+        *rules: ABCRule,
     ) -> typing.Callable[
-        [FuncType[EventType]],
-        FuncHandler[EventType, FuncType[EventType], ErrorHandler[EventType]],
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
     ]: ...
 
     @typing.overload
     @classmethod
     def to_handler(
         cls,
-        *rules: ABCRule[EventType],
+        *rules: ABCRule,
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[
-        [FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandlerT]
-    ]: ...
+    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
 
     @typing.overload
     @classmethod
     def to_handler(
         cls,
-        *rules: ABCRule[EventType],
+        *rules: ABCRule,
         error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
     ) -> typing.Callable[
-        [FuncType[EventType]],
-        FuncHandler[EventType, FuncType[EventType], ErrorHandler[EventType]],
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
     ]: ...
 
     @classmethod
     def to_handler(  # type: ignore
         cls,
-        *rules: ABCRule[EventType],
+        *rules: ABCRule,
         error_handler: ABCErrorHandler | None = None,
         is_blocking: bool = True,
     ):
-        def wrapper(func: FuncType[EventType]):
+        def wrapper(func: FuncType[Event]):
             return FuncHandler(
                 func,
                 list(rules),
@@ -129,40 +123,38 @@ class BaseView(ABCView, typing.Generic[EventType]):
     @typing.overload
     def __call__(
         self,
-        *rules: ABCRule[EventType],
+        *rules: ABCRule,
     ) -> typing.Callable[
-        [FuncType[EventType]],
-        FuncHandler[EventType, FuncType[EventType], ErrorHandler[EventType]],
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
     ]: ...
 
     @typing.overload
-    def __call__(
+    def __call__(  # type: ignore
         self,
-        *rules: ABCRule[EventType],
+        *rules: ABCRule,
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[
-        [FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandlerT]
-    ]: ...
+    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
 
     @typing.overload
     def __call__(
         self,
-        *rules: ABCRule[EventType],
+        *rules: ABCRule,
         error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
     ) -> typing.Callable[
-        [FuncType[EventType]],
-        FuncHandler[EventType, FuncType[EventType], ErrorHandler[EventType]],
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
     ]: ...
 
     def __call__(  # type: ignore
         self,
-        *rules: ABCRule[EventType],
+        *rules: ABCRule,
         error_handler: ABCErrorHandler | None = None,
         is_blocking: bool = True,
     ):
-        def wrapper(func: FuncType[EventType]):
+        def wrapper(func: FuncType[Event]):
             func_handler = FuncHandler(
                 func,
                 [*self.auto_rules, *rules],
@@ -214,9 +206,9 @@ class BaseView(ABCView, typing.Generic[EventType]):
         self.middlewares.extend(external.middlewares)
 
 
-class BaseStateView(ABCStateView[EventType], BaseView[EventType], ABC, typing.Generic[EventType]):
+class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Event]):
     @abstractmethod
-    def get_state_key(self, event: EventType) -> int | None:
+    def get_state_key(self, event: Event) -> int | None:
         pass
 
 

telegrinder/bot/dispatch/view/box.py

@@ -2,95 +2,111 @@ import dataclasses
 
 import typing_extensions as typing
 
+from telegrinder.bot.dispatch.view import (
+    callback_query,
+    chat_join_request,
+    chat_member,
+    inline_query,
+    message,
+    raw,
+)
+from telegrinder.bot.dispatch.view.abc import ABCView
 from telegrinder.types.enums import UpdateType
 
-from .abc import ABCView
-from .callback_query import CallbackQueryView
-from .chat_join_request import ChatJoinRequestView
-from .chat_member import ChatMemberView
-from .inline_query import InlineQueryView
-from .message import MessageView
-from .raw import RawEventView
-
-CallbackQueryViewT = typing.TypeVar("CallbackQueryViewT", bound=ABCView, default=CallbackQueryView)
-ChatJoinRequestViewT = typing.TypeVar(
-    "ChatJoinRequestViewT", bound=ABCView, default=ChatJoinRequestView
+CallbackQueryView = typing.TypeVar(
+    "CallbackQueryView", bound=ABCView, default=callback_query.CallbackQueryView
 )
-ChatMemberViewT = typing.TypeVar("ChatMemberViewT", bound=ABCView, default=ChatMemberView)
-InlineQueryViewT = typing.TypeVar("InlineQueryViewT", bound=ABCView, default=InlineQueryView)
-MessageViewT = typing.TypeVar("MessageViewT", bound=ABCView, default=MessageView)
-RawEventViewT = typing.TypeVar("RawEventViewT", bound=ABCView, default=RawEventView)
+ChatJoinRequestView = typing.TypeVar(
+    "ChatJoinRequestView", bound=ABCView, default=chat_join_request.ChatJoinRequestView
+)
+ChatMemberView = typing.TypeVar("ChatMemberView", bound=ABCView, default=chat_member.ChatMemberView)
+InlineQueryView = typing.TypeVar("InlineQueryView", bound=ABCView, default=inline_query.InlineQueryView)
+MessageView = typing.TypeVar("MessageView", bound=ABCView, default=message.MessageView)
+RawEventView = typing.TypeVar("RawEventView", bound=ABCView, default=raw.RawEventView)
 
 
 @dataclasses.dataclass(kw_only=True)
 class ViewBox(
     typing.Generic[
-        CallbackQueryViewT,
-        ChatJoinRequestViewT,
-        ChatMemberViewT,
-        InlineQueryViewT,
-        MessageViewT,
-        RawEventViewT,
+        CallbackQueryView,
+        ChatJoinRequestView,
+        ChatMemberView,
+        InlineQueryView,
+        MessageView,
+        RawEventView,
     ],
 ):
-    callback_query: CallbackQueryViewT = dataclasses.field(
-        default_factory=lambda: typing.cast(CallbackQueryViewT, CallbackQueryView()),
+    callback_query: CallbackQueryView = dataclasses.field(
+        default_factory=lambda: typing.cast(
+            CallbackQueryView,
+            callback_query.CallbackQueryView(),
+        ),
     )
-    chat_join_request: ChatJoinRequestViewT = dataclasses.field(
-        default_factory=lambda: typing.cast(ChatJoinRequestViewT, ChatJoinRequestView()),
+    chat_join_request: ChatJoinRequestView = dataclasses.field(
+        default_factory=lambda: typing.cast(
+            ChatJoinRequestView,
+            chat_join_request.ChatJoinRequestView(),
+        ),
     )
-    chat_member: ChatMemberViewT = dataclasses.field(
+    chat_member: ChatMemberView = dataclasses.field(
         default_factory=lambda: typing.cast(
-            ChatMemberViewT, ChatMemberView(update_type=UpdateType.CHAT_MEMBER)
+            ChatMemberView,
+            chat_member.ChatMemberView(update_type=UpdateType.CHAT_MEMBER),
         ),
     )
-    my_chat_member: ChatMemberViewT = dataclasses.field(
+    my_chat_member: ChatMemberView = dataclasses.field(
         default_factory=lambda: typing.cast(
-            ChatMemberViewT, ChatMemberView(update_type=UpdateType.MY_CHAT_MEMBER)
+            ChatMemberView,
+            chat_member.ChatMemberView(update_type=UpdateType.MY_CHAT_MEMBER),
         ),
     )
-    inline_query: InlineQueryViewT = dataclasses.field(
-        default_factory=lambda: typing.cast(InlineQueryViewT, InlineQueryView()),
+    inline_query: InlineQueryView = dataclasses.field(
+        default_factory=lambda: typing.cast(InlineQueryView, inline_query.InlineQueryView()),
     )
-    message: MessageViewT = dataclasses.field(
+    message: MessageView = dataclasses.field(
         default_factory=lambda: typing.cast(
-            MessageViewT, MessageView(update_type=UpdateType.MESSAGE)
+            MessageView,
+            message.MessageView(update_type=UpdateType.MESSAGE),
         ),
     )
-    business_message: MessageViewT = dataclasses.field(
+    business_message: MessageView = dataclasses.field(
         default_factory=lambda: typing.cast(
-            MessageViewT, MessageView(update_type=UpdateType.BUSINESS_MESSAGE)
+            MessageView,
+            message.MessageView(update_type=UpdateType.BUSINESS_MESSAGE),
         ),
     )
-    channel_post: MessageViewT = dataclasses.field(
+    channel_post: MessageView = dataclasses.field(
         default_factory=lambda: typing.cast(
-            MessageViewT, MessageView(update_type=UpdateType.CHANNEL_POST)
+            MessageView,
+            message.MessageView(update_type=UpdateType.CHANNEL_POST),
         ),
     )
-    edited_message: MessageViewT = dataclasses.field(
+    edited_message: MessageView = dataclasses.field(
         default_factory=lambda: typing.cast(
-            MessageViewT, MessageView(update_type=UpdateType.EDITED_MESSAGE)
+            MessageView,
+            message.MessageView(update_type=UpdateType.EDITED_MESSAGE),
         ),
     )
-    edited_business_message: MessageViewT = dataclasses.field(
+    edited_business_message: MessageView = dataclasses.field(
         default_factory=lambda: typing.cast(
-            MessageViewT,
-            MessageView(update_type=UpdateType.EDITED_BUSINESS_MESSAGE),
+            MessageView,
+            message.MessageView(update_type=UpdateType.EDITED_BUSINESS_MESSAGE),
         ),
     )
-    edited_channel_post: MessageViewT = dataclasses.field(
+    edited_channel_post: MessageView = dataclasses.field(
         default_factory=lambda: typing.cast(
-            MessageViewT, MessageView(update_type=UpdateType.EDITED_CHANNEL_POST)
+            MessageView,
+            message.MessageView(update_type=UpdateType.EDITED_CHANNEL_POST),
         ),
     )
-    any_message: MessageViewT = dataclasses.field(
-        default_factory=lambda: typing.cast(MessageViewT, MessageView()),
+    any_message: MessageView = dataclasses.field(
+        default_factory=lambda: typing.cast(MessageView, message.MessageView()),
     )
-    chat_member_updated: ChatMemberViewT = dataclasses.field(
-        default_factory=lambda: typing.cast(ChatMemberViewT, ChatMemberView()),
+    chat_member_updated: ChatMemberView = dataclasses.field(
+        default_factory=lambda: typing.cast(ChatMemberView, chat_member.ChatMemberView()),
     )
-    raw_event: RawEventViewT = dataclasses.field(
-        default_factory=lambda: typing.cast(RawEventViewT, RawEventView()),
+    raw_event: RawEventView = dataclasses.field(
+        default_factory=lambda: typing.cast(RawEventView, raw.RawEventView()),
     )
 
     def get_views(self) -> dict[str, ABCView]:

telegrinder/bot/dispatch/view/message.py

@@ -30,11 +30,7 @@ class MessageView(BaseStateView[MessageCute]):
     async def check(self, event: Update) -> bool:
         if not await super().check(event):
             return False
-        return (
-            True
-            if self.update_type is None
-            else self.update_type == event.update_type.unwrap_or_none()
-        )
+        return True if self.update_type is None else self.update_type == event.update_type
 
 
 __all__ = ("MessageView",)

telegrinder/bot/dispatch/view/raw.py

@@ -29,7 +29,7 @@ class RawEventView(BaseView[UpdateCute]):
     def __call__(
         self,
         update_type: UpdateType,
-        *rules: ABCRule[UpdateCute],
+        *rules: ABCRule,
     ) -> typing.Callable[
         [FuncType[UpdateCute]],
         FuncHandler[UpdateCute, FuncType[UpdateCute], ErrorHandler[UpdateCute]],
@@ -39,7 +39,7 @@ class RawEventView(BaseView[UpdateCute]):
     def __call__(
         self,
         update_type: UpdateType,
-        *rules: ABCRule[UpdateCute],
+        *rules: ABCRule,
         dataclass: type[T],
     ) -> typing.Callable[[FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandler[T]]]: ...
 
@@ -47,7 +47,7 @@ class RawEventView(BaseView[UpdateCute]):
     def __call__(
         self,
         update_type: UpdateType,
-        *rules: ABCRule[UpdateCute],
+        *rules: ABCRule,
         error_handler: ErrorHandlerT,
     ) -> typing.Callable[
         [FuncType[UpdateCute]],
@@ -58,7 +58,7 @@ class RawEventView(BaseView[UpdateCute]):
     def __call__(
         self,
         update_type: UpdateType,
-        *rules: ABCRule[UpdateCute],
+        *rules: ABCRule,
         dataclass: type[T],
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
@@ -68,7 +68,7 @@ class RawEventView(BaseView[UpdateCute]):
     def __call__(
         self,
         update_type: UpdateType,
-        *rules: ABCRule[UpdateCute],
+        *rules: ABCRule,
         dataclass: typing.Literal[None] = None,
         error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
@@ -80,7 +80,7 @@ class RawEventView(BaseView[UpdateCute]):
     def __call__(  # type: ignore
         self,
         update_type: UpdateType,
-        *rules: ABCRule[typing.Any],
+        *rules: ABCRule,
         dataclass: type[typing.Any] | None = None,
         error_handler: ABCErrorHandler | None = None,
         is_blocking: bool = True,

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -1,4 +1,4 @@
-from .machine import WaiterMachine
+from .machine import WaiterMachine, clear_wm_storage_worker
 from .middleware import WaiterMiddleware
 from .short_state import ShortState
 
@@ -6,4 +6,5 @@ __all__ = (
     "ShortState",
     "WaiterMachine",
     "WaiterMiddleware",
+    "clear_wm_storage_worker",
 )

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -4,36 +4,46 @@ import typing
 
 from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.view.abc import ABCStateView, BaseStateView
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.tools.limited_dict import LimitedDict
 from telegrinder.types import Update
 
 from .middleware import WaiterMiddleware
-from .short_state import Behaviour, EventModel, ShortState
+from .short_state import Behaviour, EventModel, ShortState, ShortStateContext
 
 if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch.view.abc import ABCStateView, BaseStateView
+    from telegrinder.bot.dispatch import Dispatch
 
 T = typing.TypeVar("T")
 
 Identificator: typing.TypeAlias = str | int
 Storage: typing.TypeAlias = dict[str, LimitedDict[Identificator, ShortState[EventModel]]]
 
+WEEK: typing.Final[datetime.timedelta] = datetime.timedelta(days=7)
+
 
 class WaiterMachine:
-    def __init__(self) -> None:
+    def __init__(self, *, max_storage_size: int = 1000) -> None:
+        self.max_storage_size = max_storage_size
         self.storage: Storage = {}
 
     def __repr__(self) -> str:
-        return "<{}: storage={!r}>".format(
+        return "<{}: max_storage_size={}, {}>".format(
             self.__class__.__name__,
-            self.storage,
+            self.max_storage_size,
+            ", ".join(
+                f"{view_name}: {len(self.storage[view_name].values())} shortstates"
+                for view_name in self.storage
+            )
+            or "empty",
         )
 
     async def drop(
         self,
         state_view: "ABCStateView[EventModel]",
         id: Identificator,
+        event: EventModel,
         update: Update,
         **context: typing.Any,
     ) -> None:
@@ -43,16 +53,12 @@ class WaiterMachine:
 
         short_state = self.storage[view_name].pop(id, None)
         if short_state is None:
-            raise LookupError(
-                "Waiter with identificator {} is not found for view {!r}".format(
-                    id, view_name
-                )
-            )
+            raise LookupError("Waiter with identificator {} is not found for view {!r}".format(id, view_name))
 
         short_state.cancel()
         await self.call_behaviour(
             state_view,
-            short_state.event,
+            event,
             update,
             behaviour=short_state.on_drop_behaviour,
             **context,
@@ -62,27 +68,24 @@ class WaiterMachine:
         self,
         state_view: "BaseStateView[EventModel]",
         linked: EventModel | tuple[ABCAPI, Identificator],
-        *rules: ABCRule[EventModel],
+        *rules: ABCRule,
         default: Behaviour[EventModel] | None = None,
         on_drop: Behaviour[EventModel] | None = None,
+        exit: Behaviour[EventModel] | None = None,
         expiration: datetime.timedelta | float | None = None,
-    ) -> tuple[EventModel, Context]:
+    ) -> ShortStateContext[EventModel]:
         if isinstance(expiration, int | float):
             expiration = datetime.timedelta(seconds=expiration)
 
         api: ABCAPI
         key: Identificator
-        api, key = (
-            linked
-            if isinstance(linked, tuple)
-            else (linked.ctx_api, state_view.get_state_key(linked))
-        )  # type: ignore
+        api, key = linked if isinstance(linked, tuple) else (linked.ctx_api, state_view.get_state_key(linked))  # type: ignore
         if not key:
             raise RuntimeError("Unable to get state key.")
 
         view_name = state_view.__class__.__name__
         event = asyncio.Event()
-        short_state = ShortState(
+        short_state = ShortState[EventModel](
             key,
             api,
             event,
@@ -90,42 +93,81 @@ class WaiterMachine:
             expiration=expiration,
             default_behaviour=default,
             on_drop_behaviour=on_drop,
+            exit_behaviour=exit,
         )
-        
+
         if view_name not in self.storage:
             state_view.middlewares.insert(0, WaiterMiddleware(self, state_view))
-            self.storage[view_name] = LimitedDict()
+            self.storage[view_name] = LimitedDict(maxlimit=self.max_storage_size)
 
         if (deleted_short_state := self.storage[view_name].set(key, short_state)) is not None:
             deleted_short_state.cancel()
-        
+
         await event.wait()
         self.storage[view_name].pop(key, None)
-        return getattr(event, "context")
+        assert short_state.context is not None
+        return short_state.context
 
     async def call_behaviour(
         self,
         view: "ABCStateView[EventModel]",
-        event: asyncio.Event | EventModel,
+        event: EventModel,
         update: Update,
         behaviour: Behaviour[EventModel] | None = None,
         **context: typing.Any,
-    ) -> None:
-        # TODO: support param view as a behaviour
+    ) -> bool:
+        # TODO: support view as a behaviour
 
         if behaviour is None:
-            return
+            return False
 
         ctx = Context(**context)
-        if isinstance(event, asyncio.Event):
-            event, preset_ctx = typing.cast(
-                tuple[EventModel, Context],
-                getattr(event, "context"),
-            )
-            ctx.update(preset_ctx)
-
         if await behaviour.check(event.api, update, ctx):
             await behaviour.run(event, ctx)
-        
+            return True
+
+        return False
+
+    async def clear_storage(
+        self,
+        views: typing.Iterable[ABCStateView[EventModel]],
+        absolutely_dead_time: datetime.timedelta = WEEK,
+    ):
+        """Clears storage.
+
+        :param absolutely_dead_time: timedelta when state can be forgotten.
+        """
+
+        for view in views:
+            view_name = view.__class__.__name__
+            now = datetime.datetime.now()
+            for ident, short_state in self.storage.get(view_name, {}).copy().items():
+                if short_state.expiration_date is not None and now > short_state.expiration_date:
+                    assert short_state.context
+                    await self.drop(
+                        view,
+                        ident,
+                        event=short_state.context.event,
+                        update=short_state.context.context.raw_update,
+                        force=True,
+                    )
+                elif short_state.creation_date + absolutely_dead_time < now:
+                    short_state.cancel()
+                    del self.storage[view_name][short_state.key]
+
+
+async def clear_wm_storage_worker(
+    wm: WaiterMachine,
+    dp: "Dispatch",
+    interval_seconds: int = 60,
+    absolutely_dead_time: datetime.timedelta = WEEK,
+) -> typing.NoReturn:
+    while True:
+        await wm.clear_storage(
+            views=[view for view in dp.get_views().values() if isinstance(view, ABCStateView)],
+            absolutely_dead_time=absolutely_dead_time,
+        )
+        await asyncio.sleep(interval_seconds)
+
 
 __all__ = ("WaiterMachine",)