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

telegrinder/bot/rules/mention.py

@@ -5,7 +5,7 @@ from .text import HasText
 
 
 class HasMention(MessageRule, requires=[HasText()]):
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         if not message.entities.unwrap_or_none():
             return False
         return any(entity.type == MessageEntityType.MENTION for entity in message.entities.unwrap())

telegrinder/bot/rules/message.py

@@ -3,7 +3,7 @@ import abc
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.objects import Message as MessageEvent
 
-from .abc import ABCRule, Message
+from .abc import ABCRule, CheckResult, Message
 from .adapter import EventAdapter
 
 
@@ -11,7 +11,7 @@ class MessageRule(ABCRule[Message], abc.ABC):
     adapter: EventAdapter[Message] = EventAdapter(MessageEvent, Message)
 
     @abc.abstractmethod
-    async def check(self, message: Message, ctx: Context) -> bool: ...
+    def check(self, message: Message, ctx: Context) -> CheckResult: ...
 
 
 __all__ = ("MessageRule",)

telegrinder/bot/rules/message_entities.py

@@ -10,7 +10,7 @@ Entity: typing.TypeAlias = str | MessageEntityType
 
 
 class HasEntities(MessageRule):
-    async def check(self, message: Message) -> bool:
+    def check(self, message: Message) -> bool:
         return bool(message.entities)
 
 
@@ -18,7 +18,7 @@ class MessageEntities(MessageRule, requires=[HasEntities()]):
     def __init__(self, entities: Entity | list[Entity], /) -> None:
         self.entities = [entities] if not isinstance(entities, list) else entities
 
-    async def check(self, message: Message, ctx: Context) -> bool:
+    def check(self, message: Message, ctx: Context) -> bool:
         message_entities: list[MessageEntity] = []
         for entity in message.entities.unwrap():
             for entity_type in self.entities:

telegrinder/bot/rules/node.py

@@ -17,7 +17,7 @@ class NodeRule(ABCRule[tuple[Node, ...]]):
     def adapter(self) -> NodeAdapter:
         return NodeAdapter(*self.nodes)  # type: ignore
 
-    async def check(self, resolved_nodes: tuple[Node, ...], ctx: Context) -> typing.Literal[True]:
+    def check(self, resolved_nodes: tuple[Node, ...], ctx: Context) -> typing.Literal[True]:
         for i, node in enumerate(resolved_nodes):
             if key := self.node_keys[i]:
                 ctx[key] = node

telegrinder/bot/rules/regex.py

@@ -22,7 +22,7 @@ class Regex(ABCRule):
                     re.compile(regexp) if isinstance(regexp, str) else regexp for regexp in regexp
                 )
 
-    async def check(self, text: Text, ctx: Context) -> bool:
+    def check(self, text: Text, ctx: Context) -> bool:
         for regexp in self.regexp:
             response = re.match(regexp, text)
             if response is not None:

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"]),
     ],
@@ -28,7 +28,7 @@ class StartCommand(
         self.validator = validator
         self.alias = alias
 
-    async def check(self, ctx: Context) -> bool:
+    def check(self, ctx: Context) -> bool:
         param: str | None = ctx.pop("param", None)
         validated_param = self.validator(param) if self.validator and param is not None else param
 

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
@@ -17,12 +19,12 @@ class Text(ABCRule):
         self.texts = texts if not ignore_case else list(map(str.lower, texts))
         self.ignore_case = ignore_case
 
-    async def check(self, text: node.text.Text) -> bool:
+    def check(self, text: node.text.Text) -> bool:
         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/rules/update.py

@@ -8,7 +8,7 @@ class IsUpdateType(ABCRule):
     def __init__(self, update_type: UpdateType, /) -> None:
         self.update_type = update_type
 
-    async def check(self, event: UpdateCute) -> bool:
+    def check(self, event: UpdateCute) -> bool:
         return event.update_type == self.update_type
 
 

telegrinder/bot/scenario/checkbox.py

@@ -35,6 +35,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         message: str,
         *,
         ready_text: str = "Ready",
+        cancel_text: str | None = None,
         max_in_row: int = 3,
     ) -> None:
         self.chat_id = chat_id
@@ -44,6 +45,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         self.max_in_row = max_in_row
         self.random_code = secrets.token_hex(8)
         self.waiter_machine = waiter_machine
+        self.cancel_text = cancel_text
 
     def __repr__(self) -> str:
         return (
@@ -75,6 +77,9 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
             kb.row()
 
         kb.add(InlineButton(self.ready, callback_data=self.random_code + "/ready"))
+        if self.cancel_text is not None:
+            kb.row()
+            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/cancel"))
         return kb.get_markup()
 
     def add_option(
@@ -94,6 +99,9 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
         if code == "ready":
             return False
+        elif code == "cancel":
+            self.choices = []
+            return False
 
         for i, choice in enumerate(self.choices):
             if choice.code == code:
@@ -124,7 +132,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:

telegrinder/node/source.py

@@ -21,7 +21,7 @@ class Source(Polymorphic, DataNode):
     thread_id: Option[int] = dataclasses.field(default_factory=lambda: Nothing())
 
     @impl
-    async def compose_message(cls, message: MessageNode) -> typing.Self:
+    def compose_message(cls, message: MessageNode) -> typing.Self:
         return cls(
             api=message.ctx_api,
             chat=message.chat,
@@ -30,7 +30,7 @@ class Source(Polymorphic, DataNode):
         )
 
     @impl
-    async def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
+    def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
         return cls(
             api=callback_query.ctx_api,
             chat=callback_query.chat.expect(ComposeError("CallbackQueryNode has no chat")),
@@ -39,9 +39,7 @@ class Source(Polymorphic, DataNode):
         )
 
     @impl
-    async def compose_chat_join_request(
-        cls, chat_join_request: EventNode[ChatJoinRequestCute]
-    ) -> typing.Self:
+    def compose_chat_join_request(cls, chat_join_request: EventNode[ChatJoinRequestCute]) -> typing.Self:
         return cls(
             api=chat_join_request.ctx_api,
             chat=chat_join_request.chat,
@@ -60,13 +58,13 @@ class Source(Polymorphic, DataNode):
 
 class ChatSource(ScalarNode, Chat):
     @classmethod
-    async def compose(cls, source: Source) -> Chat:
+    def compose(cls, source: Source) -> Chat:
         return source.chat
 
 
 class UserSource(ScalarNode, User):
     @classmethod
-    async def compose(cls, source: Source) -> User:
+    def compose(cls, source: Source) -> User:
         return source.from_user
 
 

telegrinder/node/text.py

@@ -4,7 +4,7 @@ from telegrinder.node.message import MessageNode
 
 class Text(ScalarNode, str):
     @classmethod
-    async def compose(cls, message: MessageNode) -> str:
+    def compose(cls, message: MessageNode) -> str:
         if not message.text:
             raise ComposeError("Message has no text.")
         return message.text.unwrap()
@@ -12,7 +12,7 @@ class Text(ScalarNode, str):
 
 class TextInteger(ScalarNode, int):
     @classmethod
-    async def compose(cls, text: Text) -> int:
+    def compose(cls, text: Text) -> int:
         if not text.isdigit():
             raise ComposeError("Text is not digit.")
         return int(text)

telegrinder/node/tools/generator.py

@@ -25,8 +25,7 @@ def generate_node(
     casts: tuple[typing.Callable[[typing.Any], typing.Any], ...] = (cast_false_to_none, error_on_none),
 ) -> type[Node]:
     async def compose(cls, **kw) -> typing.Any:
-        args = await ContainerNode.compose(**kw)
-        result = func(*args)  # type: ignore
+        result = func(*ContainerNode.compose(**kw))  # type: ignore
         if inspect.isawaitable(result):
             result = await result
         for cast in casts:

telegrinder/node/update.py

@@ -1,12 +1,12 @@
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types import UpdateCute
 from telegrinder.node.base import ScalarNode
-from telegrinder.types import Update
+from telegrinder.types.objects import Update
 
 
 class UpdateNode(ScalarNode, UpdateCute):
     @classmethod
-    async def compose(cls, update: Update, api: API) -> UpdateCute:
+    def compose(cls, update: Update, api: API) -> UpdateCute:
         if isinstance(update, UpdateCute):
             return update
         return UpdateCute.from_update(update, api)

telegrinder/rules.py

@@ -56,5 +56,7 @@ __all__ = (
     "Regex",
     "RuleEnum",
     "StartCommand",
+    "State",
+    "StateMeta",
     "Text",
 )

telegrinder/tools/buttons.py

@@ -14,7 +14,7 @@ from telegrinder.types.objects import (
     WebAppInfo,
 )
 
-ButtonT = typing.TypeVar("ButtonT", bound="BaseButton")
+KeyboardButton = typing.TypeVar("KeyboardButton", bound="BaseButton")
 
 
 @dataclasses.dataclass
@@ -27,11 +27,11 @@ class BaseButton:
         }
 
 
-class RowButtons(typing.Generic[ButtonT]):
-    buttons: list[ButtonT]
+class RowButtons(typing.Generic[KeyboardButton]):
+    buttons: list[KeyboardButton]
     auto_row: bool
 
-    def __init__(self, *buttons: ButtonT, auto_row: bool = True) -> None:
+    def __init__(self, *buttons: KeyboardButton, auto_row: bool = True) -> None:
         self.buttons = list(buttons)
         self.auto_row = auto_row
 

telegrinder/tools/error_handler/abc.py

@@ -6,28 +6,28 @@ from fntypes.result import Result
 from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 
-EventT = typing.TypeVar("EventT")
-Handler = typing.Callable[typing.Concatenate[EventT, ...], typing.Awaitable[typing.Any]]
+Event = typing.TypeVar("Event")
+Handler = typing.Callable[..., typing.Awaitable[typing.Any]]
 
 
-class ABCErrorHandler(ABC, typing.Generic[EventT]):
+class ABCErrorHandler(ABC, typing.Generic[Event]):
     @abstractmethod
     def __call__(
         self,
         *args: typing.Any,
         **kwargs: typing.Any,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
-        """Decorator for registering callback as an error handler."""
+        """Decorator for registering callback as a catcher for the error handler."""
 
     @abstractmethod
     async def run(
         self,
-        handler: Handler[EventT],
-        event: EventT,
+        handler: Handler,
+        event: Event,
         api: API,
         ctx: Context,
     ) -> Result[typing.Any, typing.Any]:
-        """Run error handler."""
+        """Run the error handler."""
 
 
 __all__ = ("ABCErrorHandler",)