telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/node/composer.py

@@ -5,100 +5,104 @@ import typing
 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
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
 from telegrinder.node.base import (
     ComposeError,
+    IsNode,
     Name,
-    Node,
+    NodeImpersonation,
     NodeScope,
-    get_node_calc_lst,
-    get_nodes,
+    NodeType,
+    unwrap_node,
 )
-from telegrinder.tools.magic import magic_bundle
+from telegrinder.tools.magic import join_dicts, magic_bundle
+
+type AsyncGenerator = typing.AsyncGenerator[typing.Any, None]
 
 CONTEXT_STORE_NODES_KEY = "_node_ctx"
 GLOBAL_VALUE_KEY = "_value"
 
 
+def get_scope(node: type[NodeType], /) -> NodeScope | None:
+    return getattr(node, "scope", None)
+
+
 async def compose_node(
-    _node: type[Node],
-    linked: dict[type, typing.Any],
+    node: type[NodeType],
+    linked: dict[type[typing.Any], typing.Any],
+    data: dict[type[typing.Any], typing.Any] | None = None,
 ) -> "NodeSession":
-    node = _node.as_node()
-    kwargs = magic_bundle(node.compose, linked, typebundle=True)
+    subnodes = node.get_subnodes()
+    kwargs = magic_bundle(node.compose, join_dicts(subnodes, linked))
+
+    # Linking data via typebundle
+    if data:
+        kwargs.update(magic_bundle(node.compose, data, typebundle=True))
 
     if node.is_generator():
-        generator = typing.cast(typing.AsyncGenerator[typing.Any, None], node.compose(**kwargs))
+        generator = typing.cast(AsyncGenerator, node.compose(**kwargs))
         value = await generator.asend(None)
     else:
         generator = None
-        value = typing.cast(typing.Awaitable[typing.Any] | typing.Any, node.compose(**kwargs))
+        value = node.compose(**kwargs)
         if inspect.isawaitable(value):
             value = await value
 
-    return NodeSession(_node, value, {}, generator)
+    return NodeSession(node, value, subnodes={}, generator=generator)
 
 
 async def compose_nodes(
-    nodes: dict[str, type[Node]],
+    nodes: typing.Mapping[str, IsNode | NodeImpersonation],
     ctx: Context,
     data: dict[type[typing.Any], typing.Any] | None = None,
 ) -> Result["NodeCollection", ComposeError]:
-    logger.debug("Composing nodes: {!r}...", nodes)
+    logger.debug("Composing nodes: ({})...", " ".join(f"{k}={v!r}" for k, v in nodes.items()))
 
-    local_nodes: dict[type[Node], NodeSession]
     data = {Context: ctx} | (data or {})
-    parent_nodes: dict[type[Node], NodeSession] = {}
-    event_nodes: dict[type[Node], NodeSession] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
-    # TODO: optimize flattened list calculation via caching key = tuple of node types
-    calculation_nodes: dict[tuple[str, type[Node]], tuple[type[Node], ...]] = {
-        (node_name, node_t): tuple(get_node_calc_lst(node_t)) for node_name, node_t in nodes.items()
-    }
-
-    for (parent_node_name, parent_node_t), linked_nodes in calculation_nodes.items():
-        local_nodes = {}
+    parent_nodes = dict[IsNode, NodeSession]()
+    event_nodes: dict[IsNode, NodeSession] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+    unwrapped_nodes = {(key, n := node.as_node()): unwrap_node(n) for key, node in nodes.items()}
+
+    for (parent_node_name, parent_node_t), linked_nodes in unwrapped_nodes.items():
+        local_nodes = dict[type[NodeType], NodeSession]()
         subnodes = {}
         data[Name] = parent_node_name
 
         for node_t in linked_nodes:
-            scope = getattr(node_t, "scope", None)
+            scope = get_scope(node_t)
 
             if scope is NodeScope.PER_EVENT and node_t in event_nodes:
                 local_nodes[node_t] = event_nodes[node_t]
                 continue
             elif scope is NodeScope.GLOBAL and hasattr(node_t, GLOBAL_VALUE_KEY):
-                local_nodes[node_t] = getattr(node_t, GLOBAL_VALUE_KEY)
+                local_nodes[node_t] = NodeSession(node_t, getattr(node_t, GLOBAL_VALUE_KEY), {})
                 continue
 
             subnodes |= {
                 k: session.value for k, session in (local_nodes | event_nodes).items() if k not in subnodes
             }
-
             try:
-                local_nodes[node_t] = await compose_node(node_t, subnodes | data)
+                local_nodes[node_t] = await compose_node(node_t, linked=subnodes, data=data)
             except (ComposeError, UnwrapError) as exc:
                 for t, local_node in local_nodes.items():
-                    if t.scope is NodeScope.PER_CALL:
+                    if get_scope(t) is NodeScope.PER_CALL:
                         await local_node.close()
-                return Error(ComposeError(f"Cannot compose {node_t}. Error: {exc}"))
+                return Error(ComposeError(f"Cannot compose {node_t!r}, error: {str(exc)}"))
 
             if scope is NodeScope.PER_EVENT:
                 event_nodes[node_t] = local_nodes[node_t]
             elif scope is NodeScope.GLOBAL:
-                setattr(node_t, GLOBAL_VALUE_KEY, local_nodes[node_t])
+                setattr(node_t, GLOBAL_VALUE_KEY, local_nodes[node_t].value)
 
         parent_nodes[parent_node_t] = local_nodes[parent_node_t]
 
-    node_sessions = {k: parent_nodes[t] for k, t in nodes.items()}
-    return Ok(NodeCollection(node_sessions))
+    return Ok(NodeCollection({k: parent_nodes[t] for k, t in unwrapped_nodes}))
 
 
 @dataclasses.dataclass(slots=True, repr=False)
 class NodeSession:
-    node_type: type[Node] | None
+    node_type: type[NodeType] | None
     value: typing.Any
     subnodes: dict[str, typing.Self]
     generator: typing.AsyncGenerator[typing.Any, typing.Any | None] | None = None
@@ -156,43 +160,4 @@ class NodeCollection:
             await session.close(with_value, scopes=scopes)
 
 
-@dataclasses.dataclass(slots=True, repr=False)
-class Composition:
-    func: typing.Callable[..., typing.Any]
-    is_blocking: bool
-    nodes: dict[str, type[Node]] = dataclasses.field(init=False)
-
-    def __post_init__(self) -> None:
-        self.nodes = get_nodes(self.func)
-
-    def __repr__(self) -> str:
-        return "<{}: for function={!r} with nodes={!r}>".format(
-            ("blocking " if self.is_blocking else "") + self.__class__.__name__,
-            self.func.__qualname__,
-            self.nodes,
-        )
-
-    async def compose_nodes(
-        self,
-        update: UpdateCute,
-        context: Context,
-    ) -> NodeCollection | None:
-        match await compose_nodes(
-            nodes=self.nodes,
-            ctx=context,
-            data={Update: update, API: update.api},
-        ):
-            case Ok(col):
-                return col
-            case Error(err):
-                logger.debug(f"Composition failed with error: {err!r}")
-                return None
-
-    async def __call__(self, node_cls: type[Node], **kwargs: typing.Any) -> typing.Any:
-        result = self.func(node_cls, **magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))
-        if inspect.isawaitable(result):
-            result = await result
-        return result
-
-
-__all__ = ("Composition", "NodeCollection", "NodeSession", "compose_node", "compose_nodes")
+__all__ = ("NodeCollection", "NodeSession", "compose_node", "compose_nodes")

telegrinder/node/container.py

@@ -1,17 +1,19 @@
 import typing
 
-from telegrinder.node.base import Node
+from telegrinder.node.base import IsNode, Node
 
 
 class ContainerNode(Node):
-    linked_nodes: typing.ClassVar[list[type[Node]]]
+    linked_nodes: typing.ClassVar[list[IsNode]]
+    composer: typing.Callable[..., typing.Awaitable[typing.Any]]
 
     @classmethod
-    def compose(cls, **kw) -> tuple[Node, ...]:
-        return tuple(t[1] for t in sorted(kw.items(), key=lambda t: t[0]))
+    async def compose(cls, **kw: typing.Any) -> typing.Any:
+        subnodes = cls.get_subnodes().keys()
+        return await cls.composer(*tuple(t[1] for t in sorted(kw.items(), key=lambda t: t[0]) if t[0] in subnodes))
 
     @classmethod
-    def get_subnodes(cls) -> dict[str, type[Node]]:
+    def get_subnodes(cls) -> dict[str, IsNode]:
         subnodes = getattr(cls, "subnodes", None)
         if subnodes is None:
             subnodes_dct = {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
@@ -20,8 +22,12 @@ class ContainerNode(Node):
         return subnodes
 
     @classmethod
-    def link_nodes(cls, linked_nodes: list[type[Node]]) -> type["ContainerNode"]:
-        return type("_ContainerNode", (cls,), {"linked_nodes": linked_nodes})
+    def link_nodes(
+        cls,
+        linked_nodes: list[IsNode],
+        composer: typing.Callable[..., typing.Awaitable[typing.Any]],
+    ) -> type["ContainerNode"]:
+        return type(cls.__name__, (cls,), {"linked_nodes": linked_nodes, "composer": classmethod(composer)})
 
 
 __all__ = ("ContainerNode",)

telegrinder/node/either.py

@@ -0,0 +1,82 @@
+import typing
+
+from fntypes.result import Ok
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.base import ComposeError, FactoryNode, Node
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, GLOBAL_VALUE_KEY, compose_node, compose_nodes
+from telegrinder.node.scope import NodeScope, per_call
+from telegrinder.types.objects import Update
+
+
+@per_call
+class _Either(FactoryNode):
+    """Represents a node that either to compose `left` or `right` nodes.
+
+    For example:
+    ```python
+    # ScalarNode `Integer` -> int
+    # ScalarNode `Float` -> float
+
+    Number = Either[Integer, Float]  # using a type alias just as an example
+
+    def number_to_int(number: Number) -> int:
+        return int(number)
+    ```
+    """
+
+    nodes: tuple[type[Node], type[Node] | None]
+
+    def __class_getitem__(cls, node: type[Node] | tuple[type[Node], type[Node]], /):
+        nodes = (node, None) if not isinstance(node, tuple) else node
+        assert len(nodes) == 2, "Node `Either` must have at least two nodes."
+        return cls(nodes=nodes)
+
+    @classmethod
+    async def compose(cls, api: API, update: Update, context: Context) -> typing.Any | None:
+        data = {API: api, Update: update, Context: context}
+        node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+
+        for node in cls.nodes:
+            if node is None:
+                return None
+
+            if node.scope is NodeScope.PER_EVENT and node in node_ctx:
+                return node_ctx[node].value
+            elif node.scope is NodeScope.GLOBAL and hasattr(node, GLOBAL_VALUE_KEY):
+                return getattr(node, GLOBAL_VALUE_KEY)
+
+            subnodes = node.as_node().get_subnodes()
+            match await compose_nodes(subnodes, context, data):
+                case Ok(col):
+                    try:
+                        session = await compose_node(
+                            node=node,
+                            linked={
+                                typing.cast(type, n): col.sessions[name].value for name, n in subnodes.items()
+                            },
+                            data=data,
+                        )
+                    except ComposeError:
+                        continue
+
+                    if node.scope is NodeScope.PER_EVENT:
+                        node_ctx[node] = session
+                    elif node.scope is NodeScope.GLOBAL:
+                        setattr(node, GLOBAL_VALUE_KEY, session.value)
+
+                    return session.value
+
+        raise ComposeError("Cannot compose either nodes: {}.".format(", ".join(repr(n) for n in cls.nodes)))
+
+
+if typing.TYPE_CHECKING:
+    type Either[Left, Right: typing.Any | None] = Left | Right
+    type Optional[Left] = Either[Left, None]
+else:
+    Either = _Either
+    Optional = type("Optional", (Either,), {})
+
+
+__all__ = ("Either", "Optional")

telegrinder/node/event.py

@@ -5,61 +5,50 @@ import msgspec
 
 from telegrinder.api.api import API
 from telegrinder.bot.cute_types import BaseCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.msgspec_utils import DataclassInstance, decoder
+from telegrinder.msgspec_utils import decoder
 from telegrinder.node.base import ComposeError, FactoryNode
-from telegrinder.node.update import UpdateNode
+from telegrinder.types.objects import Update
 
 if typing.TYPE_CHECKING:
-    Dataclass = typing.TypeVar("Dataclass", bound="DataclassType")
+    from _typeshed import DataclassInstance
 
-    DataclassType: typing.TypeAlias = DataclassInstance | msgspec.Struct | dict[str, typing.Any]
-
-EVENT_NODE_KEY = "_event_node"
+type DataclassType = DataclassInstance | msgspec.Struct | dict[str, typing.Any]
 
 
 class _EventNode(FactoryNode):
-    dataclass: type["DataclassType"]
+    dataclass: type[DataclassType]
+    orig_dataclass: type[DataclassType]
 
-    def __class_getitem__(cls, dataclass: type["DataclassType"], /) -> typing.Self:
-        return cls(dataclass=dataclass)
+    def __class_getitem__(cls, dataclass: type[DataclassType], /) -> typing.Self:
+        return cls(dataclass=dataclass, orig_dataclass=typing.get_origin(dataclass) or dataclass)
 
     @classmethod
-    def compose(cls, raw_update: UpdateNode, ctx: Context, api: API) -> "DataclassType":
-        dataclass_type = typing.get_origin(cls.dataclass) or cls.dataclass
-
+    def compose(cls, raw_update: Update, api: API) -> DataclassType:
         try:
-            if issubclass(dataclass_type, BaseCute):
-                if isinstance(raw_update.incoming_update, dataclass_type):
-                    dataclass = raw_update.incoming_update
-                else:
-                    dataclass = dataclass_type.from_update(raw_update.incoming_update, bound_api=api)
+            if issubclass(cls.orig_dataclass, BaseCute):
+                update = raw_update if issubclass(cls.orig_dataclass, Update) else raw_update.incoming_update
+                dataclass = cls.orig_dataclass.from_update(update=update, bound_api=api)
 
-            elif issubclass(dataclass_type, msgspec.Struct | dict) or dataclasses.is_dataclass(
-                dataclass_type
+            elif issubclass(cls.orig_dataclass, msgspec.Struct) or dataclasses.is_dataclass(
+                cls.orig_dataclass,
             ):
                 dataclass = decoder.convert(
-                    raw_update.incoming_update.to_full_dict(),
+                    obj=raw_update.incoming_update,
                     type=cls.dataclass,
-                    str_keys=True,
+                    from_attributes=True,
                 )
-
             else:
-                dataclass = cls.dataclass(**raw_update.incoming_update.to_dict())
+                dataclass = cls.dataclass(**raw_update.incoming_update.to_full_dict())
 
-            ctx[EVENT_NODE_KEY] = cls
             return dataclass
         except Exception as exc:
-            raise ComposeError(f"Cannot parse update into {cls.dataclass.__name__!r}, error: {str(exc)!r}")
+            raise ComposeError(f"Cannot parse an update object into {cls.dataclass!r}, error: {str(exc)}")
 
 
 if typing.TYPE_CHECKING:
-    EventNode: typing.TypeAlias = typing.Annotated["Dataclass", ...]
-
+    type EventNode[Dataclass: DataclassType] = Dataclass
 else:
-
-    class EventNode(_EventNode):
-        pass
+    EventNode = _EventNode
 
 
 __all__ = ("EventNode",)

telegrinder/node/file.py

@@ -0,0 +1,51 @@
+import typing
+
+import telegrinder.types as tg_types
+from telegrinder.api.api import API
+from telegrinder.node.attachment import Animation, Audio, Document, Photo, Video, VideoNote, Voice
+from telegrinder.node.base import FactoryNode
+
+type Attachment = Animation | Audio | Document | Photo | Video | VideoNote | Voice
+
+
+class _FileId(FactoryNode):
+    attachment_node: type[Attachment]
+
+    def __class_getitem__(cls, attachment_node: type[Attachment], /):
+        return cls(attachment_node=attachment_node)
+
+    @classmethod
+    def get_subnodes(cls):
+        return {"attach": cls.attachment_node}
+
+    @classmethod
+    def compose(cls, attach: Attachment) -> str:
+        if isinstance(attach, Photo):
+            return attach.sizes[-1].file_id
+        return attach.file_id
+
+
+class _File(FactoryNode):
+    attachment_node: type[Attachment]
+
+    def __class_getitem__(cls, attachment_node: type[Attachment], /):
+        return cls(attachment_node=attachment_node)
+
+    @classmethod
+    def get_subnodes(cls):
+        return {"file_id": _FileId[cls.attachment_node]}
+
+    @classmethod
+    async def compose(cls, file_id: str, api: API) -> tg_types.File:
+        return (await api.get_file(file_id=file_id)).expect("File can't be downloaded.")
+
+
+if typing.TYPE_CHECKING:
+    type FileId[T: Attachment] = str
+    type File[T: Attachment] = tg_types.File
+else:
+    FileId = _FileId
+    File = _File
+
+
+__all__ = ("File", "FileId")

telegrinder/node/me.py

@@ -1,16 +1,15 @@
 from telegrinder.api.api import API
-from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.base import ComposeError, scalar_node
 from telegrinder.node.scope import GLOBAL
 from telegrinder.types.objects import User
 
 
-class Me(ScalarNode, User):
-    scope = GLOBAL
-
+@scalar_node(scope=GLOBAL)
+class Me:
     @classmethod
     async def compose(cls, api: API) -> User:
         me = await api.get_me()
-        return me.expect(ComposeError("Can't complete get_me request"))
+        return me.expect(ComposeError("Can't complete api.get_me() request."))
 
 
 __all__ = ("Me",)

telegrinder/node/payload.py

@@ -0,0 +1,78 @@
+import dataclasses
+import typing
+
+from fntypes.result import Error, Ok
+
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
+from telegrinder.node.base import ComposeError, DataNode, FactoryNode, GlobalNode, scalar_node
+from telegrinder.node.polymorphic import Polymorphic, impl
+from telegrinder.tools.callback_data_serilization import ABCDataSerializer, JSONSerializer
+
+
+@scalar_node[str]
+class Payload(Polymorphic):
+    @impl
+    def compose_pre_checkout_query(cls, event: PreCheckoutQueryCute) -> str:
+        return event.invoice_payload
+
+    @impl
+    def compose_callback_query(cls, event: CallbackQueryCute) -> str:
+        return event.data.expect("CallbackQuery has no data.")
+
+    @impl
+    def compose_message(cls, event: MessageCute) -> str:
+        return event.successful_payment.map(
+            lambda payment: payment.invoice_payload,
+        ).expect("Message has no successful payment.")
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class PayloadSerializer[T: type[ABCDataSerializer[typing.Any]]](DataNode, GlobalNode[T]):
+    serializer: type[ABCDataSerializer[typing.Any]]
+
+    @classmethod
+    def compose(cls) -> typing.Self:
+        return cls(serializer=cls.get(default=JSONSerializer))
+
+
+class _PayloadData(FactoryNode):
+    data_type: type[typing.Any]
+    serializer: type[ABCDataSerializer[typing.Any]] | None = None
+
+    def __class_getitem__(
+        cls,
+        data_type: type[typing.Any] | tuple[type[typing.Any], type[ABCDataSerializer[typing.Any]]],
+        /,
+    ):
+        data_type, serializer = (data_type, None) if not isinstance(data_type, tuple) else data_type
+        return cls(data_type=data_type, serializer=serializer)
+
+    @classmethod
+    def compose(cls, payload: Payload, payload_serializer: PayloadSerializer) -> typing.Any:
+        serializer = cls.serializer or payload_serializer.serializer
+        match serializer(cls.data_type).deserialize(payload):
+            case Ok(value):
+                return value
+            case Error(err):
+                raise ComposeError(err)
+
+
+if typing.TYPE_CHECKING:
+    import typing_extensions
+
+    DataType = typing.TypeVar("DataType")
+    Serializer = typing_extensions.TypeVar(
+        "Serializer",
+        bound=ABCDataSerializer,
+        default=JSONSerializer[typing.Any],
+    )
+
+    type PayloadDataType[DataType, Serializer] = typing.Annotated[DataType, Serializer]
+    PayloadData: typing.TypeAlias = PayloadDataType[DataType, Serializer]
+else:
+    PayloadData = _PayloadData
+
+
+__all__ = ("Payload", "PayloadData", "PayloadSerializer")

telegrinder/node/polymorphic.py

@@ -1,25 +1,41 @@
+import inspect
 import typing
 
+from fntypes.result import Error, Ok
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
-from telegrinder.node.base import ComposeError, Node
-from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
+from telegrinder.node.base import ComposeError, Node, get_nodes
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, NodeSession, compose_nodes
 from telegrinder.node.scope import NodeScope
-from telegrinder.node.update import UpdateNode
-from telegrinder.tools.magic import get_impls, impl
+from telegrinder.tools.magic import get_impls, impl, magic_bundle
+from telegrinder.types.objects import Update
 
 
 class Polymorphic(Node):
     @classmethod
-    async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
+    async def compose(cls, raw_update: Update, update: UpdateCute, context: Context) -> typing.Any:
         logger.debug(f"Composing polymorphic node {cls.__name__!r}...")
         scope = getattr(cls, "scope", None)
         node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+        data = {
+            API: update.ctx_api,
+            Context: context,
+            Update: raw_update,
+        }
 
         for i, impl_ in enumerate(get_impls(cls)):
             logger.debug("Checking impl {!r}...", impl_.__name__)
-            composition = Composition(impl_, True)
-            node_collection = await composition.compose_nodes(update, context)
+            node_collection = None
+
+            match await compose_nodes(get_nodes(impl_), context, data=data):
+                case Ok(col):
+                    node_collection = col
+                case Error(err):
+                    logger.debug(f"Composition failed with error: {err!r}")
+
             if node_collection is None:
                 logger.debug("Impl {!r} composition failed!", impl_.__name__)
                 continue
@@ -34,7 +50,10 @@ class Polymorphic(Node):
                 await node_collection.close_all()
                 return res.value
 
-            result = await composition(cls, **node_collection.values)
+            result = impl_(cls, **node_collection.values | magic_bundle(impl_, data, typebundle=True))
+            if inspect.isawaitable(result):
+                result = await result
+
             if scope is NodeScope.PER_EVENT:
                 node_ctx[(cls, i)] = NodeSession(cls, result, {})
 

telegrinder/node/rule.py

@@ -2,9 +2,9 @@ import dataclasses
 import importlib
 import typing
 
+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.update import UpdateNode
 
 if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.process import check_rule
@@ -35,7 +35,7 @@ class RuleChain(dict[str, typing.Any], Node):
         return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
 
     @classmethod
-    async def compose(cls, update: UpdateNode) -> typing.Any:
+    async def compose(cls, update: UpdateCute) -> typing.Any:
         # Hack to avoid circular import
         globalns = globals()
         if "check_rule" not in globalns:
@@ -64,10 +64,6 @@ class RuleChain(dict[str, typing.Any], Node):
     def as_node(cls) -> type[typing.Self]:
         return cls
 
-    @classmethod
-    def get_subnodes(cls) -> dict[typing.Literal["update"], type[UpdateNode]]:
-        return {"update": UpdateNode}
-
     @classmethod
     def is_generator(cls) -> typing.Literal[False]:
         return False

telegrinder/node/scope.py

@@ -2,9 +2,7 @@ import enum
 import typing
 
 if typing.TYPE_CHECKING:
-    from .base import Node
-
-T = typing.TypeVar("T", bound=type["Node"])
+    from .base import IsNode
 
 
 class NodeScope(enum.Enum):
@@ -18,17 +16,17 @@ PER_CALL = NodeScope.PER_CALL
 GLOBAL = NodeScope.GLOBAL
 
 
-def per_call(node: T) -> T:
+def per_call[T: IsNode](node: type[T]) -> type[T]:
     setattr(node, "scope", PER_CALL)
     return node
 
 
-def per_event(node: T) -> T:
+def per_event[T: IsNode](node: type[T]) -> type[T]:
     setattr(node, "scope", PER_EVENT)
     return node
 
 
-def global_node(node: T) -> T:
+def global_node[T: IsNode](node: type[T]) -> type[T]:
     setattr(node, "scope", GLOBAL)
     return node