telegrinder 0.3.0__py3-none-any.whl → 0.3.0.post2__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],
@@ -95,13 +91,13 @@ class WaiterMachine:
         filter: ABCRule | None = None,
         release: ABCRule | None = None,
         lifetime: datetime.timedelta | float | None = None,
-        **actions: typing.Unpack[WaiterActions],
+        **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,
@@ -117,25 +113,25 @@ class WaiterMachine:
         filter: ABCRule | None = None,
         release: ABCRule | None = None,
         lifetime: datetime.timedelta | float | None = None,
-        **actions: typing.Unpack[WaiterActions],
+        **actions: typing.Unpack[WaiterActions[EventModel]],
     ) -> ShortStateContext[EventModel]:
         if isinstance(lifetime, int | float):
             lifetime = datetime.timedelta(seconds=lifetime)
 
         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,7 +22,7 @@ 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)
 
 Message: typing.TypeAlias = MessageCute
 Update: typing.TypeAlias = UpdateCute
@@ -45,12 +45,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
+        async def check(self) -> bool: ...
+
+        @typing.overload
+        async def check(self, event: AdaptTo, /) -> bool: ...
+
+        @typing.overload
+        async def check(self, event: AdaptTo, ctx: Context, /) -> bool: ...
+
+        @typing.overload
+        async def check(
+            self,
+            event: AdaptTo,
+            ctx: Context,
+            /,
+            *args: typing.Any,
+            **kwargs: typing.Any,
+        ) -> bool: ...
+
+        @typing.overload
+        async def check(self, event: AdaptTo, /, *args: typing.Any, **kwargs: typing.Any) -> bool: ...
+
+        @typing.overload
+        async def check(self, ctx: Context, /, *args: typing.Any, **kwargs: typing.Any) -> bool: ...
+
+        @abstractmethod
+        async def check(self, *args: typing.Any, **kwargs: typing.Any) -> bool:
+            pass
+    else:
         adapter = RawUpdateAdapter()
 
-    @abstractmethod
-    async def check(self, event: AdaptTo, *, ctx: Context) -> bool:
-        pass
+        @abstractmethod
+        async 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 +171,7 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
                     "because it cannot be resolved."
                 )
 
-        return await bound_check_rule(**kw)
+        return await bound_check_rule(**kw)  # type: ignore
 
     async def translate(self, translator: ABCTranslator) -> typing.Self:
         return self

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/inline.py

@@ -16,8 +16,7 @@ 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:
-        ...
+    async def check(self, query: InlineQuery, ctx: Context) -> bool: ...
 
 
 class HasLocation(InlineQueryRule):

telegrinder/bot/rules/markup.py

@@ -24,13 +24,16 @@ 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:

telegrinder/bot/rules/start.py

@@ -12,7 +12,7 @@ from .message_entities import MessageEntities
 class StartCommand(
     MessageRule,
     requires=[
-        IsPrivate(), 
+        IsPrivate(),
         MessageEntities(MessageEntityType.BOT_COMMAND),
         Markup(["/start <param>", "/start"]),
     ],

telegrinder/bot/rules/text.py

@@ -1,5 +1,7 @@
+import typing
+
 from telegrinder import node
-from telegrinder.tools.i18n.base import ABCTranslator
+from telegrinder.tools.i18n.abc import ABCTranslator
 
 from .abc import ABCRule, with_caching_translations
 from .node import NodeRule
@@ -21,8 +23,8 @@ class Text(ABCRule):
         return (text if not self.ignore_case else text.lower()) in self.texts
 
     @with_caching_translations
-    async def translate(self, translator: ABCTranslator) -> "Text":
-        return Text(
+    async def translate(self, translator: ABCTranslator) -> typing.Self:
+        return self.__class__(
             texts=[translator.get(text) for text in self.texts],
             ignore_case=self.ignore_case,
         )

telegrinder/bot/scenario/checkbox.py

@@ -124,7 +124,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         ).unwrap()
 
         while True:
-            q, _ = await self.waiter_machine.wait(StateViewHasher(view.__class__), message.message_id)
+            q, _ = await self.waiter_machine.wait(StateViewHasher(view), message.message_id)
             should_continue = await self.handle(q)
             await q.answer(self.CALLBACK_ANSWER)
             if not should_continue:

telegrinder/msgspec_utils.py

@@ -210,12 +210,18 @@ class Decoder:
 
     @typing.overload
     def __call__(
-        self, type: type[T], *, strict: bool = True
+        self,
+        type: type[T],
+        *,
+        strict: bool = True,
     ) -> typing.ContextManager[msgspec.json.Decoder[T]]: ...
 
     @typing.overload
     def __call__(
-        self, type: typing.Any, *, strict: bool = True
+        self,
+        type: typing.Any,
+        *,
+        strict: bool = True,
     ) -> typing.ContextManager[msgspec.json.Decoder[typing.Any]]: ...
 
     @contextmanager
@@ -223,7 +229,9 @@ class Decoder:
         """Context manager returns the `msgspec.json.Decoder` object with the `dec_hook`."""
 
         dec_obj = msgspec.json.Decoder(
-            type=typing.Any if type is object else type, strict=strict, dec_hook=self.dec_hook
+            type=typing.Any if type is object else type,
+            strict=strict,
+            dec_hook=self.dec_hook,
         )
         yield dec_obj
 

telegrinder/node/attachment.py

@@ -31,7 +31,7 @@ class Attachment(DataNode):
     )
 
     @classmethod
-    async def compose(cls, message: MessageNode) -> "Attachment":
+    def compose(cls, message: MessageNode) -> "Attachment":
         for attachment_type in ("audio", "document", "photo", "poll", "video"):
             match getattr(message, attachment_type, Nothing()):
                 case Some(attachment):
@@ -44,7 +44,7 @@ class Photo(DataNode):
     sizes: list[telegrinder.types.PhotoSize]
 
     @classmethod
-    async def compose(cls, attachment: Attachment) -> typing.Self:
+    def compose(cls, attachment: Attachment) -> typing.Self:
         if not attachment.photo:
             raise ComposeError("Attachment is not a photo.")
         return cls(attachment.photo.unwrap())
@@ -52,7 +52,7 @@ class Photo(DataNode):
 
 class Video(ScalarNode, telegrinder.types.Video):
     @classmethod
-    async def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
+    def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
         if not attachment.video:
             raise ComposeError("Attachment is not a video.")
         return attachment.video.unwrap()
@@ -60,7 +60,7 @@ class Video(ScalarNode, telegrinder.types.Video):
 
 class Audio(ScalarNode, telegrinder.types.Audio):
     @classmethod
-    async def compose(cls, attachment: Attachment) -> telegrinder.types.Audio:
+    def compose(cls, attachment: Attachment) -> telegrinder.types.Audio:
         if not attachment.audio:
             raise ComposeError("Attachment is not an audio.")
         return attachment.audio.unwrap()
@@ -68,7 +68,7 @@ class Audio(ScalarNode, telegrinder.types.Audio):
 
 class Document(ScalarNode, telegrinder.types.Document):
     @classmethod
-    async def compose(cls, attachment: Attachment) -> telegrinder.types.Document:
+    def compose(cls, attachment: Attachment) -> telegrinder.types.Document:
         if not attachment.document:
             raise ComposeError("Attachment is not a document.")
         return attachment.document.unwrap()
@@ -76,7 +76,7 @@ class Document(ScalarNode, telegrinder.types.Document):
 
 class Poll(ScalarNode, telegrinder.types.Poll):
     @classmethod
-    async def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
+    def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
         if not attachment.poll:
             raise ComposeError("Attachment is not a poll.")
         return attachment.poll.unwrap()

telegrinder/node/base.py

@@ -4,12 +4,11 @@ import typing
 from types import AsyncGeneratorType
 
 from telegrinder.node.scope import NodeScope
-from telegrinder.tools.magic import (
-    cache_magic_value,
-    get_annotations,
-)
+from telegrinder.tools.magic import cache_magic_value, get_annotations
 
-ComposeResult: typing.TypeAlias = typing.Awaitable[typing.Any] | typing.AsyncGenerator[typing.Any, None]
+ComposeResult: typing.TypeAlias = (
+    typing.Awaitable[typing.Any] | typing.AsyncGenerator[typing.Any, None] | typing.Any
+)
 
 
 def is_node(maybe_node: typing.Any) -> typing.TypeGuard[type["Node"]]:
@@ -28,7 +27,9 @@ def get_nodes(function: typing.Callable[..., typing.Any]) -> dict[str, type["Nod
 
 
 @cache_magic_value("__is_generator__")
-def is_generator(function: typing.Callable[..., typing.Any]) -> typing.TypeGuard[AsyncGeneratorType[typing.Any, None]]:
+def is_generator(
+    function: typing.Callable[..., typing.Any],
+) -> typing.TypeGuard[AsyncGeneratorType[typing.Any, None]]:
     return inspect.isasyncgenfunction(function)
 
 
@@ -103,20 +104,25 @@ if typing.TYPE_CHECKING:
         pass
 
 else:
+
     def __init_subclass__(cls, *args, **kwargs):  # noqa: N807
-        if any(issubclass(base, ScalarNode) for base in cls.__bases__ if base is not ScalarNode):
+        if any(issubclass(base, ScalarNodeProto) for base in cls.__bases__ if base is not ScalarNode):
             raise RuntimeError("Scalar nodes do not support inheritance.")
 
-    def create_node(cls, bases, dct):
-        dct.update(cls.__dict__)
-        return type(cls.__name__, bases, dct)
+    def _as_node(cls, bases, dct):
+        if not hasattr(cls, "_scalar_node_type"):
+            dct.update(cls.__dict__)
+            scalar_node_type = type(cls.__name__, bases, dct)
+            setattr(cls, "_scalar_node_type", scalar_node_type)
+            return scalar_node_type
+        return getattr(cls, "_scalar_node_type")
 
     def create_class(name, bases, dct):
         return type(
             "Scalar",
             (SCALAR_NODE,),
             {
-                "as_node": classmethod(lambda cls: create_node(cls, bases, dct)),
+                "as_node": classmethod(lambda cls: _as_node(cls, bases, dct)),
                 "scope": Node.scope,
                 "__init_subclass__": __init_subclass__,
             },

telegrinder/node/callback_query.py

@@ -5,7 +5,7 @@ from telegrinder.node.update import UpdateNode
 
 class CallbackQueryNode(ScalarNode, CallbackQueryCute):
     @classmethod
-    async def compose(cls, update: UpdateNode) -> CallbackQueryCute:
+    def compose(cls, update: UpdateNode) -> CallbackQueryCute:
         if not update.callback_query:
             raise ComposeError("Update is not a callback_query.")
         return update.callback_query.unwrap()

telegrinder/node/command.py

@@ -24,7 +24,7 @@ class CommandInfo(DataNode):
     mention: Option[str] = field(default_factory=Nothing)
 
     @classmethod
-    async def compose(cls, text: Text) -> typing.Self:
+    def compose(cls, text: Text) -> typing.Self:
         name, arguments = single_split(text, separator=" ")
         name, mention = cut_mention(name)
         return cls(name, arguments, mention)

telegrinder/node/composer.py

@@ -1,8 +1,9 @@
 import dataclasses
+import inspect
 import typing
 
-from fntypes import Error, Ok, Result
 from fntypes.error import UnwrapError
+from fntypes.result import Error, Ok, Result
 
 from telegrinder.api.api import API
 from telegrinder.bot.cute_types.update import Update, UpdateCute
@@ -33,7 +34,9 @@ async def compose_node(
         value = await generator.asend(None)
     else:
         generator = None
-        value = await typing.cast(typing.Awaitable[typing.Any], node.compose(**kwargs))
+        value = typing.cast(typing.Awaitable[typing.Any] | typing.Any, node.compose(**kwargs))
+        if inspect.isawaitable(value):
+            value = await value
 
     return NodeSession(_node, value, {}, generator)
 

telegrinder/node/container.py

@@ -7,7 +7,7 @@ class ContainerNode(Node):
     linked_nodes: typing.ClassVar[list[type[Node]]]
 
     @classmethod
-    async def compose(cls, **kw) -> tuple[Node, ...]:
+    def compose(cls, **kw) -> tuple[Node, ...]:
         return tuple(t[1] for t in sorted(kw.items(), key=lambda t: t[0]))
 
     @classmethod

telegrinder/node/event.py

@@ -31,7 +31,7 @@ class _EventNode(Node):
         return cls(dataclass)
 
     @classmethod
-    async def compose(cls, raw_update: UpdateNode, ctx: Context, api: API) -> "DataclassType":
+    def compose(cls, raw_update: UpdateNode, ctx: Context, api: API) -> "DataclassType":
         dataclass_type = typing.get_origin(cls.dataclass) or cls.dataclass
 
         try:

telegrinder/node/message.py

@@ -5,7 +5,7 @@ from telegrinder.node.update import UpdateNode
 
 class MessageNode(ScalarNode, MessageCute):
     @classmethod
-    async def compose(cls, update: UpdateNode) -> MessageCute:
+    def compose(cls, update: UpdateNode) -> MessageCute:
         if not update.message:
             raise ComposeError("Update is not a message.")
         return update.message.unwrap()

telegrinder/node/polymorphic.py

@@ -13,7 +13,7 @@ from telegrinder.tools.magic import get_impls, impl
 class Polymorphic(Node):
     @classmethod
     async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
-        logger.debug(f"Composing polimorphic node {cls.__name__!r}...")
+        logger.debug(f"Composing polymorphic node {cls.__name__!r}...")
         scope = getattr(cls, "scope", None)
         node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
 
@@ -27,7 +27,10 @@ class Polymorphic(Node):
 
             # To determine whether this is a right morph, all subnodes must be resolved
             if scope is NodeScope.PER_EVENT and (cls, i) in node_ctx:
-                logger.debug("Morph is already cached as per_event node, using its value. Impl {!r} succeeded!", impl_.__name__)
+                logger.debug(
+                    "Morph is already cached as per_event node, using its value. Impl {!r} succeeded!",
+                    impl_.__name__,
+                )
                 res: NodeSession = node_ctx[(cls, i)]
                 await node_collection.close_all()
                 return res.value
@@ -40,7 +43,7 @@ class Polymorphic(Node):
                 node_ctx[(cls, i)] = NodeSession(cls, result, {})
 
             await node_collection.close_all(with_value=result)
-            logger.debug("Impl {!r} succeeded with value: {}", impl_.__name__, result)
+            logger.debug("Impl {!r} succeeded with value: {!r}", impl_.__name__, result)
             return result
 
         raise ComposeError("No implementation found.")

telegrinder/node/rule.py

@@ -12,7 +12,7 @@ if typing.TYPE_CHECKING:
 
 
 class RuleChain(dict[str, typing.Any], Node):
-    dataclass = dict
+    dataclass: type[typing.Any] = dict
     rules: tuple["ABCRule", ...] = ()
 
     def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None: