telegrinder 0.3.0.post1__py3-none-any.whl → 0.3.1__py3-none-any.whl

telegrinder/bot/dispatch/waiter_machine/hasher/message.py

@@ -1,7 +1,6 @@
 from telegrinder.bot.cute_types import MessageCute as Message
 from telegrinder.bot.dispatch.view import MessageView
-
-from .hasher import Hasher
+from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
 
 
 def from_chat_hash(chat_id: int) -> int:
@@ -12,9 +11,12 @@ def get_chat_from_event(event: Message) -> int:
     return event.chat.id
 
 
-MESSAGE_IN_CHAT = Hasher(
-    view=MessageView, get_hash_from_data=from_chat_hash, get_data_from_event=get_chat_from_event
-)
+def from_user_in_chat_hash(chat_and_user: tuple[int, int]) -> str:
+    return f"{chat_and_user[0]}_{chat_and_user[1]}"
+
+
+def get_user_in_chat_from_event(event: Message) -> tuple[int, int]:
+    return event.chat.id, event.from_user.id
 
 
 def from_user_hash(from_id: int) -> int:
@@ -25,23 +27,20 @@ def get_user_from_event(event: Message) -> int:
     return event.from_user.id
 
 
+MESSAGE_IN_CHAT = Hasher(
+    view_class=MessageView,
+    get_hash_from_data=from_chat_hash,
+    get_data_from_event=get_chat_from_event,
+)
+
 MESSAGE_FROM_USER = Hasher(
-    view=MessageView,
+    view_class=MessageView,
     get_hash_from_data=from_user_hash,
     get_data_from_event=get_user_from_event,
 )
 
-
-def from_user_in_chat_hash(chat_and_user: tuple[int, int]) -> str:
-    return f"{chat_and_user[0]}_{chat_and_user[1]}"
-
-
-def get_user_in_chat_from_event(event: Message) -> tuple[int, int]:
-    return event.chat.id, event.from_user.id
-
-
 MESSAGE_FROM_USER_IN_CHAT = Hasher(
-    view=MessageView,
+    view_class=MessageView,
     get_hash_from_data=from_user_in_chat_hash,
     get_data_from_event=get_user_in_chat_from_event,
 )

telegrinder/bot/dispatch/waiter_machine/hasher/state.py

@@ -1,16 +1,16 @@
-from fntypes import Option
+from fntypes.option import Option
 
 from telegrinder.bot.dispatch.view import BaseStateView
+from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import ECHO, Event, Hasher
 from telegrinder.tools.functional import from_optional
 
-from .hasher import ECHO, Event, Hasher
-
 
 class StateViewHasher(Hasher[Event, int]):
-    view: BaseStateView
+    view: BaseStateView[Event]
 
-    def __init__(self, view: type[BaseStateView[Event]]):
-        super().__init__(view, get_hash_from_data=ECHO)
+    def __init__(self, view: BaseStateView[Event]) -> None:
+        self.view = view
+        super().__init__(view.__class__, get_hash_from_data=ECHO)
 
     def get_data_from_event(self, event: Event) -> Option[int]:
         return from_optional(self.view.get_state_key(event))

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -41,16 +41,25 @@ class WaiterMachine:
         self.storage: Storage = {}
 
     def __repr__(self) -> str:
-        return "<{}: max_storage_size={}, {}>".format(
+        return "<{}: max_storage_size={}, base_state_lifetime={!r}>".format(
             self.__class__.__name__,
             self.max_storage_size,
-            ", ".join(
-                f"{view_name}: {len(self.storage[view_name].values())} shortstates"
-                for view_name in self.storage
-            )
-            or "empty",
+            self.base_state_lifetime,
         )
 
+    async def drop_all(self) -> None:
+        """Drops all waiters in storage."""
+
+        for hasher in self.storage:
+            for ident, short_state in self.storage[hasher].items():
+                if short_state.context:
+                    await self.drop(
+                        hasher,
+                        ident,
+                    )
+                else:
+                    short_state.cancel()
+
     async def drop(
         self,
         hasher: Hasher[EventModel, HasherData],
@@ -66,7 +75,7 @@ class WaiterMachine:
         short_state = self.storage[hasher].pop(waiter_id, None)
         if short_state is None:
             raise LookupError(
-                "Waiter with identificator {} is not found for hasher {!r}".format(waiter_id, hasher)
+                "Waiter with identificator {} is not found for hasher {!r}.".format(waiter_id, hasher)
             )
 
         if on_drop := short_state.actions.get("on_drop"):
@@ -74,19 +83,6 @@ class WaiterMachine:
 
         short_state.cancel()
 
-    async def drop_all(self) -> None:
-        """Drops all waiters in storage."""
-
-        for hasher in self.storage:
-            for ident, short_state in self.storage[hasher].items():
-                if short_state.context:
-                    await self.drop(
-                        hasher,
-                        ident,
-                    )
-                else:
-                    short_state.cancel()
-
     async def wait_from_event(
         self,
         view: BaseStateView[EventModel],
@@ -97,11 +93,11 @@ class WaiterMachine:
         lifetime: datetime.timedelta | float | None = None,
         **actions: typing.Unpack[WaiterActions[EventModel]],
     ) -> ShortStateContext[EventModel]:
-        hasher = StateViewHasher(view.__class__)
+        hasher = StateViewHasher(view)
         return await self.wait(
             hasher=hasher,
             data=hasher.get_data_from_event(event).expect(
-                RuntimeError("Hasher couldn't create data from event.")
+                RuntimeError("Hasher couldn't create data from event."),
             ),
             filter=filter,
             release=release,
@@ -124,18 +120,18 @@ class WaiterMachine:
 
         event = asyncio.Event()
         short_state = ShortState[EventModel](
-            filter=filter,
+            event,
+            actions,
             release=release,
-            event=event,
+            filter=filter,
             lifetime=lifetime or self.base_state_lifetime,
-            actions=actions,
         )
         waiter_hash = hasher.get_hash_from_data(data).expect(RuntimeError("Hasher couldn't create hash."))
 
         if hasher not in self.storage:
             if self.dispatch:
-                view: BaseView[EventModel] = self.dispatch.get_view(hasher.view).expect(
-                    RuntimeError(f"View {hasher.view.__name__} is not defined in dispatch")
+                view: BaseView[EventModel] = self.dispatch.get_view(hasher.view_class).expect(
+                    RuntimeError(f"View {hasher.view_class.__name__!r} is not defined in dispatch.")
                 )
                 view.middlewares.insert(0, WaiterMiddleware(self, hasher))
             self.storage[hasher] = LimitedDict(maxlimit=self.max_storage_size)
@@ -148,9 +144,7 @@ class WaiterMachine:
         assert short_state.context is not None
         return short_state.context
 
-    async def clear_storage(
-        self,
-    ) -> None:
+    async def clear_storage(self) -> None:
         """Clears storage."""
 
         for hasher in self.storage:

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -27,10 +27,17 @@ class ShortStateContext(typing.Generic[EventModel], typing.NamedTuple):
 @dataclasses.dataclass(slots=True)
 class ShortState(typing.Generic[EventModel]):
     event: asyncio.Event
-    actions: "WaiterActions"
+    actions: "WaiterActions[EventModel]"
+
+    release: ABCRule | None = dataclasses.field(
+        default=None,
+        kw_only=True,
+    )
+    filter: ABCRule | None = dataclasses.field(
+        default=None,
+        kw_only=True,
+    )
 
-    release: ABCRule | None = None
-    filter: ABCRule | None = None
     lifetime: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(
         default=None,
         kw_only=True,
@@ -38,7 +45,6 @@ class ShortState(typing.Generic[EventModel]):
 
     expiration_date: datetime.datetime | None = dataclasses.field(init=False, kw_only=True)
     creation_date: datetime.datetime = dataclasses.field(init=False)
-
     context: ShortStateContext[EventModel] | None = dataclasses.field(default=None, init=False, kw_only=True)
 
     def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:

telegrinder/bot/rules/abc.py

@@ -10,7 +10,7 @@ from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.bot.rules.adapter import ABCAdapter, RawUpdateAdapter
 from telegrinder.bot.rules.adapter.node import Event
 from telegrinder.node.base import Node, get_nodes, is_node
-from telegrinder.tools.i18n.base import ABCTranslator
+from telegrinder.tools.i18n.abc import ABCTranslator
 from telegrinder.tools.magic import (
     cache_translation,
     get_annotations,
@@ -22,8 +22,9 @@ from telegrinder.types.objects import Update as UpdateObject
 if typing.TYPE_CHECKING:
     from telegrinder.node.composer import NodeCollection
 
-AdaptTo = typing.TypeVar("AdaptTo", default=typing.Any)
+AdaptTo = typing.TypeVar("AdaptTo", default=typing.Any, contravariant=True)
 
+CheckResult: typing.TypeAlias = bool | typing.Coroutine[typing.Any, typing.Any, bool]
 Message: typing.TypeAlias = MessageCute
 Update: typing.TypeAlias = UpdateCute
 
@@ -45,12 +46,42 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
     adapter: ABCAdapter[UpdateObject, AdaptTo]
     requires: list["ABCRule"] = []
 
-    if not typing.TYPE_CHECKING:
+    if typing.TYPE_CHECKING:
+
+        @typing.overload
+        def check(self) -> CheckResult: ...
+
+        @typing.overload
+        def check(self, event: AdaptTo, /) -> CheckResult: ...
+
+        @typing.overload
+        def check(self, event: AdaptTo, ctx: Context, /) -> CheckResult: ...
+
+        @typing.overload
+        def check(
+            self,
+            event: AdaptTo,
+            ctx: Context,
+            /,
+            *args: typing.Any,
+            **kwargs: typing.Any,
+        ) -> CheckResult: ...
+
+        @typing.overload
+        def check(self, event: AdaptTo, /, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+
+        @typing.overload
+        def check(self, ctx: Context, /, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+
+        @abstractmethod
+        def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult:
+            pass
+    else:
         adapter = RawUpdateAdapter()
 
-    @abstractmethod
-    async def check(self, event: AdaptTo, *, ctx: Context) -> bool:
-        pass
+        @abstractmethod
+        def check(self, *args, **kwargs):
+            pass
 
     def __init_subclass__(cls, requires: list["ABCRule"] | None = None) -> None:
         """Merges requirements from inherited classes and rule-specific requirements."""
@@ -141,7 +172,10 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
                     "because it cannot be resolved."
                 )
 
-        return await bound_check_rule(**kw)
+        result = bound_check_rule(**kw)  # type: ignore
+        if inspect.isawaitable(result):
+            result = await result
+        return result
 
     async def translate(self, translator: ABCTranslator) -> typing.Self:
         return self
@@ -199,5 +233,6 @@ __all__ = (
     "Never",
     "NotRule",
     "OrRule",
+    "CheckResult",
     "with_caching_translations",
 )

telegrinder/bot/rules/adapter/raw_update.py

@@ -22,9 +22,7 @@ class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
     ) -> Result[UpdateCute, AdapterError]:
         if self.ADAPTED_VALUE_KEY not in context:
             context[self.ADAPTED_VALUE_KEY] = (
-                UpdateCute.from_update(update, api)
-                if not isinstance(update, UpdateCute)
-                else update
+                UpdateCute.from_update(update, api) if not isinstance(update, UpdateCute) else update
             )
         return Ok(context[self.ADAPTED_VALUE_KEY])
 

telegrinder/bot/rules/callback_data.py

@@ -12,7 +12,7 @@ from telegrinder.model import decoder
 from telegrinder.tools.buttons import DataclassInstance
 from telegrinder.types.enums import UpdateType
 
-from .abc import ABCRule
+from .abc import ABCRule, CheckResult
 from .markup import Markup, PatternLike, check_string
 
 CallbackQuery: typing.TypeAlias = CallbackQueryCute
@@ -26,12 +26,12 @@ class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
     adapter: EventAdapter[CallbackQuery] = EventAdapter(UpdateType.CALLBACK_QUERY, CallbackQuery)
 
     @abc.abstractmethod
-    async def check(self, event: CallbackQuery, context: Context) -> bool:
+    def check(self, event: CallbackQuery, context: Context) -> CheckResult:
         pass
 
 
 class HasData(CallbackQueryRule):
-    async def check(self, event: CallbackQuery) -> bool:
+    def check(self, event: CallbackQuery) -> bool:
         return bool(event.data.unwrap_or_none())
 
 
@@ -122,7 +122,7 @@ class CallbackDataEq(CallbackQueryDataRule):
     def __init__(self, value: str, /) -> None:
         self.value = value
 
-    async def check(self, event: CallbackQuery) -> bool:
+    def check(self, event: CallbackQuery) -> bool:
         return event.data.unwrap() == self.value
 
 
@@ -130,7 +130,7 @@ class CallbackDataJsonEq(CallbackQueryDataRule):
     def __init__(self, d: dict[str, typing.Any], /) -> None:
         self.d = d
 
-    async def check(self, event: CallbackQuery) -> bool:
+    def check(self, event: CallbackQuery) -> bool:
         return event.decode_callback_data().unwrap_or_none() == self.d
 
 
@@ -144,7 +144,7 @@ class CallbackDataJsonModel(CallbackQueryDataRule):
         self.model = model
         self.alias = alias or "data"
 
-    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+    def check(self, event: CallbackQuery, ctx: Context) -> bool:
         with suppress(BaseException):
             ctx.set(self.alias, decoder.decode(event.data.unwrap().encode(), type=self.model))
             return True
@@ -155,7 +155,7 @@ class CallbackDataMarkup(CallbackQueryDataRule):
     def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
         self.patterns = Markup(patterns).patterns
 
-    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+    def check(self, event: CallbackQuery, ctx: Context) -> bool:
         return check_string(self.patterns, event.data.unwrap(), ctx)
 
 

telegrinder/bot/rules/chat_join.py

@@ -6,7 +6,7 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter import EventAdapter
 from telegrinder.types.enums import UpdateType
 
-from .abc import ABCRule
+from .abc import ABCRule, CheckResult
 
 ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
 
@@ -15,12 +15,12 @@ class ChatJoinRequestRule(ABCRule[ChatJoinRequest], requires=[]):
     adapter: EventAdapter[ChatJoinRequest] = EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest)
 
     @abc.abstractmethod
-    async def check(self, event: ChatJoinRequest, context: Context) -> bool:
+    def check(self, event: ChatJoinRequest, context: Context) -> CheckResult:
         pass
 
 
 class HasInviteLink(ChatJoinRequestRule):
-    async def check(self, event: ChatJoinRequest) -> bool:
+    def check(self, event: ChatJoinRequest) -> bool:
         return bool(event.invite_link)
 
 
@@ -28,7 +28,7 @@ class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
     def __init__(self, name: str, /) -> None:
         self.name = name
 
-    async def check(self, event: ChatJoinRequest) -> bool:
+    def check(self, event: ChatJoinRequest) -> bool:
         return event.invite_link.unwrap().name.unwrap_or_none() == self.name
 
 
@@ -36,7 +36,7 @@ class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
     def __init__(self, creator_id: int, /) -> None:
         self.creator_id = creator_id
 
-    async def check(self, event: ChatJoinRequest) -> bool:
+    def check(self, event: ChatJoinRequest) -> bool:
         return event.invite_link.unwrap().creator.id == self.creator_id
 
 

telegrinder/bot/rules/command.py

@@ -97,7 +97,7 @@ class Command(ABCRule):
 
         return None
 
-    async def check(self, command: CommandInfo, me: Me, src: Source, ctx: Context) -> bool:
+    def check(self, command: CommandInfo, me: Me, src: Source, ctx: Context) -> bool:
         name = self.remove_prefix(command.name)
         if name is None:
             return False

telegrinder/bot/rules/enum_text.py

@@ -25,9 +25,12 @@ class EnumTextRule(ABCRule, typing.Generic[T]):
                 return enumeration
         raise KeyError("Enumeration is undefined.")
 
-    async def check(self, text: Text, ctx: Context) -> bool:
+    def check(self, text: Text, ctx: Context) -> bool:
         text = text.lower()  # type: ignore
         if text not in self.texts:
             return False
         ctx.enum_text = self.find(text)
         return True
+
+
+__all__ = ("EnumTextRule",)

telegrinder/bot/rules/fuzzy.py

@@ -13,7 +13,7 @@ class FuzzyText(ABCRule):
         self.texts = texts
         self.min_ratio = min_ratio
 
-    async def check(self, message_text: Text, ctx: Context) -> bool:
+    def check(self, message_text: Text, ctx: Context) -> bool:
         match = max(difflib.SequenceMatcher(a=message_text, b=text).ratio() for text in self.texts)
         if match < self.min_ratio:
             return False

telegrinder/bot/rules/inline.py

@@ -3,7 +3,7 @@ import typing
 
 from telegrinder.bot.cute_types import InlineQueryCute
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.abc import ABCRule, CheckResult
 from telegrinder.bot.rules.adapter import EventAdapter
 from telegrinder.types.enums import ChatType, UpdateType
 
@@ -16,12 +16,11 @@ class InlineQueryRule(ABCRule[InlineQuery], abc.ABC):
     adapter: EventAdapter[InlineQuery] = EventAdapter(UpdateType.INLINE_QUERY, InlineQuery)
 
     @abc.abstractmethod
-    async def check(self, query: InlineQuery, ctx: Context) -> bool:
-        ...
+    def check(self, query: InlineQuery, ctx: Context) -> CheckResult: ...
 
 
 class HasLocation(InlineQueryRule):
-    async def check(self, query: InlineQuery) -> bool:
+    def check(self, query: InlineQuery) -> bool:
         return bool(query.location)
 
 
@@ -29,7 +28,7 @@ class InlineQueryChatType(InlineQueryRule):
     def __init__(self, chat_type: ChatType, /) -> None:
         self.chat_type = chat_type
 
-    async def check(self, query: InlineQuery) -> bool:
+    def check(self, query: InlineQuery) -> bool:
         return query.chat_type.map(lambda x: x == self.chat_type).unwrap_or(False)
 
 
@@ -40,7 +39,7 @@ class InlineQueryText(InlineQueryRule):
         ]
         self.lower_case = lower_case
 
-    async def check(self, query: InlineQuery) -> bool:
+    def check(self, query: InlineQuery) -> bool:
         return (query.query.lower() if self.lower_case else query.query) in self.texts
 
 
@@ -48,7 +47,7 @@ class InlineQueryMarkup(InlineQueryRule):
     def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
         self.patterns = Markup(patterns).patterns
 
-    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+    def check(self, query: InlineQuery, ctx: Context) -> bool:
         return check_string(self.patterns, query.query, ctx)
 
 

telegrinder/bot/rules/integer.py

@@ -13,7 +13,7 @@ class IntegerInRange(ABCRule):
     def __init__(self, rng: range) -> None:
         self.rng = rng
 
-    async def check(self, integer: TextInteger) -> bool:
+    def check(self, integer: TextInteger) -> bool:
         return integer in self.rng
 
 

telegrinder/bot/rules/is_from.py

@@ -8,17 +8,17 @@ from .message import MessageRule
 
 
 class IsBot(ABCRule):
-    async def check(self, user: UserSource) -> bool:
+    def check(self, user: UserSource) -> bool:
         return user.is_bot
 
 
 class IsUser(ABCRule):
-    async def check(self, user: UserSource) -> bool:
+    def check(self, user: UserSource) -> bool:
         return not user.is_bot
 
 
 class IsPremium(ABCRule):
-    async def check(self, user: UserSource) -> bool:
+    def check(self, user: UserSource) -> bool:
         return user.is_premium.unwrap_or(False)
 
 
@@ -26,7 +26,7 @@ class IsLanguageCode(ABCRule):
     def __init__(self, lang_codes: str | list[str], /) -> None:
         self.lang_codes = [lang_codes] if isinstance(lang_codes, str) else lang_codes
 
-    async def check(self, user: UserSource) -> bool:
+    def check(self, user: UserSource) -> bool:
         return user.language_code.unwrap_or_none() in self.lang_codes
 
 
@@ -34,12 +34,12 @@ class IsUserId(ABCRule):
     def __init__(self, user_ids: int | list[int], /) -> None:
         self.user_ids = [user_ids] if isinstance(user_ids, int) else user_ids
 
-    async def check(self, user: UserSource) -> bool:
+    def check(self, user: UserSource) -> bool:
         return user.id in self.user_ids
 
 
 class IsForum(ABCRule):
-    async def check(self, chat: ChatSource) -> bool:
+    def check(self, chat: ChatSource) -> bool:
         return chat.is_forum.unwrap_or(False)
 
 
@@ -47,32 +47,32 @@ class IsChatId(ABCRule):
     def __init__(self, chat_ids: int | list[int], /) -> None:
         self.chat_ids = [chat_ids] if isinstance(chat_ids, int) else chat_ids
 
-    async def check(self, chat: ChatSource) -> bool:
+    def check(self, chat: ChatSource) -> bool:
         return chat.id in self.chat_ids
 
 
 class IsPrivate(ABCRule):
-    async def check(self, chat: ChatSource) -> bool:
+    def check(self, chat: ChatSource) -> bool:
         return chat.type == ChatType.PRIVATE
 
 
 class IsGroup(ABCRule):
-    async def check(self, chat: ChatSource) -> bool:
+    def check(self, chat: ChatSource) -> bool:
         return chat.type == ChatType.GROUP
 
 
 class IsSuperGroup(ABCRule):
-    async def check(self, chat: ChatSource) -> bool:
+    def check(self, chat: ChatSource) -> bool:
         return chat.type == ChatType.SUPERGROUP
 
 
 class IsChat(ABCRule):
-    async def check(self, chat: ChatSource) -> bool:
+    def check(self, chat: ChatSource) -> bool:
         return chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
 
 
 class IsDice(MessageRule):
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         return bool(message.dice)
 
 
@@ -80,12 +80,12 @@ class IsDiceEmoji(MessageRule, requires=[IsDice()]):
     def __init__(self, dice_emoji: DiceEmoji, /) -> None:
         self.dice_emoji = dice_emoji
 
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         return message.dice.unwrap().emoji == self.dice_emoji
 
 
 class IsForward(MessageRule):
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         return bool(message.forward_origin)
 
 
@@ -93,32 +93,32 @@ class IsForwardType(MessageRule, requires=[IsForward()]):
     def __init__(self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /) -> None:
         self.fwd_type = fwd_type
 
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         return message.forward_origin.unwrap().v.type == self.fwd_type
 
 
 class IsReply(MessageRule):
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         return bool(message.reply_to_message)
 
 
 class IsSticker(MessageRule):
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         return bool(message.sticker)
 
 
 class IsVideoNote(MessageRule):
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         return bool(message.video_note)
 
 
 class IsDocument(MessageRule):
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         return bool(message.document)
 
 
 class IsPhoto(MessageRule):
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         return bool(message.photo)
 
 

telegrinder/bot/rules/markup.py

@@ -24,16 +24,19 @@ def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
 
 
 class Markup(ABCRule):
-    """Markup Language. See [VBML docs](https://github.com/tesseradecade/vbml/blob/master/docs/index.md)"""
+    """Markup Language. See the [vbml documentation](https://github.com/tesseradecade/vbml/blob/master/docs/index.md)."""
 
     def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
         if not isinstance(patterns, list):
             patterns = [patterns]
         self.patterns = [
-            vbml.Pattern(pattern) if isinstance(pattern, str) else pattern for pattern in patterns
+            vbml.Pattern(pattern, flags=global_ctx.vbml_pattern_flags)
+            if isinstance(pattern, str)
+            else pattern
+            for pattern in patterns
         ]
 
-    async def check(self, text: Text, ctx: Context) -> bool:
+    def check(self, text: Text, ctx: Context) -> bool:
         return check_string(self.patterns, text, ctx)