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

telegrinder/rules.py

@@ -1 +1,60 @@
 from .bot.rules import *  # noqa: F403
+
+__all__ = (
+    "ABCRule",
+    "AndRule",
+    "Argument",
+    "CallbackDataEq",
+    "CallbackDataJsonEq",
+    "CallbackDataJsonModel",
+    "CallbackDataMap",
+    "CallbackDataMarkup",
+    "CallbackQueryDataRule",
+    "CallbackQueryRule",
+    "ChatJoinRequestRule",
+    "Command",
+    "EnumTextRule",
+    "FuncRule",
+    "FuzzyText",
+    "HasData",
+    "HasEntities",
+    "HasInviteLink",
+    "HasLocation",
+    "HasMention",
+    "HasText",
+    "InlineQueryChatType",
+    "InlineQueryMarkup",
+    "InlineQueryRule",
+    "InlineQueryText",
+    "IsInteger",
+    "IntegerInRange",
+    "InviteLinkByCreator",
+    "InviteLinkName",
+    "IsBot",
+    "IsChat",
+    "IsChatId",
+    "IsDice",
+    "IsDiceEmoji",
+    "IsForum",
+    "IsForward",
+    "IsForwardType",
+    "IsGroup",
+    "IsLanguageCode",
+    "IsPremium",
+    "IsPrivate",
+    "IsReply",
+    "IsSuperGroup",
+    "IsUpdateType",
+    "IsUser",
+    "IsUserId",
+    "Markup",
+    "MessageEntities",
+    "MessageRule",
+    "NotRule",
+    "OrRule",
+    "Regex",
+    "RuleEnum",
+    "StartCommand",
+    "Text",
+    "NodeRule",
+)

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/abc.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 
 from fntypes.result import Result
 
-from telegrinder.api import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 
 EventT = typing.TypeVar("EventT")
@@ -24,7 +24,7 @@ class ABCErrorHandler(ABC, typing.Generic[EventT]):
         self,
         handler: Handler[EventT],
         event: EventT,
-        api: ABCAPI,
+        api: API,
         ctx: Context,
     ) -> Result[typing.Any, typing.Any]:
         """Run error handler."""

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

@@ -3,7 +3,7 @@ import typing
 
 from fntypes.result import Error, Ok, Result
 
-from telegrinder.api import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
 from telegrinder.tools.magic import magic_bundle
@@ -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(
@@ -39,7 +39,7 @@ class Catcher(typing.Generic[EventT]):
         self,
         handler: Handler[EventT],
         event: EventT,
-        api: ABCAPI,
+        api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
         try:
@@ -49,7 +49,7 @@ class Catcher(typing.Generic[EventT]):
 
     async def process_exception(
         self,
-        api: ABCAPI,
+        api: API,
         event: EventT,
         ctx: Context,
         exception: BaseException,
@@ -125,7 +125,7 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         self,
         handler: Handler[EventT],
         event: EventT,
-        api: ABCAPI,
+        api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
         assert self.catcher is not None
@@ -159,7 +159,7 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         self,
         handler: Handler[EventT],
         event: EventT,
-        api: ABCAPI,
+        api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
         if not self.catcher:

telegrinder/tools/formatting/spec_html_formats.py

@@ -24,7 +24,7 @@ def is_spec_format(obj: typing.Any) -> typing.TypeGuard[SpecialFormat]:
     )
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class BaseSpecFormat:
     __formatter_name__: typing.ClassVar[str] = dataclasses.field(init=False, repr=False)
 
@@ -32,7 +32,7 @@ class BaseSpecFormat:
         return f"<Special formatter {self.__class__.__name__!r} -> {self.__formatter_name__!r}>"
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class ChannelBoostLink(BaseSpecFormat):
     __formatter_name__ = "channel_boost_link"
 
@@ -40,7 +40,7 @@ class ChannelBoostLink(BaseSpecFormat):
     string: str | None = None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class InviteChatLink(BaseSpecFormat):
     __formatter_name__ = "invite_chat_link"
 
@@ -48,7 +48,7 @@ class InviteChatLink(BaseSpecFormat):
     string: str | None = None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class Mention(BaseSpecFormat):
     __formatter_name__ = "mention"
 
@@ -56,7 +56,7 @@ class Mention(BaseSpecFormat):
     user_id: int
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class Link(BaseSpecFormat):
     __formatter_name__ = "link"
 
@@ -64,7 +64,7 @@ class Link(BaseSpecFormat):
     string: str | None = None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class PreCode(BaseSpecFormat):
     __formatter_name__ = "pre_code"
 
@@ -72,7 +72,7 @@ class PreCode(BaseSpecFormat):
     lang: str | ProgrammingLanguage | None = None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class TgEmoji(BaseSpecFormat):
     __formatter_name__ = "tg_emoji"
 
@@ -80,7 +80,7 @@ class TgEmoji(BaseSpecFormat):
     emoji_id: int
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class StartBotLink(BaseSpecFormat):
     __formatter_name__ = "start_bot_link"
 
@@ -89,7 +89,7 @@ class StartBotLink(BaseSpecFormat):
     string: str | None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class StartGroupLink(BaseSpecFormat):
     __formatter_name__ = "start_group_link"
 
@@ -98,7 +98,7 @@ class StartGroupLink(BaseSpecFormat):
     string: str | None = None
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class ResolveDomain(BaseSpecFormat):
     __formatter_name__ = "resolve_domain"
 

telegrinder/tools/global_context/__init__.py

@@ -1,12 +1,12 @@
 from .abc import ABCGlobalContext, CtxVar, GlobalCtxVar
 from .global_context import GlobalContext, ctx_var
-from .telegrinder_ctx import TelegrinderCtx
+from .telegrinder_ctx import TelegrinderContext
 
 __all__ = (
     "ABCGlobalContext",
     "CtxVar",
     "GlobalContext",
     "GlobalCtxVar",
-    "TelegrinderCtx",
+    "TelegrinderContext",
     "ctx_var",
 )

telegrinder/tools/global_context/global_context.py

@@ -81,7 +81,7 @@ def ctx_var(value: T, *, const: bool = False) -> T:
     return typing.cast(T, CtxVar(value, const=const))
 
 
-@dataclasses.dataclass(frozen=True, eq=False)
+@dataclasses.dataclass(frozen=True, eq=False, slots=True)
 class RootAttr:
     name: str
     can_be_read: bool = dataclasses.field(default=True, kw_only=True)
@@ -91,7 +91,7 @@ class RootAttr:
         return self.name == __value
 
 
-@dataclasses.dataclass(repr=False, frozen=True)
+@dataclasses.dataclass(repr=False, frozen=True, slots=True)
 class Storage:
     _storage: dict[str, "GlobalContext"] = dataclasses.field(
         default_factory=lambda: {},
@@ -334,7 +334,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
     def get(self, var_name, var_value_type=object):  # type: ignore
         """Get context variable by name."""
 
-        var_value_type = typing.Any if var_value_type is object else type
+        var_value_type = typing.Any if var_value_type is object else var_value_type
         generic_types = typing.get_args(get_orig_class(self))
         if generic_types and var_value_type is object:
             var_value_type = generic_types[0]

telegrinder/tools/global_context/telegrinder_ctx.py

@@ -5,14 +5,14 @@ import vbml
 from telegrinder.tools.global_context import GlobalContext, ctx_var
 
 
-class TelegrinderCtx(GlobalContext):
+class TelegrinderContext(GlobalContext):
     """Basic type-hinted telegrinder context with context name `"telegrinder"`.
 
     You can use this class or GlobalContext:
     ```
-    from telegrinder.tools.global_context import GlobalContext, TelegrinderCtx
+    from telegrinder.tools.global_context import GlobalContext, TelegrinderContext
 
-    ctx1 = TelegrinderCtx()
+    ctx1 = TelegrinderContext()
     ctx2 = GlobalContext("telegrinder")  # same, but without the type-hints
     assert ctx1 == ctx2  # ok
     ```"""
@@ -22,4 +22,4 @@ class TelegrinderCtx(GlobalContext):
     vbml_patcher: typing.ClassVar[vbml.Patcher] = ctx_var(vbml.Patcher(), const=True)
 
 
-__all__ = ("TelegrinderCtx",)
+__all__ = ("TelegrinderContext",)

telegrinder/tools/keyboard.py

@@ -17,7 +17,7 @@ DictStrAny: typing.TypeAlias = dict[str, typing.Any]
 AnyMarkup: typing.TypeAlias = InlineKeyboardMarkup | ReplyKeyboardMarkup
 
 
-@dataclasses.dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True, slots=True)
 class KeyboardModel:
     resize_keyboard: bool
     one_time_keyboard: bool
@@ -77,7 +77,7 @@ class ABCMarkup(ABC, typing.Generic[ButtonT]):
         return self
 
 
-@dataclasses.dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True, slots=True)
 class Keyboard(ABCMarkup[Button], KeyboardModel):
     BUTTON = Button
 
@@ -94,7 +94,7 @@ class Keyboard(ABCMarkup[Button], KeyboardModel):
         self.keyboard = [row for row in self.keyboard if row]
         return {
             k: v.unwrap() if v and isinstance(v, Some) else v
-            for k, v in self.__dict__.items()
+            for k, v in dataclasses.asdict(self).items()
             if type(v) not in (NoneType, Nothing)
         }
 

telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -1,6 +1,7 @@
 import asyncio
 import contextlib
 import dataclasses
+import datetime
 import typing
 
 from telegrinder.modules import logger
@@ -32,7 +33,7 @@ def to_coroutine_task(task: Task) -> CoroutineTask[typing.Any]:
     return task
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class DelayedTask(typing.Generic[CoroFunc]):
     handler: CoroFunc
     seconds: float
@@ -60,23 +61,23 @@ class DelayedTask(typing.Generic[CoroFunc]):
             self._cancelled = True
 
 
-@dataclasses.dataclass(kw_only=True)
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
 class Lifespan:
     startup_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
     shutdown_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
 
-    def on_startup(self, task_or_func: Task) -> Task:
-        self.startup_tasks.append(to_coroutine_task(task_or_func))
-        return task_or_func
+    def on_startup(self, task: Task, /) -> Task:
+        self.startup_tasks.append(to_coroutine_task(task))
+        return task
 
-    def on_shutdown(self, task_or_func: Task) -> Task:
-        self.shutdown_tasks.append(to_coroutine_task(task_or_func))
-        return task_or_func
+    def on_shutdown(self, task: Task, /) -> Task:
+        self.shutdown_tasks.append(to_coroutine_task(task))
+        return task
 
-    def start(self, loop: asyncio.AbstractEventLoop) -> None:
+    def start(self, loop: asyncio.AbstractEventLoop, /) -> None:
         run_tasks(self.startup_tasks, loop)
 
-    def shutdown(self, loop: asyncio.AbstractEventLoop) -> None:
+    def shutdown(self, loop: asyncio.AbstractEventLoop, /) -> None:
         run_tasks(self.shutdown_tasks, loop)
 
 
@@ -86,10 +87,11 @@ class LoopWrapper(ABCLoopWrapper):
         *,
         tasks: list[CoroutineTask[typing.Any]] | None = None,
         lifespan: Lifespan | None = None,
+        event_loop: asyncio.AbstractEventLoop | None = None,
     ) -> None:
         self.tasks: list[CoroutineTask[typing.Any]] = tasks or []
         self.lifespan = lifespan or Lifespan()
-        self._loop = asyncio.new_event_loop()
+        self._loop = event_loop or asyncio.new_event_loop()
 
     def __repr__(self) -> str:
         return "<{}: loop={!r} with tasks={!r}, lifespan={!r}>".format(
@@ -143,6 +145,10 @@ class LoopWrapper(ABCLoopWrapper):
         with contextlib.suppress(asyncio.CancelledError):
             self._loop.run_until_complete(task_to_cancel)
 
+    @typing.overload
+    def timer(self, *, seconds: datetime.timedelta) -> typing.Callable[..., typing.Any]: ...
+
+    @typing.overload
     def timer(
         self,
         *,
@@ -150,7 +156,19 @@ class LoopWrapper(ABCLoopWrapper):
         hours: int = 0,
         minutes: int = 0,
         seconds: float = 0,
-    ):
+    ) -> typing.Callable[..., typing.Any]: ...
+
+    def timer(
+        self,
+        *,
+        days: int = 0,
+        hours: int = 0,
+        minutes: int = 0,
+        seconds: float | datetime.timedelta = 0,
+    ) -> typing.Callable[..., typing.Any]:
+        if isinstance(seconds, datetime.timedelta):
+            seconds = seconds.total_seconds()
+
         seconds += minutes * 60
         seconds += hours * 60 * 60
         seconds += days * 24 * 60 * 60
@@ -161,6 +179,10 @@ class LoopWrapper(ABCLoopWrapper):
 
         return decorator
 
+    @typing.overload
+    def interval(self, *, seconds: datetime.timedelta) -> typing.Callable[..., typing.Any]: ...
+
+    @typing.overload
     def interval(
         self,
         *,
@@ -168,7 +190,19 @@ class LoopWrapper(ABCLoopWrapper):
         hours: int = 0,
         minutes: int = 0,
         seconds: float = 0,
-    ):
+    ) -> typing.Callable[..., typing.Any]: ...
+
+    def interval(
+        self,
+        *,
+        days: int = 0,
+        hours: int = 0,
+        minutes: int = 0,
+        seconds: float | datetime.timedelta = 0,
+    ) -> typing.Callable[..., typing.Any]:
+        if isinstance(seconds, datetime.timedelta):
+            seconds = seconds.total_seconds()
+
         seconds += minutes * 60
         seconds += hours * 60 * 60
         seconds += days * 24 * 60 * 60

telegrinder/tools/magic.py

@@ -2,11 +2,17 @@ import enum
 import inspect
 import types
 import typing
+from functools import wraps
 
 if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
+    from telegrinder.node.base import Node
 
     T = typing.TypeVar("T", bound=ABCRule)
+    F = typing.TypeVar(
+        "F",
+        bound=typing.Callable[typing.Concatenate[typing.Callable[..., typing.Any], ...], typing.Any],
+    )
 
 Impl: typing.TypeAlias = type[classmethod]
 FuncType: typing.TypeAlias = types.FunctionType | typing.Callable[..., typing.Any]
@@ -15,21 +21,36 @@ TRANSLATIONS_KEY: typing.Final[str] = "_translations"
 IMPL_MARK: typing.Final[str] = "_is_impl"
 
 
+def cache_magic_value(mark_key: str, /):
+    def inner(func: "F") -> "F":
+
+        @wraps(func)
+        def wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+            if mark_key not in args[0].__dict__:
+                args[0].__dict__[mark_key] = func(*args, **kwargs)
+            return args[0].__dict__[mark_key]
+
+        return wrapper  # type: ignore
+    return inner
+
+
 def resolve_arg_names(func: FuncType, start_idx: int = 1) -> tuple[str, ...]:
     return func.__code__.co_varnames[start_idx : func.__code__.co_argcount]
 
 
+@cache_magic_value("__default_args__")
 def get_default_args(func: FuncType) -> dict[str, typing.Any]:
     fspec = inspect.getfullargspec(func)
-    return dict(zip(fspec.args[::-1], (fspec.defaults or ())[::-1]))
+    if not fspec.defaults:
+        return {}
+    return dict(zip(fspec.args[-len(fspec.defaults):], fspec.defaults))
 
 
-def get_annotations(func: FuncType) -> dict[str, typing.Any]:
-    return {
-        name: parameter.annotation
-        for name, parameter in inspect.signature(func).parameters.items()
-        if parameter.annotation is not inspect._empty
-    }
+def get_annotations(func: FuncType, *, return_type: bool = False) -> dict[str, typing.Any]:
+    annotations = func.__annotations__
+    if not return_type and "return" in func.__annotations__:
+       annotations.pop("return")
+    return annotations
 
 
 def to_str(s: str | enum.Enum) -> str:
@@ -38,13 +59,64 @@ def to_str(s: str | enum.Enum) -> str:
     return s
 
 
+@typing.overload
+def magic_bundle(handler: FuncType, kw: dict[str, typing.Any]) -> dict[str, typing.Any]:
+    ...
+
+
+@typing.overload
+def magic_bundle(handler: FuncType, kw: dict[enum.Enum, typing.Any]) -> dict[str, typing.Any]:
+    ...
+
+
+@typing.overload
 def magic_bundle(
     handler: FuncType,
-    kw: dict[str | enum.Enum, typing.Any],
+    kw: dict[str, typing.Any],
     *,
     start_idx: int = 1,
     bundle_ctx: bool = True,
 ) -> dict[str, typing.Any]:
+    ...
+
+
+@typing.overload
+def magic_bundle(
+    handler: FuncType,
+    kw: dict[enum.Enum, typing.Any],
+    *,
+    start_idx: int = 1,
+    bundle_ctx: bool = True,
+) -> dict[str, typing.Any]:
+    ...
+
+
+@typing.overload
+def magic_bundle(
+    handler: FuncType,
+    kw: dict[type, typing.Any],
+    *,
+    typebundle: typing.Literal[True] = True,
+) -> dict[str, typing.Any]:
+    ...
+
+
+def magic_bundle(
+    handler: FuncType,
+    kw: dict[typing.Any, typing.Any],
+    *,
+    start_idx: int = 1,
+    bundle_ctx: bool = True,
+    typebundle: bool = False,
+) -> dict[str, typing.Any]:
+
+    if typebundle:
+        types = get_annotations(handler, return_type=False)
+        bundle: dict[str, typing.Any] = {}
+        for name, type in types.items():
+            bundle[name] = kw[type]
+        return bundle
+
     names = resolve_arg_names(handler, start_idx=start_idx)
     args = get_default_args(handler)
     args.update({to_str(k): v for k, v in kw.items() if to_str(k) in names})
@@ -59,30 +131,36 @@ def get_cached_translation(rule: "T", locale: str) -> "T | None":
 
 def cache_translation(base_rule: "T", locale: str, translated_rule: "T") -> None:
     translations = getattr(base_rule, TRANSLATIONS_KEY, {})
-    setattr(base_rule, TRANSLATIONS_KEY, {locale: translated_rule, **translations})
-
-
-def get_impls(cls: type[typing.Any]) -> list[typing.Callable[..., typing.Any]]:
-    functions = [func.__func__ for func in vars(cls).values() if isinstance(func, classmethod)]
-    return [impl for impl in functions if getattr(impl, IMPL_MARK, False) is True]
+    translations[locale] = translated_rule
+    setattr(base_rule, TRANSLATIONS_KEY, translations)
 
 
 @typing.cast(typing.Callable[..., Impl], lambda f: f)
 def impl(method: typing.Callable[..., typing.Any]):
-    bound_method = classmethod(method)
     setattr(method, IMPL_MARK, True)
-    return bound_method
+    return classmethod(method)
+
+
+def get_impls(cls: type["Node"]) -> list[typing.Callable[..., typing.Any]]:
+    return [
+        func.__func__
+        for func in vars(cls).values()
+        if isinstance(func, classmethod) and getattr(func.__func__, IMPL_MARK, False)
+    ]
+
 
 
 __all__ = (
     "TRANSLATIONS_KEY",
+    "cache_magic_value",
     "cache_translation",
+    "get_annotations",
     "get_cached_translation",
     "get_default_args",
     "get_default_args",
-    "magic_bundle",
     "impl",
+    "get_impls",
+    "magic_bundle",
     "resolve_arg_names",
     "to_str",
-    "get_annotations",
 )