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

telegrinder/node/source.py

@@ -1,14 +1,11 @@
 import dataclasses
 import typing
 
-from fntypes.option import Nothing, Option
+from fntypes.option import Nothing, Option, Some
 
 from telegrinder.api.api import API
-from telegrinder.bot.cute_types import ChatJoinRequestCute
-from telegrinder.node.base import ComposeError, DataNode, ScalarNode
-from telegrinder.node.callback_query import CallbackQueryNode
-from telegrinder.node.event import EventNode
-from telegrinder.node.message import MessageNode
+from telegrinder.bot.cute_types import CallbackQueryCute, ChatJoinRequestCute, MessageCute, PreCheckoutQueryCute
+from telegrinder.node.base import ComposeError, DataNode, scalar_node
 from telegrinder.node.polymorphic import Polymorphic, impl
 from telegrinder.types.objects import Chat, Message, User
 
@@ -16,56 +13,75 @@ from telegrinder.types.objects import Chat, Message, User
 @dataclasses.dataclass(kw_only=True, slots=True)
 class Source(Polymorphic, DataNode):
     api: API
-    chat: Chat
     from_user: User
-    thread_id: Option[int] = dataclasses.field(default_factory=lambda: Nothing())
+    chat: Option[Chat] = dataclasses.field(default_factory=Nothing)
+    thread_id: Option[int] = dataclasses.field(default_factory=Nothing)
 
     @impl
-    def compose_message(cls, message: MessageNode) -> typing.Self:
+    def compose_message(cls, message: MessageCute) -> typing.Self:
         return cls(
             api=message.ctx_api,
-            chat=message.chat,
-            from_user=message.from_.expect(ComposeError("MessageNode has no from_user")),
+            from_user=message.from_user,
+            chat=Some(message.chat),
             thread_id=message.message_thread_id,
         )
 
     @impl
-    def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
+    def compose_callback_query(cls, callback_query: CallbackQueryCute) -> typing.Self:
         return cls(
             api=callback_query.ctx_api,
-            chat=callback_query.chat.expect(ComposeError("CallbackQueryNode has no chat")),
             from_user=callback_query.from_user,
+            chat=callback_query.chat,
             thread_id=callback_query.message_thread_id,
         )
 
     @impl
-    def compose_chat_join_request(cls, chat_join_request: EventNode[ChatJoinRequestCute]) -> typing.Self:
+    def compose_chat_join_request(cls, chat_join_request: ChatJoinRequestCute) -> typing.Self:
         return cls(
             api=chat_join_request.ctx_api,
-            chat=chat_join_request.chat,
             from_user=chat_join_request.from_user,
+            chat=Some(chat_join_request.chat),
             thread_id=Nothing(),
         )
 
-    async def send(self, text: str) -> Message:
+    @impl
+    def compose_pre_checkout_query(cls, pre_checkout_query: PreCheckoutQueryCute) -> typing.Self:
+        return cls(
+            api=pre_checkout_query.ctx_api,
+            from_user=pre_checkout_query.from_user,
+            chat=Nothing(),
+            thread_id=Nothing(),
+        )
+
+    async def send(self, text: str, **kwargs: typing.Any) -> Message:
         result = await self.api.send_message(
-            chat_id=self.chat.id,
+            chat_id=self.chat.map_or(self.from_user.id, lambda chat: chat.id).unwrap(),
             message_thread_id=self.thread_id.unwrap_or_none(),
             text=text,
+            **kwargs,
         )
         return result.unwrap()
 
 
-class ChatSource(ScalarNode, Chat):
+@scalar_node
+class ChatSource:
     @classmethod
     def compose(cls, source: Source) -> Chat:
-        return source.chat
+        return source.chat.expect(ComposeError("Source has no chat."))
 
 
-class UserSource(ScalarNode, User):
+@scalar_node
+class UserSource:
     @classmethod
     def compose(cls, source: Source) -> User:
         return source.from_user
 
 
-__all__ = ("ChatSource", "Source", "UserSource")
+@scalar_node
+class UserId:
+    @classmethod
+    def compose(cls, user: UserSource) -> int:
+        return user.id
+
+
+__all__ = ("ChatSource", "Source", "UserId", "UserSource")

telegrinder/node/text.py

@@ -1,20 +1,32 @@
 import typing
 
-from telegrinder.node.base import ComposeError, FactoryNode, ScalarNode
-from telegrinder.node.message import MessageNode
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.node.base import ComposeError, FactoryNode, scalar_node
+from telegrinder.node.either import Either
 
 
-class Text(ScalarNode, str):
+@scalar_node
+class Caption:
     @classmethod
-    def compose(cls, message: MessageNode) -> str:
+    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()
 
 
-class TextInteger(ScalarNode, int):
+@scalar_node
+class TextInteger:
     @classmethod
-    def compose(cls, text: Text) -> int:
+    def compose(cls, text: Either[Text, Caption]) -> int:
         if not text.isdigit():
             raise ComposeError("Text is not digit.")
         return int(text)
@@ -35,7 +47,7 @@ else:
         def compose(cls, text: Text) -> str:
             if text in cls.texts:
                 return text
-            raise ComposeError("Text matching failed.")
+            raise ComposeError("Text mismatched literal.")
 
 
-__all__ = ("Text", "TextInteger", "TextLiteral")
+__all__ = ("Caption", "Text", "TextInteger", "TextLiteral")

telegrinder/node/tools/generator.py

@@ -1,40 +1,36 @@
 import inspect
 import typing
 
-from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.base import ComposeError, IsNode, Node
 from telegrinder.node.container import ContainerNode
 
-T = typing.TypeVar("T")
 
-
-def cast_false_to_none(value: T) -> T | None:
+def cast_false_to_none[Value](value: Value) -> Value | None:
     if value is False:
         return None
     return value
 
 
-def error_on_none(value: T | None) -> T:
+def error_on_none[Value](value: Value | None) -> Value:
     if value is None:
         raise ComposeError
     return value
 
 
 def generate_node(
-    subnodes: tuple[type[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, **kw) -> typing.Any:
-        result = func(*ContainerNode.compose(**kw))  # type: ignore
+    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
 
-    container = ContainerNode.link_nodes(list(subnodes))
-    compose.__annotations__ = container.get_subnodes()
-    return type("_ContainerNode", (container,), {"compose": classmethod(compose)})
+    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",
-)

telegrinder/tools/__init__.py

@@ -1,43 +1,67 @@
+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 (
-    BaseSpecFormat,
-    ChannelBoostLink,
+    Base,
+    BlockQuote,
     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_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,
@@ -54,7 +78,7 @@ from .i18n import (
     SimpleI18n,
     SimpleTranslator,
 )
-from .kb_set import KeyboardSetBase, KeyboardSetYAML
+from .input_file_directory import InputFileDirectory
 from .keyboard import (
     AnyMarkup,
     Button,
@@ -65,11 +89,23 @@ from .keyboard import (
 )
 from .limited_dict import LimitedDict
 from .loop_wrapper import ABCLoopWrapper, DelayedTask, Lifespan, LoopWrapper
-from .magic import impl, magic_bundle, resolve_arg_names
+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",
+    "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/event.py

@@ -6,19 +6,17 @@ 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.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.errors import AdapterError
+from telegrinder.tools.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]):
+class EventAdapter[ToEvent: BaseCute](ABCAdapter[Update, ToEvent]):
     ADAPTED_VALUE_KEY: str = "_adapted_cute_event"
 
-    def __init__(self, event: UpdateType | type[Model], cute_model: type[ToCute]) -> None:
+    def __init__(self, event: UpdateType | type[Model], cute_model: type[ToEvent]) -> None:
         self.event = event
         self.cute_model = cute_model
 
@@ -26,7 +24,7 @@ class EventAdapter(ABCAdapter[Update, ToCute]):
         raw_update_type = (
             f"Update -> {self.event.__name__}"
             if isinstance(self.event, type)
-            else f"Update.{self.event.value}"
+            else f"Update.{self.event.value}"  # type: ignore
         )
         return "<{}: adapt {} -> {}>".format(
             self.__class__.__name__,
@@ -43,14 +41,14 @@ class EventAdapter(ABCAdapter[Update, ToCute]):
 
         return None
 
-    def adapt(self, api: API, update: Update, context: Context) -> Result[ToCute, AdapterError]:
+    def adapt(self, api: API, update: Update, context: Context) -> Result[ToEvent, 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)
+                    typing.cast(ToEvent, event)
                     if isinstance(event, BaseCute)
                     else self.cute_model.from_update(event, bound_api=api)
                 )