telegrinder 0.1.dev166__py3-none-any.whl → 0.1.dev167__py3-none-any.whl

telegrinder/__init__.py

@@ -69,7 +69,6 @@ from .bot import (
     Polling,
     RawEventView,
     ShortState,
-    ShortStateStorage,
     SingleChoice,
     Telegrinder,
     UpdateCute,
@@ -189,7 +188,6 @@ __all__ = (
     "RawEventView",
     "RowButtons",
     "ShortState",
-    "ShortStateStorage",
     "SimpleI18n",
     "SimpleTranslator",
     "SingleChoice",

telegrinder/bot/__init__.py

@@ -33,7 +33,6 @@ from .dispatch import (
     MessageView,
     RawEventView,
     ShortState,
-    ShortStateStorage,
     ViewBox,
     WaiterMachine,
     register_manager,
@@ -80,7 +79,6 @@ __all__ = (
     "Polling",
     "RawEventView",
     "ShortState",
-    "ShortStateStorage",
     "SingleChoice",
     "Telegrinder",
     "UpdateCute",

telegrinder/bot/bot.py

@@ -57,9 +57,7 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
 
     def run_forever(self, *, offset: int = 0, skip_updates: bool = False) -> None:
         logger.debug("Running blocking polling (id={})", self.api.id)
-        self.loop_wrapper.add_task(
-            self.run_polling(offset=offset, skip_updates=skip_updates)
-        )
+        self.loop_wrapper.add_task(self.run_polling(offset=offset, skip_updates=skip_updates))
         self.loop_wrapper.run_event_loop()
 
 

telegrinder/bot/cute_types/base.py

@@ -74,9 +74,7 @@ def compose_method_params(
         if param_name not in params:
             if param_name in validators and not validators[param_name](update):
                 continue
-            params[param_name] = getattr(
-                update, param if isinstance(param, str) else param[1]
-            )
+            params[param_name] = getattr(update, param if isinstance(param, str) else param[1])
 
     return params
 
@@ -105,21 +103,14 @@ def shortcut(
             index = 0
 
             for k, p in signature_params.items():
-                if (
-                    p.kind in (p.POSITIONAL_OR_KEYWORD, p.POSITIONAL_ONLY)
-                    and len(args) > index
-                ):
+                if p.kind in (p.POSITIONAL_OR_KEYWORD, p.POSITIONAL_ONLY) and len(args) > index:
                     params[k] = args[index]
                     index += 1
                     continue
                 if p.kind in (p.VAR_KEYWORD, p.VAR_POSITIONAL):
                     params[k] = kwargs.copy() if p.kind is p.VAR_KEYWORD else args[index:]
                     continue
-                params[k] = (
-                    kwargs.pop(k, p.default)
-                    if p.default is not p.empty
-                    else kwargs.pop(k)
-                )
+                params[k] = kwargs.pop(k, p.default) if p.default is not p.empty else kwargs.pop(k)
 
             return await executor(self, method_name, get_params(params))
 

telegrinder/bot/cute_types/callback_query.py

@@ -44,9 +44,7 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True, di
         by the bot with the callback button that originated the query."""
 
         return self.message.map(
-            lambda m: m.only()
-            .map(lambda m: m.is_topic_message.unwrap_or(False))
-            .unwrap_or(False)
+            lambda m: m.only().map(lambda m: m.is_topic_message.unwrap_or(False)).unwrap_or(False)
         )
 
     @property

telegrinder/bot/cute_types/chat_join_request.py

@@ -9,7 +9,9 @@ from .base import BaseCute, shortcut
 from .chat_member_updated import ChatMemberShortcuts, chat_member_interaction
 
 
-class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMemberShortcuts, kw_only=True):
+class ChatJoinRequestCute(
+    BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMemberShortcuts, kw_only=True
+):
     api: ABCAPI
 
     @property

telegrinder/bot/cute_types/chat_member_updated.py

@@ -232,7 +232,9 @@ class ChatMemberShortcuts:
         ...
 
 
-class ChatMemberUpdatedCute(BaseCute[ChatMemberUpdated], ChatMemberUpdated, ChatMemberShortcuts, kw_only=True):
+class ChatMemberUpdatedCute(
+    BaseCute[ChatMemberUpdated], ChatMemberUpdated, ChatMemberShortcuts, kw_only=True
+):
     api: ABCAPI
 
     @property

telegrinder/bot/cute_types/message.py

@@ -71,16 +71,12 @@ async def execute_method_answer(
     link_preview_options = params.get("link_preview_options")
 
     if reply_parameters is not None and isinstance(reply_parameters, dict):
-        reply_parameters.setdefault(
-            "message_id", params.get("message_id", message.message_id)
-        )
+        reply_parameters.setdefault("message_id", params.get("message_id", message.message_id))
         reply_parameters.setdefault("chat_id", params.get("chat_id"))
         params["reply_parameters"] = compose_reply_params(**reply_parameters)
 
     if link_preview_options is not None and isinstance(link_preview_options, dict):
-        params["link_preview_options"] = compose_link_preview_options(
-            **link_preview_options
-        )
+        params["link_preview_options"] = compose_link_preview_options(**link_preview_options)
 
     result = await getattr(message.ctx_api, method_name)(**params)
     return result.map(
@@ -124,8 +120,7 @@ async def execute_method_edit(
             "message_thread_id": lambda x: (
                 x.is_topic_message.unwrap_or(False)
                 if isinstance(x, MessageCute)
-                else bool(x.message)
-                and getattr(x.message.unwrap().v, "is_topic_message", False)
+                else bool(x.message) and getattr(x.message.unwrap().v, "is_topic_message", False)
             ),
         },
     )
@@ -330,9 +325,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
             params=get_params(locals()),
             update=self,
             default_params={"chat_id", "message_id", "message_thread_id"},
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         return await self.ctx_api.delete_message(**params)
 
@@ -450,9 +443,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
                 ("from_chat_id", "chat_id"),
                 "message_thread_id",
             },
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         if isinstance(reply_parameters, dict):
             reply_parameters.setdefault("message_id", params.get("message_id"))
@@ -467,11 +458,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     async def react(
         self,
         reaction: (
-            str
-            | ReactionEmoji
-            | ReactionType
-            | list[str | ReactionEmoji | ReactionType]
-            | None
+            str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType] | None
         ) = None,
         chat_id: int | str | None = None,
         message_thread_id: int | None = None,
@@ -507,9 +494,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
             params=get_params(locals()),
             update=self,
             default_params={"chat_id", "message_id", "message_thread_id"},
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         if reaction:
             params["reaction"] = compose_reactions(
@@ -557,9 +542,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
                 "message_id",
                 "message_thread_id",
             },
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         return (await self.ctx_api.forward_message(**params)).map(
             lambda message: MessageCute.from_update(message, bound_api=self.api),
@@ -599,9 +582,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
             params=get_params(locals()),
             update=self,
             default_params={"chat_id", "message_id", "message_thread_id"},
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         return await self.ctx_api.pin_chat_message(**params)
 
@@ -632,9 +613,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
             params=get_params(locals()),
             update=self,
             default_params={"chat_id", "message_id", "message_thread_id"},
-            validators={
-                "message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)
-            },
+            validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
         )
         return await self.ctx_api.pin_chat_message(**params)
 

telegrinder/bot/cute_types/utils.py

@@ -69,9 +69,7 @@ INPUT_MEDIA_TYPES: typing.Final[dict[str, type[InputMedia]]] = {
 
 
 def compose_reactions(
-    reactions: (
-        str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType]
-    ),
+    reactions: (str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType]),
     /,
 ) -> list[ReactionType]:
     if not isinstance(reactions, list):

telegrinder/bot/dispatch/__init__.py

@@ -27,7 +27,7 @@ from .view import (
     RawEventView,
     ViewBox,
 )
-from .waiter_machine import ShortState, ShortStateStorage, WaiterMachine
+from .waiter_machine import ShortState, WaiterMachine
 
 __all__ = (
     "ABCDispatch",
@@ -56,7 +56,6 @@ __all__ = (
     "MessageView",
     "RawEventView",
     "ShortState",
-    "ShortStateStorage",
     "TelegrinderCtx",
     "ViewBox",
     "WaiterMachine",

telegrinder/bot/dispatch/composition.py

@@ -78,9 +78,7 @@ class CompositionDispatch(ABCDispatch):
         def wrapper(func: typing.Callable):
             composition = Composition(func, is_blocking)
             if container_nodes:
-                composition.nodes["container"] = ContainerNode.link_nodes(
-                    list(container_nodes)
-                )
+                composition.nodes["container"] = ContainerNode.link_nodes(list(container_nodes))
             self.compositions.append(composition)
             return func
 

telegrinder/bot/dispatch/dispatch.py

@@ -160,9 +160,7 @@ class Dispatch(
     def load(self, external: typing.Self) -> None:
         view_external = external.get_views()
         for name, view in self.get_views().items():
-            assert (
-                name in view_external
-            ), f"View {name!r} is undefined in external dispatch."
+            assert name in view_external, f"View {name!r} is undefined in external dispatch."
             view.load(view_external[name])
             setattr(external, name, view)
 

telegrinder/bot/dispatch/handler/func.py

@@ -18,14 +18,10 @@ if typing.TYPE_CHECKING:
 
 F = typing.TypeVar(
     "F",
-    bound=typing.Callable[
-        typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]
-    ],
+    bound=typing.Callable[typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]],
 )
 EventT = typing.TypeVar("EventT", bound=BaseCute)
-ErrorHandlerT = typing.TypeVar(
-    "ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler
-)
+ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
 
 
 @dataclasses.dataclass(repr=False)
@@ -52,10 +48,7 @@ class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
         )
 
     async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
-        if (
-            self.update_type is not None
-            and self.update_type != event.update_type.unwrap_or_none()
-        ):
+        if self.update_type is not None and self.update_type != event.update_type.unwrap_or_none():
             return False
         ctx = ctx or Context()
         temp_ctx = ctx.copy()

telegrinder/bot/dispatch/return_manager/abc.py

@@ -66,9 +66,7 @@ class BaseReturnManager(ABCReturnManager[EventT]):
 
     async def run(self, response: typing.Any, event: EventT, ctx: Context) -> None:
         for manager in self.managers:
-            if typing.Any in manager.types or any(
-                type(response) is x for x in manager.types
-            ):
+            if typing.Any in manager.types or any(type(response) is x for x in manager.types):
                 await manager(response, event, ctx)
 
     @typing.overload
@@ -79,24 +77,22 @@ class BaseReturnManager(ABCReturnManager[EventT]):
     ]: ...
 
     @typing.overload
-    def register_manager(self, return_type: tuple[type[T], ...]) -> typing.Callable[
+    def register_manager(
+        self,
+        return_type: tuple[type[T], ...],
+    ) -> typing.Callable[
         [typing.Callable[[tuple[T, ...], EventT, Context], typing.Awaitable[typing.Any]]],
         Manager,
     ]: ...
 
     def register_manager(
-        self, return_type: type[T] | tuple[type[T], ...]
+        self,
+        return_type: type[T] | tuple[type[T], ...],
     ) -> typing.Callable[
-        [
-            typing.Callable[
-                [T | tuple[T, ...], EventT, Context], typing.Awaitable[typing.Any]
-            ]
-        ],
+        [typing.Callable[[T | tuple[T, ...], EventT, Context], typing.Awaitable[typing.Any]]],
         Manager,
     ]:
-        def wrapper(
-            func: typing.Callable[[T, EventT, Context], typing.Awaitable]
-        ) -> Manager:
+        def wrapper(func: typing.Callable[[T, EventT, Context], typing.Awaitable]) -> Manager:
             manager = Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
             setattr(self.__class__, func.__name__, manager)
             return manager

telegrinder/bot/dispatch/return_manager/message.py

@@ -16,23 +16,21 @@ class MessageReturnManager(BaseReturnManager[MessageCute]):
     @register_manager(list | tuple)
     @staticmethod
     async def seq_manager(
-        value: list[str] | tuple[str, ...], event: MessageCute, ctx: Context
+        value: list[str] | tuple[str, ...],
+        event: MessageCute,
+        ctx: Context,
     ) -> None:
         for message in value:
             await event.answer(message)
 
     @register_manager(dict)
     @staticmethod
-    async def dict_manager(
-        value: dict[str, typing.Any], event: MessageCute, ctx: Context
-    ) -> None:
+    async def dict_manager(value: dict[str, typing.Any], event: MessageCute, ctx: Context) -> None:
         await event.answer(**value)
 
     @register_manager(HTMLFormatter)
     @staticmethod
-    async def htmlformatter_manager(
-        value: HTMLFormatter, event: MessageCute, ctx: Context
-    ) -> None:
+    async def htmlformatter_manager(value: HTMLFormatter, event: MessageCute, ctx: Context) -> None:
         await event.answer(value, parse_mode=HTMLFormatter.PARSE_MODE)
 
 

telegrinder/bot/dispatch/view/abc.py

@@ -63,9 +63,7 @@ class BaseView(ABCView, typing.Generic[EventType]):
         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):
-                    if issubclass(
-                        typing.get_origin(generic_type) or generic_type, BaseCute
-                    ):
+                    if issubclass(typing.get_origin(generic_type) or generic_type, BaseCute):
                         return Some(generic_type)
         return Nothing()
 

telegrinder/bot/dispatch/view/box.py

@@ -12,16 +12,12 @@ from .inline_query import InlineQueryView
 from .message import MessageView
 from .raw import RawEventView
 
-CallbackQueryViewT = typing.TypeVar(
-    "CallbackQueryViewT", bound=ABCView, default=CallbackQueryView
-)
+CallbackQueryViewT = typing.TypeVar("CallbackQueryViewT", bound=ABCView, default=CallbackQueryView)
 ChatJoinRequestViewT = typing.TypeVar(
     "ChatJoinRequestViewT", bound=ABCView, default=ChatJoinRequestView
 )
 ChatMemberViewT = typing.TypeVar("ChatMemberViewT", bound=ABCView, default=ChatMemberView)
-InlineQueryViewT = typing.TypeVar(
-    "InlineQueryViewT", bound=ABCView, default=InlineQueryView
-)
+InlineQueryViewT = typing.TypeVar("InlineQueryViewT", bound=ABCView, default=InlineQueryView)
 MessageViewT = typing.TypeVar("MessageViewT", bound=ABCView, default=MessageView)
 RawEventViewT = typing.TypeVar("RawEventViewT", bound=ABCView, default=RawEventView)
 
@@ -100,11 +96,7 @@ class ViewBox(
     def get_views(self) -> dict[str, ABCView]:
         """Get all views."""
 
-        return {
-            name: view
-            for name, view in self.__dict__.items()
-            if isinstance(view, ABCView)
-        }
+        return {name: view for name, view in self.__dict__.items() if isinstance(view, ABCView)}
 
 
 __all__ = ("ViewBox",)

telegrinder/bot/dispatch/view/raw.py

@@ -41,9 +41,7 @@ class RawEventView(BaseView[UpdateCute]):
         update_type: UpdateType,
         *rules: ABCRule[UpdateCute],
         dataclass: type[T],
-    ) -> typing.Callable[
-        [FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandler[T]]
-    ]: ...
+    ) -> typing.Callable[[FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandler[T]]]: ...
 
     @typing.overload
     def __call__(
@@ -64,9 +62,7 @@ class RawEventView(BaseView[UpdateCute]):
         dataclass: type[T],
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
-    ) -> typing.Callable[
-        [FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandlerT]
-    ]: ...
+    ) -> typing.Callable[[FuncType[T]], FuncHandler[UpdateCute, FuncType[T], ErrorHandlerT]]: ...
 
     @typing.overload
     def __call__(

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -1,10 +1,9 @@
-from .machine import ShortStateStorage, WaiterMachine
+from .machine import WaiterMachine
 from .middleware import WaiterMiddleware
 from .short_state import ShortState
 
 __all__ = (
     "ShortState",
-    "ShortStateStorage",
     "WaiterMachine",
     "WaiterMiddleware",
 )

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -1,79 +1,23 @@
 import asyncio
 import datetime
 import typing
-from collections import deque
 
 from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.dispatch.context import Context
 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
 
-T = typing.TypeVar("T")
-
-Storage: typing.TypeAlias = dict[str, "ShortStateStorage"]
-Identificator: typing.TypeAlias = str | int
-
 if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.view.abc import ABCStateView, BaseStateView
 
+T = typing.TypeVar("T")
 
-class ShortStateStorage(dict[Identificator, ShortState[EventModel]]):
-    def __init__(self, *, maxlimit: int = 1000) -> None:
-        super().__init__()
-        self.maxlimit = maxlimit
-        self.queue: deque[Identificator] = deque(maxlen=maxlimit)
-    
-    def __repr__(self) -> str:
-        return "<{}: {}, (current={} | maxlimit={})>".format(
-            self.__class__.__name__,
-            super().__repr__(),
-            len(self.queue),
-            self.maxlimit,
-        )
-    
-    def __setitem__(self, key: Identificator, value: ShortState[EventModel], /) -> None:
-        self.add(key, value)
-    
-    def __delitem__(self, key: Identificator, /) -> None:
-        self.pop(key, None)
-
-    def add(self, id: Identificator, short_state: ShortState[EventModel]) -> None:
-        if len(self.queue) >= self.maxlimit:
-            self.pop(self.queue.popleft(), None)
-        if id not in self.queue:
-            self.queue.append(id)
-        super().__setitem__(id, short_state)
-
-    def clear(self) -> None:
-        self.queue.clear()
-        super().clear()
-    
-    def setdefault(self, id: Identificator, default: ShortState[EventModel]) -> ShortState[EventModel]:
-        if id in self:
-            return self[id]
-        self.add(id, default)
-        return default
-    
-    def pop(self, id: Identificator, default: T):  # type: ignore
-        if id in self.queue:
-            self.queue.remove(id)
-        return super().pop(id, default)
-    
-    def popitem(self) -> tuple[Identificator, ShortState[EventModel]]:
-        item = super().popitem()
-        self.queue.remove(item[0])
-        return item
-    
-    def update(
-        self,
-        mapping: typing.Mapping[Identificator, ShortState[EventModel]] | None = None,
-        /,
-        **kwargs: ShortState[EventModel],
-    ) -> None:
-        for key, value in (mapping if mapping is not None else kwargs).items():
-            self.add(key, value)
+Identificator: typing.TypeAlias = str | int
+Storage: typing.TypeAlias = dict[str, LimitedDict[Identificator, ShortState[EventModel]]]
 
 
 class WaiterMachine:
@@ -90,6 +34,7 @@ class WaiterMachine:
         self,
         state_view: "ABCStateView[EventModel]",
         id: Identificator,
+        update: Update,
         **context: typing.Any,
     ) -> None:
         view_name = state_view.__class__.__name__
@@ -100,8 +45,7 @@ class WaiterMachine:
         if short_state is None:
             raise LookupError(
                 "Waiter with identificator {} is not found for view {!r}".format(
-                    id,
-                    view_name,
+                    id, view_name
                 )
             )
 
@@ -114,8 +58,9 @@ class WaiterMachine:
 
         await self.call_behaviour(
             state_view,
-            short_state.on_drop_behaviour,
             short_state.event,
+            update,
+            behaviour=short_state.on_drop_behaviour,
             **context,
         )
 
@@ -126,14 +71,18 @@ class WaiterMachine:
         *rules: ABCRule[EventModel],
         default: Behaviour = None,
         on_drop: Behaviour = None,
-        expiration: datetime.timedelta | int | float | None = None,
-        short_state_storage: ShortStateStorage[EventModel] | None = None,
+        expiration: datetime.timedelta | int | None = None,
     ) -> tuple[EventModel, Context]:
         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: ABCAPI
+        key: Identificator
+        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.")
 
@@ -150,9 +99,9 @@ class WaiterMachine:
         view_name = state_view.__class__.__name__
         if view_name not in self.storage:
             state_view.middlewares.insert(0, WaiterMiddleware(self, state_view))
-            self.storage[view_name] = short_state_storage or ShortStateStorage()
+            self.storage[view_name] = LimitedDict()
 
-        self.storage[view_name].add(key, short_state)
+        self.storage[view_name][key] = short_state
         await event.wait()
 
         e, ctx = getattr(event, "context")
@@ -162,15 +111,27 @@ class WaiterMachine:
     async def call_behaviour(
         self,
         view: "ABCStateView[EventModel]",
-        behaviour: Behaviour,
         event: asyncio.Event | EventModel,
+        update: Update,
+        behaviour: Behaviour[EventModel] | None = None,
         **context: typing.Any,
     ) -> None:
+        # TODO: support param view as a behaviour
+
+        ctx = Context(**context)
+
+        if isinstance(event, asyncio.Event):
+            event, preset_ctx = typing.cast(
+                tuple[EventModel, Context],
+                getattr(event, "context"),
+            )
+            ctx.update(preset_ctx)
+
         if behaviour is None:
             return
-        # TODO: add behaviour check
-        # TODO: support view as a behaviour
-        await behaviour.run(event, context)  # type: ignore
 
+        if await behaviour.check(event.api, update, ctx):
+            await behaviour.run(event, ctx)
+        
 
 __all__ = ("WaiterMachine",)