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

telegrinder/msgspec_utils.py

@@ -10,10 +10,16 @@ if typing.TYPE_CHECKING:
     from datetime import datetime
 
     from fntypes.option import Option
-    from fntypes.result import Result
+
+    def get_class_annotations(obj: typing.Any) -> dict[str, type[typing.Any]]: ...
+
+    def get_type_hints(obj: typing.Any) -> dict[str, type[typing.Any]]: ...
+
 else:
     from datetime import datetime as dt
 
+    from msgspec._utils import get_class_annotations, get_type_hints
+
     Value = typing.TypeVar("Value")
     Err = typing.TypeVar("Err")
 
@@ -23,16 +29,10 @@ else:
         def __instancecheck__(cls, __instance: typing.Any) -> bool:
             return isinstance(__instance, fntypes.option.Some | fntypes.option.Nothing)
 
-    class ResultMeta(type):
-        def __instancecheck__(cls, __instance: typing.Any) -> bool:
-            return isinstance(__instance, fntypes.result.Ok | fntypes.result.Error)
 
     class Option(typing.Generic[Value], metaclass=OptionMeta):
         pass
 
-    class Result(typing.Generic[Value, Err], metaclass=ResultMeta):
-        pass
-
 
 T = typing.TypeVar("T")
 
@@ -46,10 +46,29 @@ def get_origin(t: type[T]) -> type[T]:
     return typing.cast(T, typing.get_origin(t)) or t
 
 
-def repr_type(t: type) -> str:
+def repr_type(t: typing.Any) -> str:
     return getattr(t, "__name__", repr(get_origin(t)))
 
 
+def is_common_type(type_: typing.Any) -> typing.TypeGuard[type[typing.Any]]:
+    if not isinstance(type_, type):
+        return False
+    return (
+        type_ in (str, int, float, bool, None, Variative)
+        or issubclass(type_, msgspec.Struct)
+        or hasattr(type_, "__dataclass_fields__")
+    )
+
+
+def type_check(obj: typing.Any, t: typing.Any) -> bool:
+    return (
+        isinstance(obj, t)
+        if isinstance(t, type)
+        and issubclass(t, msgspec.Struct)
+        else type(obj) in t if isinstance(t, tuple) else type(obj) is t
+    )
+
+
 def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, str]:
     try:
         return Ok(decoder.convert(obj, type=t, strict=True))
@@ -68,72 +87,62 @@ def msgspec_to_builtins(
     str_keys: bool = False,
     builtin_types: typing.Iterable[type[typing.Any]] | None = None,
     order: typing.Literal["deterministic", "sorted"] | None = None,
-) -> typing.Any:
-    return encoder.to_builtins(**locals())
+) -> fntypes.result.Result[typing.Any, msgspec.ValidationError]:
+    try:
+        return Ok(encoder.to_builtins(**locals()))
+    except msgspec.ValidationError as exc:
+        return Error(exc)
 
 
 def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
-    orig_type = get_origin(tp)
-    (value_type,) = typing.get_args(tp) or (typing.Any,)
+    if obj is None:
+        return Nothing
 
-    if obj is None and orig_type in (fntypes.option.Nothing, Option):
-        return fntypes.option.Nothing()
-    return fntypes.option.Some(msgspec_convert(obj, value_type).unwrap())
-
-
-def result_dec_hook(
-    tp: type[Result[typing.Any, typing.Any]], obj: typing.Any
-) -> Result[typing.Any, typing.Any]:
-    if not isinstance(obj, dict):
-        raise TypeError(f"Cannot parse to Result object of type `{repr_type(type(obj))}`.")
-
-    orig_type = get_origin(tp)
-    (first_type, second_type) = (
-        typing.get_args(tp) + (typing.Any,) if len(typing.get_args(tp)) == 1 else typing.get_args(tp)
-    ) or (typing.Any, typing.Any)
+    (value_type,) = typing.get_args(tp) or (typing.Any,)
+    orig_value_type = typing.get_origin(value_type) or value_type
+    orig_obj = obj
 
-    if orig_type is Ok and "ok" in obj:
-        return Ok(msgspec_convert(obj["ok"], first_type).unwrap())
+    if not isinstance(orig_obj, dict | list) and is_common_type(orig_value_type):
+        if orig_value_type is Variative:
+            obj = value_type(orig_obj)  # type: ignore
+            orig_value_type = typing.get_args(value_type)
 
-    if orig_type is Error and "error" in obj:
-        return Error(msgspec_convert(obj["error"], first_type).unwrap())
+        if not type_check(orig_obj, orig_value_type):
+            raise TypeError(f"Expected `{repr_type(orig_value_type)}`, got `{repr_type(type(orig_obj))}`.")
 
-    if orig_type is Result:
-        match obj:
-            case {"ok": ok}:
-                return Ok(msgspec_convert(ok, first_type).unwrap())
-            case {"error": error}:
-                return Error(msgspec_convert(error, second_type).unwrap())
+        return fntypes.option.Some(obj)
 
-    raise msgspec.ValidationError(f"Cannot parse object `{obj!r}` to Result.")
+    return fntypes.option.Some(decoder.convert(orig_obj, type=value_type))
 
 
 def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
     union_types = typing.get_args(tp)
 
     if isinstance(obj, dict):
-        struct_fields_match_sums: dict[type[msgspec.Struct], int] = {
+        models_struct_fields: dict[type[msgspec.Struct], int] = {
             m: sum(1 for k in obj if k in m.__struct_fields__)
             for m in union_types
             if issubclass(get_origin(m), msgspec.Struct)
         }
-        union_types = tuple(t for t in union_types if t not in struct_fields_match_sums)
+        union_types = tuple(t for t in union_types if t not in models_struct_fields)
         reverse = False
 
-        if len(set(struct_fields_match_sums.values())) != len(struct_fields_match_sums.values()):
-            struct_fields_match_sums = {m: len(m.__struct_fields__) for m in struct_fields_match_sums}
+        if len(set(models_struct_fields.values())) != len(models_struct_fields.values()):
+            models_struct_fields = {m: len(m.__struct_fields__) for m in models_struct_fields}
             reverse = True
 
         union_types = (
             *sorted(
-                struct_fields_match_sums,
-                key=lambda k: struct_fields_match_sums[k],
+                models_struct_fields,
+                key=lambda k: models_struct_fields[k],
                 reverse=reverse,
             ),
             *union_types,
         )
 
     for t in union_types:
+        if not isinstance(obj, dict | list) and is_common_type(t) and type_check(obj, t):
+            return tp(obj)
         match msgspec_convert(obj, t):
             case Ok(value):
                 return tp(value)
@@ -179,12 +188,9 @@ class Decoder:
 
     def __init__(self) -> None:
         self.dec_hooks: dict[typing.Any, DecHook[typing.Any]] = {
-            Result: result_dec_hook,
             Option: option_dec_hook,
             Variative: variative_dec_hook,
             datetime: lambda t, obj: t.fromtimestamp(obj),
-            fntypes.result.Error: result_dec_hook,
-            fntypes.result.Ok: result_dec_hook,
             fntypes.option.Some: option_dec_hook,
             fntypes.option.Nothing: option_dec_hook,
         }
@@ -271,10 +277,6 @@ class Encoder:
         self.enc_hooks: dict[typing.Any, EncHook[typing.Any]] = {
             fntypes.option.Some: lambda opt: opt.value,
             fntypes.option.Nothing: lambda _: None,
-            fntypes.result.Ok: lambda ok: {"ok": ok.value},
-            fntypes.result.Error: lambda err: {
-                "error": (str(err.error) if isinstance(err.error, BaseException) else err.error)
-            },
             Variative: lambda variative: variative.v,
             datetime: lambda date: int(date.timestamp()),
         }
@@ -342,10 +344,8 @@ __all__ = (
     "datetime",
     "decoder",
     "encoder",
-    "get_origin",
     "msgspec_convert",
+    "get_class_annotations",
+    "get_type_hints",
     "msgspec_to_builtins",
-    "option_dec_hook",
-    "repr_type",
-    "variative_dec_hook",
 )

telegrinder/node/__init__.py

@@ -1,5 +1,5 @@
 from .attachment import Attachment, Audio, Photo, Video
-from .base import BaseNode, ComposeError, DataNode, Node, ScalarNode, is_node, node_impl
+from .base import ComposeError, DataNode, Node, ScalarNode, is_node
 from .callback_query import CallbackQueryNode
 from .command import CommandInfo
 from .composer import Composition, NodeCollection, NodeSession, compose_node, compose_nodes
@@ -18,7 +18,6 @@ from .update import UpdateNode
 __all__ = (
     "Attachment",
     "Audio",
-    "BaseNode",
     "CallbackQueryNode",
     "ChatSource",
     "CommandInfo",
@@ -52,7 +51,6 @@ __all__ = (
     "global_node",
     "impl",
     "is_node",
-    "node_impl",
     "per_call",
     "per_event",
 )

telegrinder/node/base.py

@@ -3,17 +3,10 @@ import inspect
 import typing
 from types import AsyncGeneratorType
 
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.node.scope import NodeScope
 from telegrinder.tools.magic import (
-    NODE_IMPL_MARK,
     cache_magic_value,
     get_annotations,
-    get_impls_by_key,
-    magic_bundle,
-    node_impl,
 )
 
 ComposeResult: typing.TypeAlias = typing.Awaitable[typing.Any] | typing.AsyncGenerator[typing.Any, None]
@@ -29,11 +22,6 @@ def is_node(maybe_node: type[typing.Any]) -> typing.TypeGuard[type["Node"]]:
     )
 
 
-@cache_magic_value("__compose_annotations__")
-def get_compose_annotations(function: typing.Callable[..., typing.Any]) -> dict[str, typing.Any]:
-    return {k: v for k, v in get_annotations(function).items() if not is_node(v)}
-
-
 @cache_magic_value("__nodes__")
 def get_nodes(function: typing.Callable[..., typing.Any]) -> dict[str, type["Node"]]:
     return {k: v for k, v in get_annotations(function).items() if is_node(v)}
@@ -44,23 +32,17 @@ def is_generator(function: typing.Callable[..., typing.Any]) -> typing.TypeGuard
     return inspect.isasyncgenfunction(function)
 
 
-def get_node_impls(node_cls: type["Node"]) -> dict[str, typing.Any]:
-    if not hasattr(node_cls, "__node_impls__"):
-        impls = get_impls_by_key(node_cls, NODE_IMPL_MARK)
-        if issubclass(node_cls, BaseNode):
-            impls |= get_impls_by_key(BaseNode, NODE_IMPL_MARK)
-        setattr(node_cls, "__node_impls__", impls)
-    return getattr(node_cls, "__node_impls__")
-
-
-def get_node_impl(
-    node: type[typing.Any],
-    node_impls: dict[str, typing.Callable[..., typing.Any]],
-) -> typing.Callable[..., typing.Any] | None:
-    for n_impl in node_impls.values():
-        if "return" in n_impl.__annotations__ and node is n_impl.__annotations__["return"]:
-            return n_impl
-    return None
+def get_node_calc_lst(node: type["Node"]) -> list[type["Node"]]:
+    """ Returns flattened list of node types in ordering required to calculate given node. Provides caching for passed node type """
+    if calc_lst := getattr(node, "__nodes_calc_lst__", None):
+        return calc_lst
+    nodes_lst: list[type["Node"]] = []
+    annotations = list(node.as_node().get_subnodes().values())
+    for node_type in annotations:
+        nodes_lst.extend(get_node_calc_lst(node_type))
+    calc_lst = [*nodes_lst, node]
+    setattr(node, "__nodes_calc_lst__", calc_lst)
+    return calc_lst
 
 
 class ComposeError(BaseException):
@@ -76,47 +58,14 @@ class Node(abc.ABC):
     def compose(cls, *args, **kwargs) -> ComposeResult:
         pass
 
-    @classmethod
-    async def compose_annotation(
-        cls,
-        annotation: typing.Any,
-        update: UpdateCute,
-        ctx: Context,
-    ) -> typing.Any:
-        orig_annotation: type[typing.Any] = typing.get_origin(annotation) or annotation
-        n_impl = get_node_impl(orig_annotation, cls.get_node_impls())
-        if n_impl is None:
-            raise ComposeError(f"Node implementation for {orig_annotation!r} not found.")
-
-        result = n_impl(
-            cls,
-            **magic_bundle(
-                n_impl,
-                {"update": update, "context": ctx},
-                start_idx=0,
-                bundle_ctx=False,
-            ),
-        )
-        if inspect.isawaitable(result):
-            return await result
-        return result
-
     @classmethod
     def compose_error(cls, error: str | None = None) -> typing.NoReturn:
         raise ComposeError(error)
 
     @classmethod
-    def get_sub_nodes(cls) -> dict[str, type["Node"]]:
+    def get_subnodes(cls) -> dict[str, type["Node"]]:
         return get_nodes(cls.compose)
 
-    @classmethod
-    def get_compose_annotations(cls) -> dict[str, typing.Any]:
-        return get_compose_annotations(cls.compose)
-
-    @classmethod
-    def get_node_impls(cls) -> dict[str, typing.Callable[..., typing.Any]]:
-        return get_node_impls(cls)
-
     @classmethod
     def as_node(cls) -> type[typing.Self]:
         return cls
@@ -126,26 +75,7 @@ class Node(abc.ABC):
         return is_generator(cls.compose)
 
 
-class BaseNode(Node, abc.ABC):
-    @classmethod
-    @abc.abstractmethod
-    def compose(cls, *args, **kwargs) -> ComposeResult:
-        pass
-
-    @node_impl
-    def compose_api(cls, update: UpdateCute) -> API:
-        return update.ctx_api
-
-    @node_impl
-    def compose_context(cls, context: Context) -> Context:
-        return context
-
-    @node_impl
-    def compose_update(cls, update: UpdateCute) -> UpdateCute:
-        return update
-
-
-class DataNode(BaseNode, abc.ABC):
+class DataNode(Node, abc.ABC):
     node = "data"
 
     @typing.dataclass_transform()
@@ -155,7 +85,7 @@ class DataNode(BaseNode, abc.ABC):
         pass
 
 
-class ScalarNodeProto(BaseNode, abc.ABC):
+class ScalarNodeProto(Node, abc.ABC):
     @classmethod
     @abc.abstractmethod
     async def compose(cls, *args, **kwargs) -> ComposeResult:
@@ -190,14 +120,12 @@ else:
 
 
 __all__ = (
-    "BaseNode",
     "ComposeError",
     "DataNode",
     "Node",
     "SCALAR_NODE",
     "ScalarNode",
     "ScalarNodeProto",
-    "get_compose_annotations",
     "get_nodes",
     "is_node",
 )

telegrinder/node/composer.py

@@ -1,105 +1,97 @@
 import dataclasses
 import typing
 
+from fntypes import Error, Ok, Result
 from fntypes.error import UnwrapError
 
-from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.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 (
-    BaseNode,
     ComposeError,
     Node,
     NodeScope,
-    get_compose_annotations,
+    get_node_calc_lst,
     get_nodes,
 )
 from telegrinder.tools.magic import magic_bundle
 
-CONTEXT_STORE_NODES_KEY = "node_ctx"
+CONTEXT_STORE_NODES_KEY = "_node_ctx"
+GLOBAL_VALUE_KEY = "_value"
 
 
 async def compose_node(
     _node: type[Node],
-    update: UpdateCute,
-    ctx: Context,
+    linked: dict[type, typing.Any],
 ) -> "NodeSession":
     node = _node.as_node()
-    context = NodeCollection({})
-    node_ctx: dict[type[Node], "NodeSession"] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
-
-    for name, subnode in node.get_sub_nodes().items():
-        if subnode in node_ctx:
-            context.sessions[name] = node_ctx[subnode]
-        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]
-
-    for name, annotation in node.get_compose_annotations().items():
-        context.sessions[name] = NodeSession(
-            None,
-            await node.compose_annotation(annotation, update, ctx),
-            {},
-        )
+    kwargs = magic_bundle(node.compose, linked, typebundle=True)
 
     if node.is_generator():
-        generator = typing.cast(typing.AsyncGenerator[typing.Any, None], node.compose(**context.values()))
+        generator = typing.cast(typing.AsyncGenerator[typing.Any, None], node.compose(**kwargs))
         value = await generator.asend(None)
     else:
         generator = None
-        value = await typing.cast(typing.Awaitable[typing.Any], node.compose(**context.values()))
+        value = await typing.cast(typing.Awaitable[typing.Any], node.compose(**kwargs))
 
-    return NodeSession(_node, value, context.sessions, generator)
+    return NodeSession(_node, value, {}, generator)
 
 
 async def compose_nodes(
-    update: UpdateCute,
-    ctx: Context,
     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, {})
-
-    try:
-        for name, node_t in nodes.items():
+    ctx: Context,
+    data: dict[type, typing.Any] | None = None,
+) -> Result["NodeCollection", ComposeError]:
+    logger.debug("Composing nodes: {!r}...", nodes)
+
+    parent_nodes: dict[type[Node], NodeSession] = {}
+    event_nodes: dict[type[Node], "NodeSession"] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+    data = {Context: ctx} | (data or {})
+
+    # Create flattened list of ordered nodes to be calculated
+    # TODO: optimize flattened list calculation via caching key = tuple of node types
+    calculation_nodes: list[list[type[Node]]] = []
+    for node_t in nodes.values():
+        calculation_nodes.append(get_node_calc_lst(node_t))
+
+    for linked_nodes in calculation_nodes:
+        local_nodes: dict[type[Node], "NodeSession"] = {}
+        for node_t in linked_nodes:
             scope = getattr(node_t, "scope", None)
 
-            if scope is NodeScope.PER_EVENT and node_t in node_ctx:
-                node_sessions[name] = node_ctx[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, "_value"):
-                node_sessions[name] = getattr(node_t, "_value")
+            elif scope is NodeScope.GLOBAL and hasattr(node_t, GLOBAL_VALUE_KEY):
+                local_nodes[node_t] = getattr(node_t, GLOBAL_VALUE_KEY)
                 continue
 
-            node_sessions[name] = await compose_node(node_t, update, ctx)
+            subnodes = {
+                k: session.value
+                for k, session in
+                (local_nodes | event_nodes).items()
+            }
+
+            try:
+                local_nodes[node_t] = await compose_node(node_t, subnodes | data)
+            except (ComposeError, UnwrapError) as exc:
+                for t, local_node in local_nodes.items():
+                    if t.scope is NodeScope.PER_CALL:
+                        await local_node.close()
+                return Error(ComposeError(f"Cannot compose {node_t}. Error: {exc}"))
 
             if scope is NodeScope.PER_EVENT:
-                node_ctx[node_t] = node_sessions[name]
+                event_nodes[node_t] = local_nodes[node_t]
             elif scope is NodeScope.GLOBAL:
-                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
+                setattr(node_t, GLOBAL_VALUE_KEY, local_nodes[node_t])
 
-    if context_annotations:
-        node_class = node_class or BaseNode
+        # Last node is the parent node
+        parent_node_t = linked_nodes[-1]
+        parent_nodes[parent_node_t] = local_nodes[parent_node_t]
 
-        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(node_sessions)
+    node_sessions = {k: parent_nodes[t] for k, t in nodes.items()}
+    return Ok(NodeCollection(node_sessions))
 
 
 @dataclasses.dataclass(slots=True, repr=False)
@@ -107,7 +99,7 @@ class NodeSession:
     node_type: type[Node] | None
     value: typing.Any
     subnodes: dict[str, typing.Self]
-    generator: typing.AsyncGenerator[typing.Any, None] | None = None
+    generator: typing.AsyncGenerator[typing.Any, typing.Any | None] | None = None
 
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}: {self.value!r}" + (" ACTIVE>" if self.generator else ">")
@@ -126,6 +118,7 @@ class NodeSession:
         if self.generator is None:
             return
         try:
+            logger.debug("Closing session for node {!r}...", self.node_type)
             await self.generator.asend(with_value)
         except StopAsyncIteration:
             self.generator = None
@@ -140,6 +133,7 @@ class NodeCollection:
     def __repr__(self) -> str:
         return "<{}: sessions={!r}>".format(self.__class__.__name__, self.sessions)
 
+    @property
     def values(self) -> dict[str, typing.Any]:
         return {name: session.value for name, session in self.sessions.items()}
 
@@ -156,30 +150,33 @@ class NodeCollection:
 class Composition:
     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 __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={!r}, context_annotations={!r}>".format(
+        return "<{}: for function={!r} with nodes={!r}>".format(
             ("blocking " if self.is_blocking else "") + self.__class__.__name__,
             self.func.__qualname__,
             self.nodes,
-            self.context_annotations,
         )
 
-    async def compose_nodes(self, update: UpdateCute, context: Context) -> NodeCollection | None:
-        return await compose_nodes(
-            update=update,
-            ctx=context,
+    async def compose_nodes(
+        self,
+        update: UpdateCute,
+        context: Context,
+    ) -> NodeCollection | None:
+        match await compose_nodes(
             nodes=self.nodes,
-            node_class=self.node_class,
-            context_annotations=self.context_annotations,
-        )
+            ctx=context,
+            data={Update: update, API: update.api},
+        ):
+            case Ok(col):
+                return col
+            case Error(err):
+                logger.debug(f"Composition failed with error: {err}")
+                return None
 
     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

telegrinder/node/container.py

@@ -1,9 +1,9 @@
 import typing
 
-from telegrinder.node.base import BaseNode, Node
+from telegrinder.node.base import Node
 
 
-class ContainerNode(BaseNode):
+class ContainerNode(Node):
     linked_nodes: typing.ClassVar[list[type[Node]]]
 
     @classmethod
@@ -11,7 +11,7 @@ class ContainerNode(BaseNode):
         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_subnodes(cls) -> dict[str, type[Node]]:
         return {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
 
     @classmethod