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

telegrinder/node/text.py

@@ -1,41 +1,53 @@
-import typing
-
-from telegrinder.node.base import ComposeError, FactoryNode, ScalarNode
-from telegrinder.node.message import MessageNode
-
-
-class Text(ScalarNode, str):
-    @classmethod
-    def compose(cls, message: MessageNode) -> str:
-        if not message.text:
-            raise ComposeError("Message has no text.")
-        return message.text.unwrap()
-
-
-class TextInteger(ScalarNode, int):
-    @classmethod
-    def compose(cls, text: Text) -> int:
-        if not text.isdigit():
-            raise ComposeError("Text is not digit.")
-        return int(text)
-
-
-if typing.TYPE_CHECKING:
-    from typing import Literal as TextLiteral
-
-else:
-
-    class TextLiteral(FactoryNode):
-        texts: tuple[str, ...]
-
-        def __class_getitem__(cls, texts, /):
-            return cls(texts=(texts,) if not isinstance(texts, tuple) else texts)
-
-        @classmethod
-        def compose(cls, text: Text) -> str:
-            if text in cls.texts:
-                return text
-            raise ComposeError("Text matching failed.")
-
-
-__all__ = ("Text", "TextInteger", "TextLiteral")
+import typing
+
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.node.base import ComposeError, FactoryNode, scalar_node
+from telegrinder.node.either import Either
+
+
+@scalar_node
+class Caption:
+    @classmethod
+    def compose(cls, message: MessageCute) -> str:
+        if not message.caption:
+            raise ComposeError("Message has no caption.")
+        return message.caption.unwrap()
+
+
+@scalar_node
+class Text:
+    @classmethod
+    def compose(cls, message: MessageCute) -> str:
+        if not message.text:
+            raise ComposeError("Message has no text.")
+        return message.text.unwrap()
+
+
+@scalar_node
+class TextInteger:
+    @classmethod
+    def compose(cls, text: Either[Text, Caption]) -> int:
+        if not text.isdigit():
+            raise ComposeError("Text is not digit.")
+        return int(text)
+
+
+if typing.TYPE_CHECKING:
+    from typing import Literal as TextLiteral
+
+else:
+
+    class TextLiteral(FactoryNode):
+        texts: tuple[str, ...]
+
+        def __class_getitem__(cls, texts, /):
+            return cls(texts=(texts,) if not isinstance(texts, tuple) else texts)
+
+        @classmethod
+        def compose(cls, text: Text) -> str:
+            if text in cls.texts:
+                return text
+            raise ComposeError("Text mismatched literal.")
+
+
+__all__ = ("Caption", "Text", "TextInteger", "TextLiteral")

telegrinder/node/tools/__init__.py

@@ -1,3 +1,3 @@
-from .generator import generate_node
-
-__all__ = ("generate_node",)
+from .generator import generate_node
+
+__all__ = ("generate_node",)

telegrinder/node/tools/generator.py

@@ -1,40 +1,36 @@
-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, IsNode, Node
+from telegrinder.node.container import ContainerNode
+
+
+def cast_false_to_none[Value](value: Value) -> Value | None:
+    if value is False:
+        return None
+    return value
+
+
+def error_on_none[Value](value: Value | None) -> Value:
+    if value is None:
+        raise ComposeError
+    return value
+
+
+def generate_node(
+    subnodes: tuple[IsNode, ...],
+    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, *args: typing.Any) -> typing.Any:
+        result = func(*args)
+        if inspect.isawaitable(result):
+            result = await result
+        for cast in casts:
+            result = cast(result)
+        return result
+
+    return ContainerNode.link_nodes(linked_nodes=list(subnodes), composer=compose)
+
+
+__all__ = ("generate_node",)

telegrinder/rules.py

@@ -1,62 +1 @@
-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",
-    "IntegerInRange",
-    "InviteLinkByCreator",
-    "InviteLinkName",
-    "IsBot",
-    "IsChat",
-    "IsChatId",
-    "IsDice",
-    "IsDiceEmoji",
-    "IsForum",
-    "IsForward",
-    "IsForwardType",
-    "IsGroup",
-    "IsInteger",
-    "IsLanguageCode",
-    "IsPremium",
-    "IsPrivate",
-    "IsReply",
-    "IsSuperGroup",
-    "IsUpdateType",
-    "IsUser",
-    "IsUserId",
-    "Markup",
-    "MessageEntities",
-    "MessageRule",
-    "NodeRule",
-    "NotRule",
-    "OrRule",
-    "Regex",
-    "RuleEnum",
-    "StartCommand",
-    "State",
-    "StateMeta",
-    "Text",
-)
+from .bot.rules import *  # noqa: F403

telegrinder/tools/__init__.py

@@ -1,75 +1,111 @@
-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 .adapter import (
+    ABCAdapter,
+    DataclassAdapter,
+    EventAdapter,
+    NodeAdapter,
+    RawEventAdapter,
+    RawUpdateAdapter,
+)
+from .buttons import BaseButton
+from .callback_data_serilization import (
+    ABCDataSerializer,
+    JSONSerializer,
+    MsgPackSerializer,
+)
+from .error_handler import ABCErrorHandler, Catcher, CatcherError, ErrorHandler
+from .formatting import (
+    Base,
+    BlockQuote,
+    FormatString,
+    HTMLFormatter,
+    Link,
+    Mention,
+    PreCode,
+    SpecialFormat,
+    TgEmoji,
+    block_quote,
+    bold,
+    code_inline,
+    escape,
+    italic,
+    link,
+    mention,
+    pre_code,
+    spoiler,
+    strike,
+    tg_bot_attach_open_any_chat,
+    tg_bot_attach_open_current_chat,
+    tg_bot_attach_open_specific_chat,
+    tg_bot_start_link,
+    tg_bot_startchannel_link,
+    tg_bot_startgroup_link,
+    tg_chat_folder_link,
+    tg_chat_invite_link,
+    tg_direct_mini_app_link,
+    tg_emoji,
+    tg_emoji_link,
+    tg_emoji_stickerset_link,
+    tg_invoice_link,
+    tg_language_pack_link,
+    tg_main_mini_app_link,
+    tg_mention_link,
+    tg_open_message_link,
+    tg_premium_multigift_link,
+    tg_premium_offer_link,
+    tg_private_channel_boost_link,
+    tg_private_message_link,
+    tg_public_channel_boost_link,
+    tg_public_message_link,
+    tg_public_username_link,
+    tg_share_link,
+    tg_story_link,
+    underline,
+)
+from .functional import from_optional
+from .global_context import (
+    ABCGlobalContext,
+    CtxVar,
+    GlobalContext,
+    GlobalCtxVar,
+    TelegrinderContext,
+    ctx_var,
+)
+from .i18n import (
+    ABCI18n,
+    ABCTranslator,
+    ABCTranslatorMiddleware,
+    I18nEnum,
+    SimpleI18n,
+    SimpleTranslator,
+)
+from .input_file_directory import InputFileDirectory
+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 (
+    cancel_future,
+    get_annotations,
+    get_cached_translation,
+    get_default_args,
+    get_func_parameters,
+    get_impls,
+    impl,
+    magic_bundle,
+    resolve_arg_names,
+)
+from .parse_mode import ParseMode
+from .state_storage import ABCStateStorage, MemoryStateStorage, StateData
+
+__all__ = (
+    "ABCAdapter",
+    "ABCDataSerializer",
     "ABCErrorHandler",
     "ABCGlobalContext",
     "ABCI18n",
@@ -78,15 +114,17 @@ __all__ = (
     "ABCTranslator",
     "ABCTranslatorMiddleware",
     "AnyMarkup",
+    "Base",
     "BaseButton",
-    "BaseSpecFormat",
+    "BlockQuote",
     "Button",
     "Catcher",
     "CatcherError",
-    "ChannelBoostLink",
     "CtxVar",
+    "DataclassAdapter",
     "DelayedTask",
     "ErrorHandler",
+    "EventAdapter",
     "FormatString",
     "GlobalContext",
     "GlobalCtxVar",
@@ -94,53 +132,74 @@ __all__ = (
     "I18nEnum",
     "InlineButton",
     "InlineKeyboard",
-    "InviteChatLink",
+    "InputFileDirectory",
+    "JSONSerializer",
     "Keyboard",
-    "KeyboardSetBase",
-    "KeyboardSetYAML",
     "Lifespan",
     "LimitedDict",
     "Link",
     "LoopWrapper",
     "MemoryStateStorage",
     "Mention",
+    "MsgPackSerializer",
+    "NodeAdapter",
     "ParseMode",
     "PreCode",
-    "ResolveDomain",
+    "RawEventAdapter",
+    "RawUpdateAdapter",
     "RowButtons",
     "SimpleI18n",
     "SimpleTranslator",
     "SpecialFormat",
-    "StartBotLink",
-    "StartGroupLink",
     "StateData",
     "TelegrinderContext",
     "TgEmoji",
     "block_quote",
     "bold",
-    "channel_boost_link",
+    "cancel_future",
     "code_inline",
     "ctx_var",
     "escape",
-    "get_channel_boost_link",
-    "get_invite_chat_link",
-    "get_mention_link",
-    "get_resolve_domain_link",
-    "get_start_bot_link",
-    "get_start_group_link",
+    "from_optional",
+    "get_annotations",
+    "get_cached_translation",
+    "get_default_args",
+    "get_func_parameters",
+    "get_impls",
     "impl",
-    "invite_chat_link",
     "italic",
     "link",
     "magic_bundle",
     "mention",
     "pre_code",
     "resolve_arg_names",
-    "resolve_domain",
     "spoiler",
-    "start_bot_link",
-    "start_group_link",
     "strike",
+    "tg_bot_attach_open_any_chat",
+    "tg_bot_attach_open_current_chat",
+    "tg_bot_attach_open_specific_chat",
+    "tg_bot_start_link",
+    "tg_bot_startchannel_link",
+    "tg_bot_startgroup_link",
+    "tg_chat_folder_link",
+    "tg_chat_invite_link",
+    "tg_direct_mini_app_link",
     "tg_emoji",
-    "underline",
-)
+    "tg_emoji_link",
+    "tg_emoji_stickerset_link",
+    "tg_invoice_link",
+    "tg_language_pack_link",
+    "tg_main_mini_app_link",
+    "tg_mention_link",
+    "tg_open_message_link",
+    "tg_premium_multigift_link",
+    "tg_premium_offer_link",
+    "tg_private_channel_boost_link",
+    "tg_private_message_link",
+    "tg_public_channel_boost_link",
+    "tg_public_message_link",
+    "tg_public_username_link",
+    "tg_share_link",
+    "tg_story_link",
+    "underline",
+)

telegrinder/tools/adapter/__init__.py

@@ -0,0 +1,19 @@
+from telegrinder.tools.adapter.abc import ABCAdapter, AdaptResult, Event
+from telegrinder.tools.adapter.dataclass import DataclassAdapter
+from telegrinder.tools.adapter.errors import AdapterError
+from telegrinder.tools.adapter.event import EventAdapter
+from telegrinder.tools.adapter.node import NodeAdapter
+from telegrinder.tools.adapter.raw_event import RawEventAdapter
+from telegrinder.tools.adapter.raw_update import RawUpdateAdapter
+
+__all__ = (
+    "ABCAdapter",
+    "AdaptResult",
+    "AdapterError",
+    "DataclassAdapter",
+    "Event",
+    "EventAdapter",
+    "NodeAdapter",
+    "RawEventAdapter",
+    "RawUpdateAdapter",
+)

telegrinder/tools/adapter/abc.py

@@ -0,0 +1,49 @@
+import abc
+import dataclasses
+import inspect
+import typing
+
+from fntypes import Error, Nothing, Ok, Option, Some
+from fntypes.result import Result
+
+from telegrinder.modules import logger
+from telegrinder.tools.adapter.errors import AdapterError
+
+type AdaptResult[To] = Result[To, AdapterError] | typing.Awaitable[Result[To, AdapterError]]
+
+
+if typing.TYPE_CHECKING:
+    from telegrinder.api.api import API
+    from telegrinder.bot.dispatch.context import Context
+    from telegrinder.model import Model
+
+
+class ABCAdapter[From: "Model", To](abc.ABC):
+    ADAPTED_VALUE_KEY: str | None = None
+
+    @abc.abstractmethod
+    def adapt(self, api: "API", update: From, context: "Context") -> AdaptResult[To]:
+        pass
+
+
+@dataclasses.dataclass(slots=True)
+class Event[To]:
+    obj: To
+
+
+async def run_adapter[T, U: "Model"](
+    adapter: "ABCAdapter[U, T]",
+    api: "API",
+    update: U,
+    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 {!r} failed with error message: {!r}", adapter, str(err))
+            return Nothing()
+
+
+__all__ = ("ABCAdapter", "AdaptResult", "Event", "run_adapter")

telegrinder/tools/adapter/dataclass.py

@@ -0,0 +1,56 @@
+from fntypes.option import Nothing, Some
+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.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.errors import AdapterError
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
+
+
+class DataclassAdapter[Dataclass](ABCAdapter[Update, Dataclass]):
+    ADAPTED_VALUE_KEY: str
+
+    def __init__(
+        self,
+        dataclass: type[Dataclass],
+        update_type: UpdateType | None = None,
+    ) -> None:
+        self.ADAPTED_VALUE_KEY = f"_adapted_dataclass_{dataclass.__name__}"
+        self.dataclass = dataclass
+        self.update_type = update_type
+
+    def __repr__(self) -> str:
+        return f"<Update -> {self.dataclass.__name__}>"
+
+    def adapt(self, api: API, update: Update, context: Context) -> Result[Dataclass, AdapterError]:
+        if self.ADAPTED_VALUE_KEY in context:
+            return Ok(context[self.ADAPTED_VALUE_KEY])
+
+        update_type = (self.update_type or update.update_type).value
+        try:
+            if self.dataclass is Update:
+                return Ok(update)  # type: ignore
+            elif issubclass(self.dataclass, UpdateCute):
+                dataclass = self.dataclass.from_update(update, bound_api=api)
+            else:
+                match getattr(update, update_type):
+                    case Some(val):
+                        dataclass = (
+                            self.dataclass.from_update(val, bound_api=api)
+                            if issubclass(self.dataclass, BaseCute)
+                            else self.dataclass(**val.to_dict())
+                        )
+                    case Nothing():
+                        return Error(AdapterError(f"Update has no event {update_type!r}."))
+        except Exception as e:
+            return Error(AdapterError(f"Cannot adapt Update to {self.dataclass!r}, error: {e!r}"))
+
+        context[self.ADAPTED_VALUE_KEY] = dataclass
+        return Ok(dataclass)  # type: ignore
+
+
+__all__ = ("DataclassAdapter",)

telegrinder/{bot/rules → tools}/adapter/errors.py

@@ -1,5 +1,5 @@
-class AdapterError(RuntimeError):
-    pass
-
-
-__all__ = ("AdapterError",)
+class AdapterError(RuntimeError):
+    pass
+
+
+__all__ = ("AdapterError",)