telegrinder 0.3.3.post1__tar.gz → 0.3.4__tar.gz

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.3.3.post1
+Version: 0.3.4
 Summary: Modern visionary telegram bot framework.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.3.3.post1"
+version = "0.3.4"
 description = "Modern visionary telegram bot framework."
 authors = ["timoniq <tesseradecades@mail.ru>"]
 maintainers = ["luwqz1 <howluwqz1@gmail.com>"]

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/cute_types/update.py

@@ -1,5 +1,4 @@
 import typing
-from functools import cached_property
 
 from fntypes.co import Nothing, Some
 
@@ -96,10 +95,6 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     """Optional. A request to join the chat has been sent. The bot must have the can_invite_users
     administrator right in the chat to receive these updates."""
 
-    @cached_property
-    def incoming_update(self) -> Model:
-        return getattr(self, self.update_type.value).unwrap()
-
     def get_event(self, event_model: type[EventModel]) -> Option[EventModel]:
         if isinstance(self.incoming_update, event_model):
             return Some(self.incoming_update)

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/dispatch/middleware/abc.py

@@ -3,11 +3,17 @@ from abc import ABC
 
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.model import Model
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.adapter.abc import ABCAdapter
 
 Event = typing.TypeVar("Event", bound=Model)
 
 
 class ABCMiddleware(ABC, typing.Generic[Event]):
+    adapter: "ABCAdapter[Update, Event] | None" = None
+
     async def pre(self, event: Event, ctx: Context) -> bool: ...
 
     async def post(self, event: Event, responses: list[typing.Any], ctx: Context) -> None: ...

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/dispatch/process.py

@@ -1,5 +1,7 @@
+import inspect
 import typing
 
+from fntypes.option import Nothing, Option, Some
 from fntypes.result import Error, Ok
 
 from telegrinder.api.api import API
@@ -16,10 +18,27 @@ from telegrinder.types.objects import Update
 if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.handler.abc import ABCHandler
     from telegrinder.bot.rules.abc import ABCRule
+    from telegrinder.bot.rules.adapter.abc import ABCAdapter
 
+T = typing.TypeVar("T")
 Event = typing.TypeVar("Event", bound=Model)
 
 
+async def run_adapter(
+    adapter: "ABCAdapter[Update, T]",
+    api: API,
+    update: Update,
+    context: Context,
+) -> Option[T]:
+    adapt_result = adapter.adapt(api, update, context)
+    match await adapt_result if inspect.isawaitable(adapt_result) else adapt_result:
+        case Ok(value):
+            return Some(value)
+        case Error(err):
+            logger.debug("Adapter failed with error message: {!r}", str(err))
+            return Nothing()
+
+
 async def process_inner(
     api: API,
     event: Event,
@@ -34,6 +53,13 @@ async def process_inner(
 
     logger.debug("Run pre middlewares...")
     for middleware in middlewares:
+        if middleware.adapter is not None:
+            match await run_adapter(middleware.adapter, api, raw_event, ctx):
+                case Some(val):
+                    event = val
+                case Nothing():
+                    return False
+
         middleware_result = await middleware.pre(event, ctx)
         logger.debug("Middleware {!r} returned: {!r}", middleware.__class__.__qualname__, middleware_result)
         if middleware_result is False:
@@ -83,11 +109,10 @@ async def check_rule(
     Returns check result."""
 
     # Running adapter
-    match await rule.adapter.adapt(api, update, ctx):
-        case Ok(value):
-            adapted_value = value
-        case Error(err):
-            logger.debug("Adapter failed with error message: {!r}", str(err))
+    match await run_adapter(rule.adapter, api, update, ctx):
+        case Some(val):
+            adapted_value = val
+        case Nothing():
             return False
 
     # Preparing update

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -45,6 +45,11 @@ class WaiterMachine:
             self.base_state_lifetime,
         )
 
+    def create_middleware(self, view: BaseStateView[EventModel]) -> WaiterMiddleware[EventModel]:
+        hasher = StateViewHasher(view)
+        self.storage[hasher] = LimitedDict(maxlimit=self.max_storage_size)
+        return WaiterMiddleware(self, hasher)
+
     async def drop_all(self) -> None:
         """Drops all waiters in storage."""
 

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/rules/abc.py

@@ -202,12 +202,12 @@ class Always(ABCRule):
 
 
 __all__ = (
-    "ABCRule",
-    "Always",
-    "AndRule",
-    "CheckResult",
-    "Never",
-    "NotRule",
-    "OrRule",
+    "ABCRule",
+    "Always",
+    "AndRule",
+    "CheckResult",
+    "Never",
+    "NotRule",
+    "OrRule",
     "with_caching_translations",
 )

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/rules/adapter/__init__.py

@@ -1,14 +1,17 @@
-from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
+from telegrinder.bot.rules.adapter.abc import ABCAdapter, AdaptResult, 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_event import RawEventAdapter
 from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
 
 __all__ = (
-    "ABCAdapter",
-    "AdapterError",
-    "Event",
-    "EventAdapter",
-    "NodeAdapter",
+    "ABCAdapter",
+    "AdaptResult",
+    "AdapterError",
+    "Event",
+    "EventAdapter",
+    "NodeAdapter",
+    "RawEventAdapter",
     "RawUpdateAdapter",
 )

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/rules/adapter/abc.py

@@ -12,12 +12,14 @@ from telegrinder.model import Model
 From = typing.TypeVar("From", bound=Model)
 To = typing.TypeVar("To")
 
+AdaptResult: typing.TypeAlias = Result[To, AdapterError] | typing.Awaitable[Result[To, AdapterError]]
+
 
 class ABCAdapter(abc.ABC, typing.Generic[From, To]):
     ADAPTED_VALUE_KEY: str | None = None
 
     @abc.abstractmethod
-    async def adapt(self, api: API, update: From, context: Context) -> Result[To, AdapterError]:
+    def adapt(self, api: API, update: From, context: Context) -> AdaptResult[To]:
         pass
 
 
@@ -26,4 +28,4 @@ class Event(typing.Generic[To]):
     obj: To
 
 
-__all__ = ("ABCAdapter", "Event")
+__all__ = ("ABCAdapter", "AdaptResult", "Event")

telegrinder-0.3.4/telegrinder/bot/rules/adapter/event.py

@@ -0,0 +1,65 @@
+import typing
+
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+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.bot.rules.adapter.raw_update import RawUpdateAdapter
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Model, Update
+
+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
+
+    def __repr__(self) -> str:
+        raw_update_type = (
+            f"Update -> {self.event.__name__}"
+            if isinstance(self.event, type)
+            else f"Update.{self.event.value}"
+        )
+        return "<{}: adapt {} -> {}>".format(
+            self.__class__.__name__,
+            raw_update_type,
+            self.cute_model.__name__,
+        )
+
+    def get_event(self, update: UpdateCute) -> Model | None:
+        if isinstance(self.event, UpdateType) and self.event == update.update_type:
+            return update.incoming_update
+
+        if not isinstance(self.event, UpdateType) and (event := update.get_event(self.event)):
+            return event.unwrap()
+
+        return None
+
+    def adapt(self, api: API, update: Update, context: Context) -> Result[ToCute, AdapterError]:
+        match RawUpdateAdapter().adapt(api, update, context):
+            case Ok(update_cute) if event := self.get_event(update_cute):
+                if self.ADAPTED_VALUE_KEY in context:
+                    return Ok(context[self.ADAPTED_VALUE_KEY])
+
+                adapted = (
+                    typing.cast(ToCute, event)
+                    if isinstance(event, BaseCute)
+                    else self.cute_model.from_update(event, bound_api=api)
+                )
+                context[self.ADAPTED_VALUE_KEY] = adapted
+                return Ok(adapted)
+            case Error(_) as err:
+                return err
+            case _:
+                return Error(AdapterError(f"Update is not an {self.event!r}."))
+
+
+__all__ = ("EventAdapter",)

telegrinder-0.3.4/telegrinder/bot/rules/adapter/raw_event.py

@@ -0,0 +1,27 @@
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.api import API
+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.model import Model
+from telegrinder.types.objects import Update
+
+
+class RawEventAdapter(ABCAdapter[Update, Model]):
+    def __init__(self, event_model: type[Model], /) -> None:
+        self.event_model = event_model
+
+    def __repr__(self) -> str:
+        return "<{}: adapt Update -> {}>".format(
+            self.__class__.__name__,
+            self.event_model.__name__,
+        )
+
+    def adapt(self, api: API, update: Update, context: Context) -> Result[Model, AdapterError]:
+        if isinstance(update.incoming_update, self.event_model):
+            return Ok(update.incoming_update)
+        return Error(AdapterError(f"Update is not an {self.event_model.__name__!r}."))
+
+
+__all__ = ("RawEventAdapter",)

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/rules/adapter/raw_update.py

@@ -14,7 +14,7 @@ class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
 
-    async def adapt(
+    def adapt(
         self,
         api: API,
         update: Update,

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/rules/callback_data.py

@@ -159,12 +159,12 @@ class CallbackDataMarkup(CallbackQueryDataRule):
 
 
 __all__ = (
-    "CallbackDataEq",
-    "CallbackDataJsonEq",
-    "CallbackDataJsonModel",
-    "CallbackDataMap",
-    "CallbackDataMarkup",
-    "CallbackQueryDataRule",
-    "CallbackQueryRule",
+    "CallbackDataEq",
+    "CallbackDataJsonEq",
+    "CallbackDataJsonModel",
+    "CallbackDataMap",
+    "CallbackDataMarkup",
+    "CallbackQueryDataRule",
+    "CallbackQueryRule",
     "HasData",
 )

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/rules/chat_join.py

@@ -39,8 +39,8 @@ class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
 
 
 __all__ = (
-    "ChatJoinRequestRule",
-    "HasInviteLink",
-    "InviteLinkByCreator",
+    "ChatJoinRequestRule",
+    "HasInviteLink",
+    "InviteLinkByCreator",
     "InviteLinkName",
 )

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/rules/inline.py

@@ -52,9 +52,9 @@ class InlineQueryMarkup(InlineQueryRule):
 
 
 __all__ = (
-    "HasLocation",
-    "InlineQueryChatType",
-    "InlineQueryMarkup",
-    "InlineQueryRule",
+    "HasLocation",
+    "InlineQueryChatType",
+    "InlineQueryMarkup",
+    "InlineQueryRule",
     "InlineQueryText",
 )

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/bot/scenario/checkbox.py

@@ -1,4 +1,5 @@
 import dataclasses
+import enum
 import secrets
 import typing
 
@@ -17,6 +18,11 @@ if typing.TYPE_CHECKING:
 Key = typing.TypeVar("Key", bound=typing.Hashable)
 
 
+class ChoiceCode(enum.StrEnum):
+    READY = "ready"
+    CANCEL = "cancel"
+
+
 @dataclasses.dataclass(slots=True)
 class Choice(typing.Generic[Key]):
     key: Key
@@ -79,10 +85,11 @@ class _Checkbox(ABCScenario[CallbackQueryCute]):
                 )
             kb.row()
 
-        kb.add(InlineButton(self.ready, callback_data=self.random_code + "/ready"))
+        kb.add(InlineButton(self.ready, callback_data=self.random_code + "/" + ChoiceCode.READY))
         if self.cancel_text is not None:
             kb.row()
-            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/cancel"))
+            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/" + ChoiceCode.CANCEL))
+
         return kb.get_markup()
 
     def add_option(
@@ -100,11 +107,13 @@ class _Checkbox(ABCScenario[CallbackQueryCute]):
 
     async def handle(self, cb: CallbackQueryCute) -> bool:
         code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
-        if code == "ready":
-            return False
-        elif code == "cancel":
-            self.choices = []
-            return False
+
+        match code:
+            case ChoiceCode.READY:
+                return False
+            case ChoiceCode.CANCEL:
+                self.choices = []
+                return False
 
         for i, choice in enumerate(self.choices):
             if choice.code == code:

telegrinder-0.3.4/telegrinder/bot/scenario/choice.py

@@ -0,0 +1,51 @@
+import typing
+
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
+from telegrinder.bot.scenario.checkbox import Checkbox, ChoiceCode
+
+if typing.TYPE_CHECKING:
+    from telegrinder.api.api import API
+    from telegrinder.bot.dispatch.view.base import BaseStateView
+    from telegrinder.bot.scenario.checkbox import Key
+
+    class Choice(Checkbox[Key], typing.Generic[Key]):
+        async def wait(
+            self,
+            hasher: Hasher[CallbackQueryCute, int],
+            api: API,
+            view: BaseStateView[CallbackQueryCute],
+        ) -> tuple[Key, int]: ...
+
+else:
+
+    class Choice(Checkbox):
+        async def handle(self, cb):
+            code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
+            if code == ChoiceCode.READY:
+                return False
+
+            for choice in self.choices:
+                choice.is_picked = False
+
+            for i, choice in enumerate(self.choices):
+                if choice.code == code:
+                    self.choices[i].is_picked = True
+                    await cb.ctx_api.edit_message_text(
+                        text=self.message,
+                        chat_id=cb.message.unwrap().v.chat.id,
+                        message_id=cb.message.unwrap().v.message_id,
+                        parse_mode=self.PARSE_MODE,
+                        reply_markup=self.get_markup(),
+                    )
+
+            return True
+
+        async def wait(self, hasher, api, view):
+            if len(tuple(choice for choice in self.choices if choice.is_picked)) != 1:
+                raise ValueError("Exactly one choice must be picked")
+            choices, m_id = await super().wait(hasher, api, view)
+            return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
+
+
+__all__ = ("Choice",)

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/model.py

@@ -1,6 +1,8 @@
+import base64
 import dataclasses
 import enum
 import keyword
+import os
 import secrets
 import typing
 from datetime import datetime
@@ -15,6 +17,7 @@ if typing.TYPE_CHECKING:
     from telegrinder.api.error import APIError
 
 T = typing.TypeVar("T")
+P = typing.ParamSpec("P")
 
 UnionType: typing.TypeAlias = typing.Annotated[tuple[T, ...], ...]
 
@@ -46,6 +49,15 @@ def full_result(
     return result.map(lambda v: decoder.decode(v, type=full_t))
 
 
+def generate_random_id(length_bytes: int) -> str:
+    if length_bytes < 1 or length_bytes > 64:
+        raise ValueError("Length of bytes must be between 1 and 64.")
+
+    random_bytes = os.urandom(length_bytes)
+    random_id = base64.urlsafe_b64encode(random_bytes).rstrip(b"=").decode("utf-8")
+    return random_id
+
+
 def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     validated_params = {}
     for k, v in (
@@ -60,10 +72,6 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     return validated_params
 
 
-class From(typing.Generic[T]):
-    def __new__(cls, _: T, /) -> typing.Any: ...
-
-
 if typing.TYPE_CHECKING:
 
     @typing.overload
@@ -72,6 +80,13 @@ if typing.TYPE_CHECKING:
     @typing.overload
     def field(*, default: typing.Any, name: str | None = ...) -> typing.Any: ...
 
+    @typing.overload
+    def field(
+        *,
+        default_factory: typing.Callable[[], typing.Any],
+        name: str | None = None,
+    ) -> typing.Any: ...
+
     @typing.overload
     def field(
         *,
@@ -102,9 +117,14 @@ if typing.TYPE_CHECKING:
         name=...,
         converter=...,
     ) -> typing.Any: ...
+
+    class From(typing.Generic[T]):
+        def __new__(cls, _: T, /) -> typing.Any: ...
 else:
     from msgspec import field as _field
 
+    From = typing.Annotated[T, ...]
+
     def field(**kwargs):
         kwargs.pop("converter", None)
         return _field(**kwargs)
@@ -113,12 +133,16 @@ else:
 @typing.dataclass_transform(field_specifiers=(field,))
 class Model(msgspec.Struct, **MODEL_CONFIG):
     @classmethod
-    def from_data(cls, data: dict[str, typing.Any]) -> typing.Self:
-        return decoder.convert(data, type=cls)
+    def from_data(cls: typing.Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+        return decoder.convert(msgspec.structs.asdict(cls(*args, **kwargs)), type=cls)  # type: ignore
+
+    @classmethod
+    def from_dict(cls, obj: dict[str, typing.Any], /) -> typing.Self:
+        return decoder.convert(obj, type=cls)
 
     @classmethod
-    def from_bytes(cls, data: bytes) -> typing.Self:
-        return decoder.decode(data, type=cls)
+    def from_bytes(cls, obj: bytes, /) -> typing.Self:
+        return decoder.decode(obj, type=cls)
 
     def _to_dict(
         self,
@@ -285,11 +309,12 @@ else:
 
 
 __all__ = (
-    "DataConverter",
-    "MODEL_CONFIG",
-    "Model",
-    "ProxiedDict",
-    "Proxy",
-    "full_result",
+    "DataConverter",
+    "MODEL_CONFIG",
+    "Model",
+    "ProxiedDict",
+    "Proxy",
+    "full_result",
+    "generate_random_id",
     "get_params",
 )

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/modules.py

@@ -36,8 +36,8 @@ class LoggerModule(typing.Protocol):
 
 logger: LoggerModule
 logging_level = os.getenv("LOGGER_LEVEL", default="DEBUG").upper()
-logging_module = choice_in_order(["loguru"], default="logging")
-asyncio_module = choice_in_order(["uvloop"], default="asyncio")
+logging_module = choice_in_order(["loguru"], default="logging", do_import=False)
+asyncio_module = choice_in_order(["uvloop"], default="asyncio", do_import=False)
 
 if logging_module == "loguru":
     import os

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/msgspec_utils.py

@@ -96,7 +96,7 @@ def msgspec_to_builtins(
 
 
 def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
-    if obj is None:
+    if obj is None or isinstance(obj, fntypes.Nothing):
         return Nothing
 
     (value_type,) = typing.get_args(tp) or (typing.Any,)

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/node/__init__.py

@@ -1,21 +1,21 @@
-from .attachment import Attachment, Audio, Photo, Video
-from .base import ComposeError, DataNode, Name, Node, ScalarNode, is_node
-from .callback_query import CallbackQueryData, CallbackQueryNode, Field
-from .command import CommandInfo
-from .composer import Composition, NodeCollection, NodeSession, compose_node, compose_nodes
-from .container import ContainerNode
-from .event import EventNode
-from .me import Me
-from .message import MessageNode
-from .polymorphic import Polymorphic, impl
-from .rule import RuleChain
-from .scope import GLOBAL, PER_CALL, PER_EVENT, NodeScope, global_node, per_call, per_event
-from .source import ChatSource, Source, UserSource
-from .text import Text, TextInteger, TextLiteral
-from .tools import generate_node
-from .update import UpdateNode
-
-__all__ = (
+from .attachment import Attachment, Audio, Photo, Video
+from .base import ComposeError, DataNode, Name, Node, ScalarNode, is_node
+from .callback_query import CallbackQueryData, CallbackQueryNode, Field
+from .command import CommandInfo
+from .composer import Composition, NodeCollection, NodeSession, compose_node, compose_nodes
+from .container import ContainerNode
+from .event import EventNode
+from .me import Me
+from .message import MessageNode
+from .polymorphic import Polymorphic, impl
+from .rule import RuleChain
+from .scope import GLOBAL, PER_CALL, PER_EVENT, NodeScope, global_node, per_call, per_event
+from .source import ChatSource, Source, UserSource
+from .text import Text, TextInteger, TextLiteral
+from .tools import generate_node
+from .update import UpdateNode
+
+__all__ = (
     "Attachment",
     "Audio",
     "CallbackQueryData",
@@ -56,5 +56,5 @@ __all__ = (
     "impl",
     "is_node",
     "per_call",
-    "per_event",
-)
+    "per_event",
+)

{telegrinder-0.3.3.post1 → telegrinder-0.3.4}/telegrinder/node/base.py

@@ -153,14 +153,14 @@ class Name(ScalarNode, str):
 
 
 __all__ = (
-    "ComposeError",
-    "FactoryNode",
-    "DataNode",
-    "Name",
-    "Node",
-    "SCALAR_NODE",
-    "ScalarNode",
-    "ScalarNodeProto",
-    "get_nodes",
+    "ComposeError",
+    "DataNode",
+    "FactoryNode",
+    "Name",
+    "Node",
+    "SCALAR_NODE",
+    "ScalarNode",
+    "ScalarNodeProto",
+    "get_nodes",
     "is_node",
 )