telegrinder 0.3.3.post1__py3-none-any.whl → 0.3.4.post1__py3-none-any.whl

telegrinder/node/tools/generator.py

@@ -1,40 +1,40 @@
-import inspect
-import typing
-
-from telegrinder.node.base import ComposeError, Node
-from telegrinder.node.container import ContainerNode
-
-T = typing.TypeVar("T")
-
-
-def cast_false_to_none(value: T) -> T | None:
-    if value is False:
-        return None
-    return value
-
-
-def error_on_none(value: T | None) -> T:
-    if value is None:
-        raise ComposeError
-    return value
-
-
-def generate_node(
-    subnodes: tuple[type[Node], ...],
-    func: typing.Callable[..., typing.Any],
-    casts: tuple[typing.Callable[[typing.Any], typing.Any], ...] = (cast_false_to_none, error_on_none),
-) -> type[Node]:
-    async def compose(cls, **kw) -> typing.Any:
-        result = func(*ContainerNode.compose(**kw))  # type: ignore
-        if inspect.isawaitable(result):
-            result = await result
-        for cast in casts:
-            result = cast(result)
-        return result
-
-    container = ContainerNode.link_nodes(list(subnodes))
-    compose.__annotations__ = container.get_subnodes()
-    return type("_ContainerNode", (container,), {"compose": classmethod(compose)})
-
-
-__all__ = ("generate_node",)
+import inspect
+import typing
+
+from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.container import ContainerNode
+
+T = typing.TypeVar("T")
+
+
+def cast_false_to_none(value: T) -> T | None:
+    if value is False:
+        return None
+    return value
+
+
+def error_on_none(value: T | None) -> T:
+    if value is None:
+        raise ComposeError
+    return value
+
+
+def generate_node(
+    subnodes: tuple[type[Node], ...],
+    func: typing.Callable[..., typing.Any],
+    casts: tuple[typing.Callable[[typing.Any], typing.Any], ...] = (cast_false_to_none, error_on_none),
+) -> type[Node]:
+    async def compose(cls, **kw) -> typing.Any:
+        result = func(*ContainerNode.compose(**kw))  # type: ignore
+        if inspect.isawaitable(result):
+            result = await result
+        for cast in casts:
+            result = cast(result)
+        return result
+
+    container = ContainerNode.link_nodes(list(subnodes))
+    compose.__annotations__ = container.get_subnodes()
+    return type("_ContainerNode", (container,), {"compose": classmethod(compose)})
+
+
+__all__ = ("generate_node",)

telegrinder/node/update.py

@@ -1,15 +1,15 @@
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types import UpdateCute
-from telegrinder.node.base import ScalarNode
-from telegrinder.types.objects import Update
-
-
-class UpdateNode(ScalarNode, UpdateCute):
-    @classmethod
-    def compose(cls, update: Update, api: API) -> UpdateCute:
-        if isinstance(update, UpdateCute):
-            return update
-        return UpdateCute.from_update(update, api)
-
-
-__all__ = ("UpdateNode",)
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types import UpdateCute
+from telegrinder.node.base import ScalarNode
+from telegrinder.types.objects import Update
+
+
+class UpdateNode(ScalarNode, UpdateCute):
+    @classmethod
+    def compose(cls, update: Update, api: API) -> UpdateCute:
+        if isinstance(update, UpdateCute):
+            return update
+        return UpdateCute.from_update(update, api)
+
+
+__all__ = ("UpdateNode",)

telegrinder/tools/__init__.py

@@ -1,75 +1,75 @@
-from .buttons import BaseButton
-from .error_handler import ABCErrorHandler, Catcher, CatcherError, ErrorHandler
-from .formatting import (
-    BaseSpecFormat,
-    ChannelBoostLink,
-    FormatString,
-    HTMLFormatter,
-    InviteChatLink,
-    Link,
-    Mention,
-    PreCode,
-    ResolveDomain,
-    SpecialFormat,
-    StartBotLink,
-    StartGroupLink,
-    TgEmoji,
-    block_quote,
-    bold,
-    channel_boost_link,
-    code_inline,
-    escape,
-    get_channel_boost_link,
-    get_invite_chat_link,
-    get_mention_link,
-    get_resolve_domain_link,
-    get_start_bot_link,
-    get_start_group_link,
-    invite_chat_link,
-    italic,
-    link,
-    mention,
-    pre_code,
-    resolve_domain,
-    spoiler,
-    start_bot_link,
-    start_group_link,
-    strike,
-    tg_emoji,
-    underline,
-)
-from .global_context import (
-    ABCGlobalContext,
-    CtxVar,
-    GlobalContext,
-    GlobalCtxVar,
-    TelegrinderContext,
-    ctx_var,
-)
-from .i18n import (
-    ABCI18n,
-    ABCTranslator,
-    ABCTranslatorMiddleware,
-    I18nEnum,
-    SimpleI18n,
-    SimpleTranslator,
-)
-from .kb_set import KeyboardSetBase, KeyboardSetYAML
-from .keyboard import (
-    AnyMarkup,
-    Button,
-    InlineButton,
-    InlineKeyboard,
-    Keyboard,
-    RowButtons,
-)
-from .limited_dict import LimitedDict
-from .loop_wrapper import ABCLoopWrapper, DelayedTask, Lifespan, LoopWrapper
-from .magic import impl, magic_bundle, resolve_arg_names
-from .parse_mode import ParseMode
-from .state_storage import ABCStateStorage, MemoryStateStorage, StateData
-
-__all__ = (
+from .buttons import BaseButton
+from .error_handler import ABCErrorHandler, Catcher, CatcherError, ErrorHandler
+from .formatting import (
+    BaseSpecFormat,
+    ChannelBoostLink,
+    FormatString,
+    HTMLFormatter,
+    InviteChatLink,
+    Link,
+    Mention,
+    PreCode,
+    ResolveDomain,
+    SpecialFormat,
+    StartBotLink,
+    StartGroupLink,
+    TgEmoji,
+    block_quote,
+    bold,
+    channel_boost_link,
+    code_inline,
+    escape,
+    get_channel_boost_link,
+    get_invite_chat_link,
+    get_mention_link,
+    get_resolve_domain_link,
+    get_start_bot_link,
+    get_start_group_link,
+    invite_chat_link,
+    italic,
+    link,
+    mention,
+    pre_code,
+    resolve_domain,
+    spoiler,
+    start_bot_link,
+    start_group_link,
+    strike,
+    tg_emoji,
+    underline,
+)
+from .global_context import (
+    ABCGlobalContext,
+    CtxVar,
+    GlobalContext,
+    GlobalCtxVar,
+    TelegrinderContext,
+    ctx_var,
+)
+from .i18n import (
+    ABCI18n,
+    ABCTranslator,
+    ABCTranslatorMiddleware,
+    I18nEnum,
+    SimpleI18n,
+    SimpleTranslator,
+)
+from .kb_set import KeyboardSetBase, KeyboardSetYAML
+from .keyboard import (
+    AnyMarkup,
+    Button,
+    InlineButton,
+    InlineKeyboard,
+    Keyboard,
+    RowButtons,
+)
+from .limited_dict import LimitedDict
+from .loop_wrapper import ABCLoopWrapper, DelayedTask, Lifespan, LoopWrapper
+from .magic import impl, magic_bundle, resolve_arg_names
+from .parse_mode import ParseMode
+from .state_storage import ABCStateStorage, MemoryStateStorage, StateData
+
+__all__ = (
     "ABCErrorHandler",
     "ABCGlobalContext",
     "ABCI18n",
@@ -142,5 +142,5 @@ __all__ = (
     "start_group_link",
     "strike",
     "tg_emoji",
-    "underline",
-)
+    "underline",
+)

telegrinder/tools/buttons.py

@@ -1,83 +1,83 @@
-import dataclasses
-import typing
-
-import msgspec
-
-from telegrinder.msgspec_utils import DataclassInstance, encoder
-from telegrinder.types.objects import (
-    CallbackGame,
-    KeyboardButtonPollType,
-    KeyboardButtonRequestChat,
-    KeyboardButtonRequestUsers,
-    LoginUrl,
-    SwitchInlineQueryChosenChat,
-    WebAppInfo,
-)
-
-KeyboardButton = typing.TypeVar("KeyboardButton", bound="BaseButton")
-
-
-@dataclasses.dataclass
-class BaseButton:
-    def get_data(self) -> dict[str, typing.Any]:
-        return {
-            k: v if k != "callback_data" or isinstance(v, str) else encoder.encode(v)
-            for k, v in dataclasses.asdict(self).items()
-            if v is not None
-        }
-
-
-class RowButtons(typing.Generic[KeyboardButton]):
-    buttons: list[KeyboardButton]
-    auto_row: bool
-
-    def __init__(self, *buttons: KeyboardButton, auto_row: bool = True) -> None:
-        self.buttons = list(buttons)
-        self.auto_row = auto_row
-
-    def get_data(self) -> list[dict[str, typing.Any]]:
-        return [b.get_data() for b in self.buttons]
-
-
-@dataclasses.dataclass(slots=True)
-class Button(BaseButton):
-    text: str
-    request_contact: bool = dataclasses.field(default=False, kw_only=True)
-    request_location: bool = dataclasses.field(default=False, kw_only=True)
-    request_chat: dict[str, typing.Any] | KeyboardButtonRequestChat | None = dataclasses.field(
-        default=None, kw_only=True
-    )
-    request_user: dict[str, typing.Any] | KeyboardButtonRequestUsers | None = dataclasses.field(
-        default=None, kw_only=True
-    )
-    request_poll: dict[str, typing.Any] | KeyboardButtonPollType | None = dataclasses.field(
-        default=None, kw_only=True
-    )
-    web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
-
-
-@dataclasses.dataclass(slots=True)
-class InlineButton(BaseButton):
-    text: str
-    url: str | None = dataclasses.field(default=None, kw_only=True)
-    login_url: dict[str, typing.Any] | LoginUrl | None = dataclasses.field(default=None, kw_only=True)
-    pay: bool | None = dataclasses.field(default=None, kw_only=True)
-    callback_data: str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct | None = (
-        dataclasses.field(default=None, kw_only=True)
-    )
-    callback_game: dict[str, typing.Any] | CallbackGame | None = dataclasses.field(default=None, kw_only=True)
-    switch_inline_query: str | None = dataclasses.field(default=None, kw_only=True)
-    switch_inline_query_current_chat: str | None = dataclasses.field(default=None, kw_only=True)
-    switch_inline_query_chosen_chat: dict[str, typing.Any] | SwitchInlineQueryChosenChat | None = (
-        dataclasses.field(default=None, kw_only=True)
-    )
-    web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
-
-
-__all__ = (
+import dataclasses
+import typing
+
+import msgspec
+
+from telegrinder.msgspec_utils import DataclassInstance, encoder
+from telegrinder.types.objects import (
+    CallbackGame,
+    KeyboardButtonPollType,
+    KeyboardButtonRequestChat,
+    KeyboardButtonRequestUsers,
+    LoginUrl,
+    SwitchInlineQueryChosenChat,
+    WebAppInfo,
+)
+
+KeyboardButton = typing.TypeVar("KeyboardButton", bound="BaseButton")
+
+
+@dataclasses.dataclass
+class BaseButton:
+    def get_data(self) -> dict[str, typing.Any]:
+        return {
+            k: v if k != "callback_data" or isinstance(v, str) else encoder.encode(v)
+            for k, v in dataclasses.asdict(self).items()
+            if v is not None
+        }
+
+
+class RowButtons(typing.Generic[KeyboardButton]):
+    buttons: list[KeyboardButton]
+    auto_row: bool
+
+    def __init__(self, *buttons: KeyboardButton, auto_row: bool = True) -> None:
+        self.buttons = list(buttons)
+        self.auto_row = auto_row
+
+    def get_data(self) -> list[dict[str, typing.Any]]:
+        return [b.get_data() for b in self.buttons]
+
+
+@dataclasses.dataclass(slots=True)
+class Button(BaseButton):
+    text: str
+    request_contact: bool = dataclasses.field(default=False, kw_only=True)
+    request_location: bool = dataclasses.field(default=False, kw_only=True)
+    request_chat: dict[str, typing.Any] | KeyboardButtonRequestChat | None = dataclasses.field(
+        default=None, kw_only=True
+    )
+    request_user: dict[str, typing.Any] | KeyboardButtonRequestUsers | None = dataclasses.field(
+        default=None, kw_only=True
+    )
+    request_poll: dict[str, typing.Any] | KeyboardButtonPollType | None = dataclasses.field(
+        default=None, kw_only=True
+    )
+    web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
+
+
+@dataclasses.dataclass(slots=True)
+class InlineButton(BaseButton):
+    text: str
+    url: str | None = dataclasses.field(default=None, kw_only=True)
+    login_url: dict[str, typing.Any] | LoginUrl | None = dataclasses.field(default=None, kw_only=True)
+    pay: bool | None = dataclasses.field(default=None, kw_only=True)
+    callback_data: str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct | None = (
+        dataclasses.field(default=None, kw_only=True)
+    )
+    callback_game: dict[str, typing.Any] | CallbackGame | None = dataclasses.field(default=None, kw_only=True)
+    switch_inline_query: str | None = dataclasses.field(default=None, kw_only=True)
+    switch_inline_query_current_chat: str | None = dataclasses.field(default=None, kw_only=True)
+    switch_inline_query_chosen_chat: dict[str, typing.Any] | SwitchInlineQueryChosenChat | None = (
+        dataclasses.field(default=None, kw_only=True)
+    )
+    web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
+
+
+__all__ = (
     "BaseButton",
     "Button",
     "DataclassInstance",
     "InlineButton",
-    "RowButtons",
-)
+    "RowButtons",
+)

telegrinder/tools/error_handler/__init__.py

@@ -1,10 +1,10 @@
-from .abc import ABCErrorHandler
-from .error import CatcherError
-from .error_handler import Catcher, ErrorHandler
-
-__all__ = (
+from .abc import ABCErrorHandler
+from .error import CatcherError
+from .error_handler import Catcher, ErrorHandler
+
+__all__ = (
     "ABCErrorHandler",
     "Catcher",
     "CatcherError",
-    "ErrorHandler",
-)
+    "ErrorHandler",
+)

telegrinder/tools/error_handler/abc.py

@@ -1,33 +1,33 @@
-import typing
-from abc import ABC, abstractmethod
-
-from fntypes.result import Result
-
-from telegrinder.api import API
-from telegrinder.bot.dispatch.context import Context
-
-Event = typing.TypeVar("Event")
-Handler = typing.Callable[..., typing.Awaitable[typing.Any]]
-
-
-class ABCErrorHandler(ABC, typing.Generic[Event]):
-    @abstractmethod
-    def __call__(
-        self,
-        *args: typing.Any,
-        **kwargs: typing.Any,
-    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
-        """Decorator for registering callback as a catcher for the error handler."""
-
-    @abstractmethod
-    async def run(
-        self,
-        handler: Handler,
-        event: Event,
-        api: API,
-        ctx: Context,
-    ) -> Result[typing.Any, typing.Any]:
-        """Run the error handler."""
-
-
-__all__ = ("ABCErrorHandler",)
+import typing
+from abc import ABC, abstractmethod
+
+from fntypes.result import Result
+
+from telegrinder.api import API
+from telegrinder.bot.dispatch.context import Context
+
+Event = typing.TypeVar("Event")
+Handler = typing.Callable[..., typing.Awaitable[typing.Any]]
+
+
+class ABCErrorHandler(ABC, typing.Generic[Event]):
+    @abstractmethod
+    def __call__(
+        self,
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
+        """Decorator for registering callback as a catcher for the error handler."""
+
+    @abstractmethod
+    async def run(
+        self,
+        handler: Handler,
+        event: Event,
+        api: API,
+        ctx: Context,
+    ) -> Result[typing.Any, typing.Any]:
+        """Run the error handler."""
+
+
+__all__ = ("ABCErrorHandler",)

telegrinder/tools/error_handler/error.py

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