telegrinder 0.1.dev169__py3-none-any.whl → 0.1.dev171__py3-none-any.whl

telegrinder/node/composer.py

@@ -1,11 +1,20 @@
+import dataclasses
 import typing
 
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types import UpdateCute
+from fntypes.error import UnwrapError
+
+from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.base import ComposeError, Node
-from telegrinder.node.scope import NodeScope
-from telegrinder.tools.magic import get_annotations, magic_bundle
+from telegrinder.modules import logger
+from telegrinder.node.base import (
+    BaseNode,
+    ComposeError,
+    Node,
+    NodeScope,
+    get_compose_annotations,
+    get_nodes,
+)
+from telegrinder.tools.magic import magic_bundle
 
 CONTEXT_STORE_NODES_KEY = "node_ctx"
 
@@ -22,80 +31,86 @@ async def compose_node(
     for name, subnode in node.get_sub_nodes().items():
         if subnode in node_ctx:
             context.sessions[name] = node_ctx[subnode]
-        elif subnode is UpdateCute:
-            context.sessions[name] = NodeSession(None, update, {})
-        elif subnode is API:
-            context.sessions[name] = NodeSession(None, update.ctx_api, {})
-        elif subnode is Context:
-            context.sessions[name] = NodeSession(None, ctx, {})
         else:
             context.sessions[name] = await compose_node(subnode, update, ctx)
 
             if getattr(subnode, "scope", None) is NodeScope.PER_EVENT:
                 node_ctx[subnode] = context.sessions[name]
 
-    generator: typing.AsyncGenerator | None
+    for name, annotation in node.get_compose_annotations().items():
+        context.sessions[name] = NodeSession(
+            None,
+            await node.compose_annotation(annotation, update, ctx),
+            {},
+        )
 
     if node.is_generator():
-        generator = typing.cast(typing.AsyncGenerator, node.compose(**context.values()))
+        generator = typing.cast(typing.AsyncGenerator[typing.Any, None], node.compose(**context.values()))
         value = await generator.asend(None)
     else:
         generator = None
-        value = await node.compose(**context.values())  # type: ignore
+        value = await typing.cast(typing.Awaitable[typing.Any], node.compose(**context.values()))
 
     return NodeSession(_node, value, context.sessions, generator)
 
 
 async def compose_nodes(
-    node_types: dict[str, type[Node]],
     update: UpdateCute,
     ctx: Context,
-) -> typing.Optional["NodeCollection"]:
-    nodes: dict[str, NodeSession] = {}
+    nodes: dict[str, type[Node]],
+    node_class: type[Node] | None = None,
+    context_annotations: dict[str, typing.Any] | None = None,
+) -> "NodeCollection | None":
+    node_sessions: dict[str, NodeSession] = {}
     node_ctx: dict[type[Node], "NodeSession"] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
 
-    for name, node_t in node_types.items():
-        scope = getattr(node_t, "scope", None)
-        try:
+    try:
+        for name, node_t in nodes.items():
+            scope = getattr(node_t, "scope", None)
+
             if scope is NodeScope.PER_EVENT and node_t in node_ctx:
-                nodes[name] = node_ctx[node_t]
+                node_sessions[name] = node_ctx[node_t]
                 continue
             elif scope is NodeScope.GLOBAL and hasattr(node_t, "_value"):
-                nodes[name] = getattr(node_t, "_value")
+                node_sessions[name] = getattr(node_t, "_value")
                 continue
 
-            nodes[name] = await compose_node(
-                node_t,
-                update,
-                ctx,
-            )
+            node_sessions[name] = await compose_node(node_t, update, ctx)
 
             if scope is NodeScope.PER_EVENT:
-                node_ctx[node_t] = nodes[name]
+                node_ctx[node_t] = node_sessions[name]
             elif scope is NodeScope.GLOBAL:
-                setattr(node_t, "_value", nodes[name])
+                setattr(node_t, "_value", node_sessions[name])
+    except (ComposeError, UnwrapError) as exc:
+        logger.debug(f"Composing node (name={name!r}, node_class={node_t!r}) failed with error: {str(exc)!r}")
+        await NodeCollection(node_sessions).close_all()
+        return None
+
+    if context_annotations:
+        node_class = node_class or BaseNode
 
-        except ComposeError:
-            await NodeCollection(nodes).close_all()
+        try:
+            for name, annotation in context_annotations.items():
+                node_sessions[name] = await node_class.compose_annotation(annotation, update, ctx)
+        except (ComposeError, UnwrapError) as exc:
+            logger.debug(
+                f"Composing context annotation (name={name!r}, annotation={annotation!r}) failed with error: {str(exc)!r}",
+            )
+            await NodeCollection(node_sessions).close_all()
             return None
-    return NodeCollection(nodes)
+
+    return NodeCollection(node_sessions)
 
 
+@dataclasses.dataclass(slots=True, repr=False)
 class NodeSession:
-    def __init__(
-        self,
-        node_type: type[Node] | None,
-        value: typing.Any,
-        subnodes: dict[str, typing.Self],
-        generator: typing.AsyncGenerator[typing.Any, None] | None = None,
-    ):
-        self.node_type = node_type
-        self.value = value
-        self.subnodes = subnodes
-        self.generator = generator
+    node_type: type[Node] | None
+    value: typing.Any
+    subnodes: dict[str, typing.Self]
+    generator: typing.AsyncGenerator[typing.Any, None] | None = None
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}: {self.value}" + ("ACTIVE>" if self.generator else ">")
+        return f"<{self.__class__.__name__}: {self.value!r}" + (" ACTIVE>" if self.generator else ">")
 
     async def close(
         self,
@@ -117,11 +132,13 @@ class NodeSession:
 
 
 class NodeCollection:
+    __slots__ = ("sessions",)
+
     def __init__(self, sessions: dict[str, NodeSession]) -> None:
         self.sessions = sessions
 
     def __repr__(self) -> str:
-        return "<{}: sessions={}>".format(self.__class__.__name__, self.sessions)
+        return "<{}: sessions={!r}>".format(self.__class__.__name__, self.sessions)
 
     def values(self) -> dict[str, typing.Any]:
         return {name: session.value for name, session in self.sessions.items()}
@@ -135,26 +152,37 @@ class NodeCollection:
             await session.close(with_value, scopes=scopes)
 
 
+@dataclasses.dataclass(slots=True, repr=False)
 class Composition:
-    nodes: dict[str, type[Node]]
+    func: typing.Callable[..., typing.Any]
+    is_blocking: bool
+    node_class: type[Node] = dataclasses.field(default_factory=lambda: BaseNode)
+    nodes: dict[str, type[Node]] = dataclasses.field(init=False)
+    context_annotations: dict[str, typing.Any] = dataclasses.field(init=False)
 
-    def __init__(self, func: typing.Callable[..., typing.Any], is_blocking: bool) -> None:
-        self.func = func
-        self.nodes = get_annotations(func)
-        self.is_blocking = is_blocking
+    def __post_init__(self) -> None:
+        self.nodes = get_nodes(self.func)
+        self.context_annotations = get_compose_annotations(self.func)
 
     def __repr__(self) -> str:
-        return "<{}: for function={!r} with nodes={}>".format(
+        return "<{}: for function={!r} with nodes={!r}, context_annotations={!r}>".format(
             ("blocking " if self.is_blocking else "") + self.__class__.__name__,
-            self.func.__name__,
+            self.func.__qualname__,
             self.nodes,
+            self.context_annotations,
         )
 
     async def compose_nodes(self, update: UpdateCute, context: Context) -> NodeCollection | None:
-        return await compose_nodes(self.nodes, update, context)
+        return await compose_nodes(
+            update=update,
+            ctx=context,
+            nodes=self.nodes,
+            node_class=self.node_class,
+            context_annotations=self.context_annotations,
+        )
 
     async def __call__(self, **kwargs: typing.Any) -> typing.Any:
         return await self.func(**magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))  # type: ignore
 
 
-__all__ = ("NodeCollection", "NodeSession", "Composition", "compose_node", "compose_nodes")
+__all__ = ("Composition", "NodeCollection", "NodeSession", "compose_node", "compose_nodes")

telegrinder/node/container.py

@@ -1,17 +1,17 @@
 import typing
 
-from .base import Node
+from telegrinder.node.base import BaseNode, Node
 
 
-class ContainerNode(Node):
+class ContainerNode(BaseNode):
     linked_nodes: typing.ClassVar[list[type[Node]]]
 
     @classmethod
-    async def compose(cls, **kw) -> tuple["Node", ...]:
+    async def compose(cls, **kw) -> tuple[Node, ...]:
         return tuple(t[1] for t in sorted(kw.items(), key=lambda t: t[0]))
 
     @classmethod
-    def get_sub_nodes(cls) -> dict[str, type["Node"]]:
+    def get_sub_nodes(cls) -> dict[str, type[Node]]:
         return {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
 
     @classmethod

telegrinder/node/event.py

@@ -0,0 +1,59 @@
+import typing
+
+import msgspec
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.msgspec_utils import DataclassInstance
+from telegrinder.node.base import BaseNode, ComposeError, DataNode
+from telegrinder.node.update import UpdateNode
+
+if typing.TYPE_CHECKING:
+    Dataclass = typing.TypeVar("Dataclass", bound="DataclassType")
+
+    DataclassType: typing.TypeAlias = DataclassInstance | DataNode | msgspec.Struct | dict[str, typing.Any]
+
+EVENT_NODE_KEY = "_event_node"
+
+
+if typing.TYPE_CHECKING:
+    EventNode: typing.TypeAlias = typing.Annotated["Dataclass", ...]
+
+else:
+    from telegrinder.msgspec_utils import decoder
+
+    class EventNode(BaseNode):
+        dataclass: type["DataclassType"]
+
+        def __new__(cls, dataclass: type["DataclassType"], /) -> type[typing.Self]:
+            namespace = dict(**cls.__dict__)
+            namespace.pop("__new__", None)
+            new_cls = type("EventNode", (cls,), {"dataclass": dataclass, **namespace})
+            return new_cls  # type: ignore
+
+        def __class_getitem__(cls, dataclass: type["DataclassType"], /) -> type[typing.Self]:
+            return cls(dataclass)
+
+        @classmethod
+        async def compose(cls, raw_update: UpdateNode, ctx: Context) -> "DataclassType":
+            dataclass_type = typing.get_origin(cls.dataclass) or cls.dataclass
+
+            try:
+                if issubclass(dataclass_type, dict):
+                    dataclass = cls.dataclass(**raw_update.incoming_update.to_full_dict())
+
+                elif issubclass(dataclass_type, msgspec.Struct | DataclassInstance):
+                    dataclass = decoder.convert(
+                        raw_update.incoming_update.to_full_dict(),
+                        type=cls.dataclass,
+                    )
+
+                else:
+                    dataclass = cls.dataclass(**raw_update.incoming_update.to_dict())
+
+                ctx[EVENT_NODE_KEY] = cls
+                return dataclass
+            except Exception:
+                raise ComposeError(f"Cannot parse update to {cls.dataclass.__name__!r}.")
+
+
+__all__ = ("EventNode",)

telegrinder/node/me.py

@@ -12,3 +12,6 @@ class Me(ScalarNode, User):
     async def compose(cls, api: API) -> User:
         me = await api.get_me()
         return me.expect(ComposeError("Can't complete get_me request"))
+
+
+__all__ = ("Me",)

telegrinder/node/message.py

@@ -1,18 +1,14 @@
-from telegrinder.bot.cute_types import MessageCute
-
-from .base import ComposeError, ScalarNode
-from .update import UpdateNode
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.update import UpdateNode
 
 
 class MessageNode(ScalarNode, MessageCute):
     @classmethod
-    async def compose(cls, update: UpdateNode) -> "MessageNode":
+    async def compose(cls, update: UpdateNode) -> MessageCute:
         if not update.message:
-            raise ComposeError
-        return MessageNode(
-            **update.message.unwrap().to_dict(),
-            api=update.api,
-        )
+            raise ComposeError("Update is not a message.")
+        return update.message.unwrap()
 
 
 __all__ = ("MessageNode",)

telegrinder/node/polymorphic.py

@@ -2,38 +2,37 @@ import inspect
 import typing
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.tools.magic import get_impls, impl
+from telegrinder.node.base import BaseNode, ComposeError
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
+from telegrinder.node.scope import NodeScope
+from telegrinder.node.update import UpdateNode
+from telegrinder.tools.magic import IMPL_MARK, get_impls_by_key, impl
 
-from .base import ComposeError
-from .composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
-from .scope import NodeScope
-from .update import UpdateNode
 
-
-class Polymorphic:
+class Polymorphic(BaseNode):
     @classmethod
     async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
         scope = getattr(cls, "scope", None)
         node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
 
-        for i, impl in enumerate(get_impls(cls)):
-            composition = Composition(impl, True)
+        for i, impl in enumerate(get_impls_by_key(cls, IMPL_MARK).values()):
+            composition = Composition(impl, True, node_class=cls)
             node_collection = await composition.compose_nodes(update, context)
             if node_collection is None:
                 continue
 
             # 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:
-                result: NodeSession = node_ctx[(cls, i)]
+                res: NodeSession = node_ctx[(cls, i)]
                 await node_collection.close_all()
-                return result.value
+                return res.value
 
             result = composition.func(cls, **node_collection.values())
             if inspect.isawaitable(result):
                 result = await result
 
             if scope is NodeScope.PER_EVENT:
-                node_ctx[(cls, i)] = NodeSession(cls, result, {})  # type: ignore
+                node_ctx[(cls, i)] = NodeSession(cls, result, {})
 
             await node_collection.close_all(with_value=result)
             return result

telegrinder/node/rule.py

@@ -1,4 +1,5 @@
 import dataclasses
+import importlib
 import typing
 
 from telegrinder.bot.dispatch.context import Context
@@ -6,6 +7,7 @@ from telegrinder.node.base import ComposeError, Node
 from telegrinder.node.update import UpdateNode
 
 if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.process import check_rule
     from telegrinder.bot.rules.abc import ABCRule
 
 
@@ -13,7 +15,9 @@ class RuleChain(dict[str, typing.Any]):
     dataclass = dict
     rules: tuple["ABCRule", ...] = ()
 
-    def __init_subclass__(cls) -> None:
+    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
+        super().__init_subclass__(*args, **kwargs)
+
         if cls.__name__ == "_RuleNode":
             return
         cls.dataclass = cls.generate_node_dataclass(cls)
@@ -21,7 +25,7 @@ class RuleChain(dict[str, typing.Any]):
     def __new__(cls, *rules: "ABCRule") -> type[Node]:
         return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
 
-    def __class_getitem__(cls, items: typing.Union[tuple["ABCRule", ...], "ABCRule"]) -> typing.Self:
+    def __class_getitem__(cls, items: "ABCRule | tuple[ABCRule, ...]", /) -> typing.Self:
         if not isinstance(items, tuple):
             items = (items,)
         assert all(isinstance(rule, "ABCRule") for rule in items), "All items must be instances of 'ABCRule'."
@@ -32,13 +36,23 @@ class RuleChain(dict[str, typing.Any]):
         return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
 
     @classmethod
-    async def compose(cls, update: UpdateNode):
-        from telegrinder.bot.dispatch.process import check_rule
+    async def compose(cls, update: UpdateNode) -> typing.Any:
+        globalns = globals()
+        if "check_rule" not in globalns:
+            globalns.update(
+                {
+                    "check_rule": getattr(
+                        importlib.import_module("telegrinder.bot.dispatch.process"),
+                        "check_rule",
+                    ),
+                },
+            )
 
         ctx = Context()
         for rule in cls.rules:
             if not await check_rule(update.api, rule, update, ctx):
-                raise ComposeError
+                raise ComposeError(f"Rule {rule!r} failed!")
+
         try:
             return cls.dataclass(**ctx)  # type: ignore
         except Exception as exc:
@@ -52,6 +66,14 @@ class RuleChain(dict[str, typing.Any]):
     def get_sub_nodes(cls) -> dict:
         return {"update": UpdateNode}
 
+    @classmethod
+    def get_compose_annotations(cls) -> dict[str, typing.Any]:
+        return {}
+
+    @classmethod
+    def get_node_impls(cls) -> dict[str, typing.Callable[..., typing.Any]]:
+        return {}
+
     @classmethod
     def is_generator(cls) -> typing.Literal[False]:
         return False

telegrinder/node/source.py

@@ -1,18 +1,17 @@
 import dataclasses
 import typing
 
-from fntypes import Nothing, Option
+from fntypes.option import Nothing, Option
 
-from telegrinder.api import API
-from telegrinder.types import Chat, Message, User
+from telegrinder.api.api import API
+from telegrinder.node.base import ComposeError, DataNode, ScalarNode
+from telegrinder.node.callback_query import CallbackQueryNode
+from telegrinder.node.message import MessageNode
+from telegrinder.node.polymorphic import Polymorphic, impl
+from telegrinder.types.objects import Chat, Message, User
 
-from .base import ComposeError, DataNode, ScalarNode
-from .callback_query import CallbackQueryNode
-from .message import MessageNode
-from .polymorphic import Polymorphic, impl
 
-
-@dataclasses.dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True, slots=True)
 class Source(Polymorphic, DataNode):
     api: API
     chat: Chat
@@ -24,7 +23,7 @@ class Source(Polymorphic, DataNode):
         return cls(
             api=message.ctx_api,
             chat=message.chat,
-            from_user=message.from_user,
+            from_user=message.from_.expect(ComposeError("MessageNode has no from_user")),
             thread_id=message.message_thread_id,
         )
 
@@ -32,7 +31,7 @@ class Source(Polymorphic, DataNode):
     async def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
         return cls(
             api=callback_query.ctx_api,
-            chat=callback_query.chat.expect(ComposeError),
+            chat=callback_query.chat.expect(ComposeError("CallbackQueryNode has no chat")),
             from_user=callback_query.from_user,
             thread_id=callback_query.message_thread_id,
         )

telegrinder/node/text.py

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

telegrinder/node/update.py

@@ -1,6 +1,5 @@
 from telegrinder.bot.cute_types import UpdateCute
-
-from .base import ScalarNode
+from telegrinder.node.base import ScalarNode
 
 
 class UpdateNode(ScalarNode, UpdateCute):

telegrinder/tools/__init__.py

@@ -43,7 +43,7 @@ from .global_context import (
     CtxVar,
     GlobalContext,
     GlobalCtxVar,
-    TelegrinderCtx,
+    TelegrinderContext,
     ctx_var,
 )
 from .i18n import (
@@ -110,7 +110,7 @@ __all__ = (
     "SpecialFormat",
     "StartBotLink",
     "StartGroupLink",
-    "TelegrinderCtx",
+    "TelegrinderContext",
     "TgEmoji",
     "escape",
     "get_channel_boost_link",

telegrinder/tools/buttons.py

@@ -3,25 +3,20 @@ import typing
 
 import msgspec
 
-from telegrinder.model import encoder
-from telegrinder.types import (
+from telegrinder.msgspec_utils import DataclassInstance, encoder
+from telegrinder.types.objects import (
     CallbackGame,
     KeyboardButtonPollType,
     KeyboardButtonRequestChat,
     KeyboardButtonRequestUsers,
+    LoginUrl,
     SwitchInlineQueryChosenChat,
     WebAppInfo,
 )
-from telegrinder.types.objects import LoginUrl
 
 ButtonT = typing.TypeVar("ButtonT", bound="BaseButton")
 
 
-@typing.runtime_checkable
-class DataclassInstance(typing.Protocol):
-    __dataclass_fields__: typing.ClassVar[dict[str, dataclasses.Field[typing.Any]]]
-
-
 @dataclasses.dataclass
 class BaseButton:
     def get_data(self) -> dict[str, typing.Any]:
@@ -44,7 +39,7 @@ class RowButtons(typing.Generic[ButtonT]):
         return [b.get_data() for b in self.buttons]
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class Button(BaseButton):
     text: str
     request_contact: bool = dataclasses.field(default=False, kw_only=True)
@@ -61,7 +56,7 @@ class Button(BaseButton):
     web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class InlineButton(BaseButton):
     text: str
     url: str | None = dataclasses.field(default=None, kw_only=True)

telegrinder/tools/error_handler/error.py

@@ -1,4 +1,6 @@
 class CatcherError(BaseException):
+    __slots__ = ("exc", "message")
+
     def __init__(self, exc: BaseException, message: str) -> None:
         self.exc = exc
         self.message = message

telegrinder/tools/error_handler/error_handler.py

@@ -16,7 +16,7 @@ ExceptionT = typing.TypeVar("ExceptionT", bound=BaseException, contravariant=Tru
 FuncCatcher = typing.Callable[typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]]
 
 
-@dataclasses.dataclass(frozen=True, repr=False)
+@dataclasses.dataclass(frozen=True, repr=False, slots=True)
 class Catcher(typing.Generic[EventT]):
     func: FuncCatcher[BaseException]
     exceptions: list[type[BaseException] | BaseException] = dataclasses.field(