telegrinder 0.1.dev171__py3-none-any.whl → 0.2.0__py3-none-any.whl

telegrinder/bot/rules/__init__.py

@@ -1,5 +1,5 @@
-from .abc import ABCRule, AndRule, NotRule, OrRule
-from .callback_data import (
+from telegrinder.bot.rules.abc import ABCRule, AndRule, NotRule, OrRule
+from telegrinder.bot.rules.callback_data import (
     CallbackDataEq,
     CallbackDataJsonEq,
     CallbackDataJsonModel,
@@ -9,25 +9,25 @@ from .callback_data import (
     CallbackQueryRule,
     HasData,
 )
-from .chat_join import (
+from telegrinder.bot.rules.chat_join import (
     ChatJoinRequestRule,
     HasInviteLink,
     InviteLinkByCreator,
     InviteLinkName,
 )
-from .command import Argument, Command
-from .enum_text import EnumTextRule
-from .func import FuncRule
-from .fuzzy import FuzzyText
-from .inline import (
+from telegrinder.bot.rules.command import Argument, Command
+from telegrinder.bot.rules.enum_text import EnumTextRule
+from telegrinder.bot.rules.func import FuncRule
+from telegrinder.bot.rules.fuzzy import FuzzyText
+from telegrinder.bot.rules.inline import (
     HasLocation,
     InlineQueryChatType,
     InlineQueryMarkup,
     InlineQueryRule,
     InlineQueryText,
 )
-from .integer import IntegerInRange, IsInteger
-from .is_from import (
+from telegrinder.bot.rules.integer import IntegerInRange, IsInteger
+from telegrinder.bot.rules.is_from import (
     IsBot,
     IsChat,
     IsChatId,
@@ -45,16 +45,16 @@ from .is_from import (
     IsUser,
     IsUserId,
 )
-from .markup import Markup
-from .mention import HasMention
-from .message import MessageRule
-from .message_entities import HasEntities, MessageEntities
-from .node import NodeRule
-from .regex import Regex
-from .rule_enum import RuleEnum
-from .start import StartCommand
-from .text import HasText, Text
-from .update import IsUpdateType
+from telegrinder.bot.rules.markup import Markup
+from telegrinder.bot.rules.mention import HasMention
+from telegrinder.bot.rules.message import MessageRule
+from telegrinder.bot.rules.message_entities import HasEntities, MessageEntities
+from telegrinder.bot.rules.node import NodeRule
+from telegrinder.bot.rules.regex import Regex
+from telegrinder.bot.rules.rule_enum import RuleEnum
+from telegrinder.bot.rules.start import StartCommand
+from telegrinder.bot.rules.text import HasText, Text
+from telegrinder.bot.rules.update import IsUpdateType
 
 __all__ = (
     "ABCRule",

telegrinder/bot/rules/abc.py

@@ -11,7 +11,12 @@ 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.magic import cache_translation, get_annotations, get_cached_translation
+from telegrinder.tools.magic import (
+    cache_translation,
+    get_annotations,
+    get_cached_translation,
+    get_default_args,
+)
 from telegrinder.types.objects import Update as UpdateObject
 
 if typing.TYPE_CHECKING:
@@ -37,51 +42,16 @@ def with_caching_translations(func: typing.Callable[..., typing.Any]):
 
 
 class ABCRule(ABC, typing.Generic[AdaptTo]):
-    adapter: ABCAdapter[UpdateObject, AdaptTo] = RawUpdateAdapter()  # type: ignore
+    adapter: ABCAdapter[UpdateObject, AdaptTo]
     requires: list["ABCRule"] = []
 
+    if not typing.TYPE_CHECKING:
+        adapter = RawUpdateAdapter()
+
     @abstractmethod
     async def check(self, event: AdaptTo, *, ctx: Context) -> bool:
         pass
 
-    @cached_property
-    def required_nodes(self) -> dict[str, type[Node]]:
-        return get_nodes(self.check)
-
-    async def bounding_check(
-        self,
-        adapted_value: AdaptTo,
-        ctx: Context,
-        node_col: "NodeCollection | None" = None,
-    ) -> bool:
-        kw = {}
-        node_col_values = node_col.values() if node_col is not None else {}
-
-        for i, (k, v) in enumerate(get_annotations(self.check).items()):
-            if (isinstance(adapted_value, Event) and not i) or (
-                isinstance(v, type) and isinstance(adapted_value, v)
-            ):
-                kw[k] = adapted_value if not isinstance(adapted_value, Event) else adapted_value.obj
-            elif is_node(v):
-                assert k in node_col_values, "Node is undefined, error while bounding."
-                kw[k] = node_col_values[k]
-            elif k in ctx:
-                kw[k] = ctx[k]
-            elif v is Context:
-                kw[k] = ctx
-            else:
-                raise LookupError(
-                    f"Cannot bound {k!r} of type {v!r} to '{self.__class__.__name__}.check()', because it cannot be resolved."
-                )
-
-        return await self.check(**kw)
-
-    def optional(self) -> "ABCRule":
-        return self | Always()
-
-    def should_fail(self) -> "ABCRule":
-        return self & Never()
-
     def __init_subclass__(cls, requires: list["ABCRule"] | None = None) -> None:
         """Merges requirements from inherited classes and rule-specific requirements."""
 
@@ -132,6 +102,46 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
             self.adapter,
         )
 
+    @cached_property
+    def required_nodes(self) -> dict[str, type[Node]]:
+        return get_nodes(self.check)
+
+    def as_optional(self) -> "ABCRule":
+        return self | Always()
+
+    def should_fail(self) -> "ABCRule":
+        return self & Never()
+
+    async def bounding_check(
+        self,
+        adapted_value: AdaptTo,
+        ctx: Context,
+        node_col: "NodeCollection | None" = None,
+    ) -> bool:
+        kw = {}
+        node_col_values = node_col.values if node_col is not None else {}
+        temp_ctx = get_default_args(self.check) | ctx
+
+        for i, (k, v) in enumerate(get_annotations(self.check).items()):
+            if (isinstance(adapted_value, Event) and not i) or (
+                isinstance(v, type) and isinstance(adapted_value, v)
+            ):
+                kw[k] = adapted_value if not isinstance(adapted_value, Event) else adapted_value.obj
+            elif is_node(v):
+                assert k in node_col_values, "Node is undefined, error while bounding."
+                kw[k] = node_col_values[k]
+            elif k in temp_ctx:
+                kw[k] = temp_ctx[k]
+            elif v is Context:
+                kw[k] = ctx
+            else:
+                raise LookupError(
+                    f"Cannot bound {k!r} of type {v!r} to '{self.__class__.__qualname__}.check()', "
+                    "because it cannot be resolved."
+                )
+
+        return await self.check(**kw)
+
     async def translate(self, translator: ABCTranslator) -> typing.Self:
         return self
 

telegrinder/bot/rules/adapter/__init__.py

@@ -1,8 +1,8 @@
-from .abc import ABCAdapter, Event
-from .errors import AdapterError
-from .event import EventAdapter
-from .node import NodeAdapter
-from .raw_update import RawUpdateAdapter
+from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.bot.rules.adapter.event import EventAdapter
+from telegrinder.bot.rules.adapter.node import NodeAdapter
+from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
 
 __all__ = (
     "ABCAdapter",

telegrinder/bot/rules/adapter/abc.py

@@ -4,7 +4,8 @@ import typing
 
 from fntypes.result import Result
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
+from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.model import Model
 
@@ -13,12 +14,14 @@ To = typing.TypeVar("To")
 
 
 class ABCAdapter(abc.ABC, typing.Generic[From, To]):
+    ADAPTED_VALUE_KEY: str | None = None
+
     @abc.abstractmethod
-    async def adapt(self, api: ABCAPI, update: From) -> Result[To, AdapterError]:
+    async def adapt(self, api: API, update: From, context: Context) -> Result[To, AdapterError]:
         pass
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class Event(typing.Generic[To]):
     obj: To
 

telegrinder/bot/rules/adapter/errors.py

@@ -1,4 +1,5 @@
-class AdapterError(RuntimeError): ...
+class AdapterError(RuntimeError):
+    pass
 
 
 __all__ = ("AdapterError",)

telegrinder/bot/rules/adapter/event.py

@@ -2,8 +2,9 @@ import typing
 
 from fntypes.result import Error, Ok, Result
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter.abc import ABCAdapter
 from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.msgspec_utils import Nothing
@@ -14,6 +15,8 @@ ToCute = typing.TypeVar("ToCute", bound=BaseCute)
 
 
 class EventAdapter(ABCAdapter[Update, ToCute]):
+    ADAPTED_VALUE_KEY: str = "_adapted_cute_event"
+
     def __init__(self, event: UpdateType | type[Model], cute_model: type[ToCute]) -> None:
         self.event = event
         self.cute_model = cute_model
@@ -29,36 +32,45 @@ class EventAdapter(ABCAdapter[Update, ToCute]):
         else:
             raw_update_type = self.event.__name__
 
-        return "<{}: adapt {} -> {}>".format(
+        return "<{}: adapt Update -> {} -> {}>".format(
             self.__class__.__name__,
             raw_update_type,
             self.cute_model.__name__,
         )
 
-    async def adapt(self, api: ABCAPI, update: Update) -> Result[ToCute, AdapterError]:
-        update_dct = update.to_dict()
+    async def adapt(self, api: API, update: Update, context: Context) -> Result[ToCute, AdapterError]:
+        if self.ADAPTED_VALUE_KEY in context:
+            return Ok(context[self.ADAPTED_VALUE_KEY])
+
         if isinstance(self.event, UpdateType):
             if update.update_type != self.event:
                 return Error(
                     AdapterError(f"Update is not of event type {self.event!r}."),
                 )
 
-            if (event := getattr(update, self.event.value, Nothing)) is Nothing:
+            if isinstance(event := getattr(update, self.event.value, Nothing), type(Nothing)):
                 return Error(
                     AdapterError(f"Update is not an {self.event!r}."),
                 )
 
-            return Ok(
-                self.cute_model.from_update(
-                    getattr(update, self.event.value).unwrap(),
-                    bound_api=api,
-                ),
-            )
+            event = event.unwrap()
+
+            if type(event) is self.cute_model:
+                adapted = event
+            else:
+                adapted = self.cute_model.from_update(event, bound_api=api)
+        else:
+            event = getattr(update, update.update_type.value).unwrap()
+            if not update.update_type or not issubclass(type(event), self.event):
+                return Error(AdapterError(f"Update is not an {self.event.__name__!r}."))
+
+            if type(event) is self.cute_model:
+                adapted = event
+            else:
+                adapted = self.cute_model.from_update(event, bound_api=api)
 
-        event = getattr(update, update.update_type.value).unwrap()
-        if not update.update_type or not issubclass(event.__class__, self.event):
-            return Error(AdapterError(f"Update is not an {self.event.__name__!r}."))
-        return Ok(self.cute_model.from_update(event, bound_api=api))
+        context[self.ADAPTED_VALUE_KEY] = adapted
+        return Ok(adapted)  # type: ignore
 
 
 __all__ = ("EventAdapter",)

telegrinder/bot/rules/adapter/node.py

@@ -1,17 +1,18 @@
-import typing
-
+import typing_extensions as typing
 from fntypes.result import Error, Ok, Result
 
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
 from telegrinder.bot.rules.adapter.errors import AdapterError
-from telegrinder.node.base import ComposeError
-from telegrinder.node.composer import NodeSession, compose_node
+from telegrinder.msgspec_utils import repr_type
+from telegrinder.node.composer import NodeSession, compose_nodes
 from telegrinder.types.objects import Update
 
-Ts = typing.TypeVarTuple("Ts")
+if typing.TYPE_CHECKING:
+    from telegrinder.node.base import Node
+
+Ts = typing.TypeVarTuple("Ts", default=typing.Unpack[tuple[type["Node"], ...]])
 
 
 class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
@@ -19,24 +20,29 @@ class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
         self.nodes = nodes
 
     def __repr__(self) -> str:
-        return "<{}: adapt Update -> {}>".format(
+        return "<{}: adapt Update -> ({})>".format(
             self.__class__.__name__,
-            Update.__name__,
-            ", ".join(node.__name__ for node in self.nodes),  # type: ignore
+            ", ".join(repr_type(node) for node in self.nodes),
+        )
+
+    async def adapt(
+        self,
+        api: API,
+        update: Update,
+        context: Context,
+    ) -> Result[Event[tuple[*Ts]], AdapterError]:
+        result = await compose_nodes(
+            nodes={str(i): typing.cast(type["Node"], node) for i, node in enumerate(self.nodes)},
+            ctx=context,
+            data={Update: update, API: api},
         )
 
-    async def adapt(self, api: ABCAPI, update: Update) -> Result[Event[tuple[*Ts]], AdapterError]:
-        update_cute = UpdateCute.from_update(update, api)
-        node_sessions: list[NodeSession] = []
-        for node_t in self.nodes:
-            try:
-                # FIXME: adapters should have context
-                node_sessions.append(await compose_node(node_t, update_cute, Context(raw_update=update)))  # type: ignore
-            except ComposeError:
-                for session in node_sessions:
-                    await session.close(with_value=None)
-                return Error(AdapterError(f"Couldn't compose nodes, error on {node_t}"))
-        return Ok(Event(tuple(node_sessions)))  # type: ignore
+        match result:
+            case Ok(collection):
+                sessions: list[NodeSession] = list(collection.sessions.values())
+                return Ok(Event(tuple(sessions)))  # type: ignore
+            case Error(err):
+                return Error(AdapterError(f"Couldn't compose nodes, error: {err}."))
 
 
 __all__ = ("NodeAdapter",)

telegrinder/bot/rules/adapter/raw_update.py

@@ -1,24 +1,32 @@
 from fntypes.result import Ok, Result
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.adapter.abc import ABCAdapter
 from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.types.objects import Update
 
 
 class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
+    ADAPTED_VALUE_KEY: str = "_adapted_update_cute"
+
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
 
     async def adapt(
         self,
-        api: ABCAPI,
+        api: API,
         update: Update,
+        context: Context,
     ) -> Result[UpdateCute, AdapterError]:
-        if not isinstance(update, UpdateCute):
-            return Ok(UpdateCute.from_update(update, api))
-        return Ok(update)
+        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
+            )
+        return Ok(context[self.ADAPTED_VALUE_KEY])
 
 
 __all__ = ("RawUpdateAdapter",)

telegrinder/bot/rules/callback_data.py

@@ -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, ctx: Context) -> bool:
+    async def check(self, event: CallbackQuery, context: Context) -> bool:
         pass
 
 
 class HasData(CallbackQueryRule):
-    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+    async 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, ctx: Context) -> bool:
+    async 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, ctx: Context) -> bool:
+    async def check(self, event: CallbackQuery) -> bool:
         return event.decode_callback_data().unwrap_or_none() == self.d
 
 

telegrinder/bot/rules/chat_join.py

@@ -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, ctx: Context) -> bool:
+    async def check(self, event: ChatJoinRequest, context: Context) -> bool:
         pass
 
 
 class HasInviteLink(ChatJoinRequestRule):
-    async def check(self, event: ChatJoinRequest, ctx: Context) -> bool:
+    async 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, ctx: Context) -> bool:
+    async 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, ctx: Context) -> bool:
+    async def check(self, event: ChatJoinRequest) -> bool:
         return event.invite_link.unwrap().creator.id == self.creator_id
 
 

telegrinder/bot/rules/func.py

@@ -12,7 +12,7 @@ class FuncRule(ABCRule, typing.Generic[AdaptTo]):
         self,
         func: typing.Callable[[AdaptTo, Context], typing.Awaitable[bool] | bool],
         adapter: ABCAdapter[Update, AdaptTo] | None = None,
-    ):
+    ) -> None:
         self.func = func
         self.adapter = adapter or RawUpdateAdapter()  # type: ignore
 

telegrinder/bot/rules/inline.py

@@ -21,7 +21,7 @@ class InlineQueryRule(ABCRule[InlineQuery], abc.ABC):
 
 
 class HasLocation(InlineQueryRule):
-    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+    async def check(self, query: InlineQuery) -> bool:
         return bool(query.location)
 
 
@@ -29,7 +29,7 @@ class InlineQueryChatType(InlineQueryRule):
     def __init__(self, chat_type: ChatType, /) -> None:
         self.chat_type = chat_type
 
-    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+    async def check(self, query: InlineQuery) -> bool:
         return query.chat_type.map(lambda x: x == self.chat_type).unwrap_or(False)
 
 
@@ -40,7 +40,7 @@ class InlineQueryText(InlineQueryRule):
         ]
         self.lower_case = lower_case
 
-    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+    async def check(self, query: InlineQuery) -> bool:
         return (query.query.lower() if self.lower_case else query.query) in self.texts
 
 

telegrinder/bot/rules/markup.py

@@ -9,7 +9,7 @@ from telegrinder.tools.global_context.telegrinder_ctx import TelegrinderContext
 from .abc import ABCRule
 
 PatternLike: typing.TypeAlias = str | vbml.Pattern
-global_ctx = TelegrinderContext()
+global_ctx: typing.Final[TelegrinderContext] = TelegrinderContext()
 
 
 def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
@@ -24,6 +24,8 @@ 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)"""
+
     def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
         if not isinstance(patterns, list):
             patterns = [patterns]

telegrinder/bot/rules/message_entities.py

@@ -10,7 +10,7 @@ Entity: typing.TypeAlias = str | MessageEntityType
 
 
 class HasEntities(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
+    async def check(self, message: Message) -> bool:
         return bool(message.entities)
 
 

telegrinder/bot/rules/text.py

@@ -1,5 +1,4 @@
 from telegrinder import node
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.tools.i18n.base import ABCTranslator
 
 from .abc import ABCRule, with_caching_translations
@@ -18,7 +17,7 @@ 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, ctx: Context) -> bool:
+    async def check(self, text: node.text.Text) -> bool:
         return (text if not self.ignore_case else text.lower()) in self.texts
 
     @with_caching_translations

telegrinder/bot/rules/update.py

@@ -1,5 +1,4 @@
 from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.enums import UpdateType
 
 from .abc import ABCRule
@@ -9,7 +8,7 @@ class IsUpdateType(ABCRule):
     def __init__(self, update_type: UpdateType, /) -> None:
         self.update_type = update_type
 
-    async def check(self, event: UpdateCute, ctx: Context) -> bool:
+    async def check(self, event: UpdateCute) -> bool:
         return event.update_type == self.update_type
 
 

telegrinder/bot/scenario/abc.py

@@ -4,7 +4,7 @@ from abc import ABC, abstractmethod
 from telegrinder.bot.cute_types.base import BaseCute
 
 if typing.TYPE_CHECKING:
-    from telegrinder.api import ABCAPI
+    from telegrinder.api import API
     from telegrinder.bot.dispatch.view.abc import ABCStateView
 
 EventT = typing.TypeVar("EventT", bound=BaseCute)
@@ -12,7 +12,7 @@ EventT = typing.TypeVar("EventT", bound=BaseCute)
 
 class ABCScenario(ABC, typing.Generic[EventT]):
     @abstractmethod
-    def wait(self, api: "ABCAPI", view: "ABCStateView[EventT]") -> typing.Any:
+    def wait(self, api: "API", view: "ABCStateView[EventT]") -> typing.Any:
         pass
 
 

telegrinder/bot/scenario/checkbox.py

@@ -4,12 +4,11 @@ import typing
 
 from telegrinder.bot.cute_types import CallbackQueryCute
 from telegrinder.bot.dispatch.waiter_machine import WaiterMachine
+from telegrinder.bot.scenario.abc import ABCScenario
 from telegrinder.tools import InlineButton, InlineKeyboard
 from telegrinder.tools.parse_mode import ParseMode
 from telegrinder.types.objects import InlineKeyboardMarkup
 
-from .abc import ABCScenario
-
 if typing.TYPE_CHECKING:
     from telegrinder.api import API
     from telegrinder.bot.dispatch.view.abc import BaseStateView

telegrinder/bot/scenario/choice.py

@@ -1,8 +1,7 @@
 import typing
 
 from telegrinder.bot.cute_types import CallbackQueryCute
-
-from .checkbox import Checkbox
+from telegrinder.bot.scenario.checkbox import Checkbox
 
 if typing.TYPE_CHECKING:
     from telegrinder.api import API

telegrinder/model.py

@@ -58,6 +58,11 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     return validated_params
 
 
+def encode_name(name: str) -> str:
+    # TODO
+    return MODEL_CONFIG.get("rename", {}).get(name, name)
+
+
 class Model(msgspec.Struct, **MODEL_CONFIG):
     @classmethod
     def from_data(cls, data: dict[str, typing.Any]) -> typing.Self:
@@ -168,7 +173,7 @@ class DataConverter:
         data: Model,
         serialize: bool = True,
     ) -> str | dict[str, typing.Any]:
-        converted_dct = self(data.to_full_dict(), serialize=False)
+        converted_dct = self(data.to_dict(), serialize=False)
         return encoder.encode(converted_dct) if serialize is True else converted_dct
 
     def convert_dct(