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

telegrinder/node/file.py

@@ -0,0 +1,51 @@
+import typing
+
+import telegrinder.types as tg_types
+from telegrinder.api.api import API
+from telegrinder.node.attachment import Animation, Audio, Document, Photo, Video, VideoNote, Voice
+from telegrinder.node.base import FactoryNode
+
+type Attachment = Animation | Audio | Document | Photo | Video | VideoNote | Voice
+
+
+class _FileId(FactoryNode):
+    attachment_node: type[Attachment]
+
+    def __class_getitem__(cls, attachment_node: type[Attachment], /):
+        return cls(attachment_node=attachment_node)
+
+    @classmethod
+    def get_subnodes(cls):
+        return {"attach": cls.attachment_node}
+
+    @classmethod
+    def compose(cls, attach: Attachment) -> str:
+        if isinstance(attach, Photo):
+            return attach.sizes[-1].file_id
+        return attach.file_id
+
+
+class _File(FactoryNode):
+    attachment_node: type[Attachment]
+
+    def __class_getitem__(cls, attachment_node: type[Attachment], /):
+        return cls(attachment_node=attachment_node)
+
+    @classmethod
+    def get_subnodes(cls):
+        return {"file_id": _FileId[cls.attachment_node]}
+
+    @classmethod
+    async def compose(cls, file_id: str, api: API) -> tg_types.File:
+        return (await api.get_file(file_id=file_id)).expect("File can't be downloaded.")
+
+
+if typing.TYPE_CHECKING:
+    type FileId[T: Attachment] = str
+    type File[T: Attachment] = tg_types.File
+else:
+    FileId = _FileId
+    File = _File
+
+
+__all__ = ("File", "FileId")

telegrinder/node/me.py

@@ -1,16 +1,15 @@
-from telegrinder.api.api import API
-from telegrinder.node.base import ComposeError, ScalarNode
-from telegrinder.node.scope import GLOBAL
-from telegrinder.types.objects import User
-
-
-class Me(ScalarNode, User):
-    scope = GLOBAL
-
-    @classmethod
-    async def compose(cls, api: API) -> User:
-        me = await api.get_me()
-        return me.expect(ComposeError("Can't complete get_me request"))
-
-
-__all__ = ("Me",)
+from telegrinder.api.api import API
+from telegrinder.node.base import ComposeError, scalar_node
+from telegrinder.node.scope import GLOBAL
+from telegrinder.types.objects import User
+
+
+@scalar_node(scope=GLOBAL)
+class Me:
+    @classmethod
+    async def compose(cls, api: API) -> User:
+        me = await api.get_me()
+        return me.expect(ComposeError("Can't complete api.get_me() request."))
+
+
+__all__ = ("Me",)

telegrinder/node/payload.py

@@ -0,0 +1,78 @@
+import dataclasses
+import typing
+
+from fntypes.result import Error, Ok
+
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
+from telegrinder.node.base import ComposeError, DataNode, FactoryNode, GlobalNode, scalar_node
+from telegrinder.node.polymorphic import Polymorphic, impl
+from telegrinder.tools.callback_data_serilization import ABCDataSerializer, JSONSerializer
+
+
+@scalar_node[str]
+class Payload(Polymorphic):
+    @impl
+    def compose_pre_checkout_query(cls, event: PreCheckoutQueryCute) -> str:
+        return event.invoice_payload
+
+    @impl
+    def compose_callback_query(cls, event: CallbackQueryCute) -> str:
+        return event.data.expect("CallbackQuery has no data.")
+
+    @impl
+    def compose_message(cls, event: MessageCute) -> str:
+        return event.successful_payment.map(
+            lambda payment: payment.invoice_payload,
+        ).expect("Message has no successful payment.")
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class PayloadSerializer[T: type[ABCDataSerializer[typing.Any]]](DataNode, GlobalNode[T]):
+    serializer: type[ABCDataSerializer[typing.Any]]
+
+    @classmethod
+    def compose(cls) -> typing.Self:
+        return cls(serializer=cls.get(default=JSONSerializer))
+
+
+class _PayloadData(FactoryNode):
+    data_type: type[typing.Any]
+    serializer: type[ABCDataSerializer[typing.Any]] | None = None
+
+    def __class_getitem__(
+        cls,
+        data_type: type[typing.Any] | tuple[type[typing.Any], type[ABCDataSerializer[typing.Any]]],
+        /,
+    ):
+        data_type, serializer = (data_type, None) if not isinstance(data_type, tuple) else data_type
+        return cls(data_type=data_type, serializer=serializer)
+
+    @classmethod
+    def compose(cls, payload: Payload, payload_serializer: PayloadSerializer) -> typing.Any:
+        serializer = cls.serializer or payload_serializer.serializer
+        match serializer(cls.data_type).deserialize(payload):
+            case Ok(value):
+                return value
+            case Error(err):
+                raise ComposeError(err)
+
+
+if typing.TYPE_CHECKING:
+    import typing_extensions
+
+    DataType = typing.TypeVar("DataType")
+    Serializer = typing_extensions.TypeVar(
+        "Serializer",
+        bound=ABCDataSerializer,
+        default=JSONSerializer[typing.Any],
+    )
+
+    type PayloadDataType[DataType, Serializer] = typing.Annotated[DataType, Serializer]
+    PayloadData: typing.TypeAlias = PayloadDataType[DataType, Serializer]
+else:
+    PayloadData = _PayloadData
+
+
+__all__ = ("Payload", "PayloadData", "PayloadSerializer")

telegrinder/node/polymorphic.py

@@ -1,48 +1,67 @@
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.modules import logger
-from telegrinder.node.base import ComposeError, Node
-from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
-from telegrinder.node.scope import NodeScope
-from telegrinder.node.update import UpdateNode
-from telegrinder.tools.magic import get_impls, impl
-
-
-class Polymorphic(Node):
-    @classmethod
-    async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
-        logger.debug(f"Composing polymorphic node {cls.__name__!r}...")
-        scope = getattr(cls, "scope", None)
-        node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
-
-        for i, impl_ in enumerate(get_impls(cls)):
-            logger.debug("Checking impl {!r}...", impl_.__name__)
-            composition = Composition(impl_, True)
-            node_collection = await composition.compose_nodes(update, context)
-            if node_collection is None:
-                logger.debug("Impl {!r} composition failed!", impl_.__name__)
-                continue
-
-            # To determine whether this is a right morph, all subnodes must be resolved
-            if scope is NodeScope.PER_EVENT and (cls, i) in node_ctx:
-                logger.debug(
-                    "Morph is already cached as per_event node, using its value. Impl {!r} succeeded!",
-                    impl_.__name__,
-                )
-                res: NodeSession = node_ctx[(cls, i)]
-                await node_collection.close_all()
-                return res.value
-
-            result = await composition(cls, **node_collection.values)
-            if scope is NodeScope.PER_EVENT:
-                node_ctx[(cls, i)] = NodeSession(cls, result, {})
-
-            await node_collection.close_all(with_value=result)
-            logger.debug("Impl {!r} succeeded with value: {!r}", impl_.__name__, result)
-            return result
-
-        raise ComposeError("No implementation found.")
-
-
-__all__ = ("Polymorphic", "impl")
+import inspect
+import typing
+
+from fntypes.result import Error, Ok
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.modules import logger
+from telegrinder.node.base import ComposeError, Node, get_nodes
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, NodeSession, compose_nodes
+from telegrinder.node.scope import NodeScope
+from telegrinder.tools.magic import get_impls, impl, magic_bundle
+from telegrinder.types.objects import Update
+
+
+class Polymorphic(Node):
+    @classmethod
+    async def compose(cls, raw_update: Update, update: UpdateCute, context: Context) -> typing.Any:
+        logger.debug(f"Composing polymorphic node {cls.__name__!r}...")
+        scope = getattr(cls, "scope", None)
+        node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+        data = {
+            API: update.ctx_api,
+            Context: context,
+            Update: raw_update,
+        }
+
+        for i, impl_ in enumerate(get_impls(cls)):
+            logger.debug("Checking impl {!r}...", impl_.__name__)
+            node_collection = None
+
+            match await compose_nodes(get_nodes(impl_), context, data=data):
+                case Ok(col):
+                    node_collection = col
+                case Error(err):
+                    logger.debug(f"Composition failed with error: {err!r}")
+
+            if node_collection is None:
+                logger.debug("Impl {!r} composition failed!", impl_.__name__)
+                continue
+
+            # To determine whether this is a right morph, all subnodes must be resolved
+            if scope is NodeScope.PER_EVENT and (cls, i) in node_ctx:
+                logger.debug(
+                    "Morph is already cached as per_event node, using its value. Impl {!r} succeeded!",
+                    impl_.__name__,
+                )
+                res: NodeSession = node_ctx[(cls, i)]
+                await node_collection.close_all()
+                return res.value
+
+            result = impl_(cls, **node_collection.values | magic_bundle(impl_, data, typebundle=True))
+            if inspect.isawaitable(result):
+                result = await result
+
+            if scope is NodeScope.PER_EVENT:
+                node_ctx[(cls, i)] = NodeSession(cls, result, {})
+
+            await node_collection.close_all(with_value=result)
+            logger.debug("Impl {!r} succeeded with value: {!r}", impl_.__name__, result)
+            return result
+
+        raise ComposeError("No implementation found.")
+
+
+__all__ = ("Polymorphic", "impl")

telegrinder/node/rule.py

@@ -1,76 +1,72 @@
-import dataclasses
-import importlib
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.base import ComposeError, Node
-from telegrinder.node.update import UpdateNode
-
-if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch.process import check_rule
-    from telegrinder.bot.rules.abc import ABCRule
-
-
-class RuleChain(dict[str, typing.Any], Node):
-    dataclass: type[typing.Any] = dict
-    rules: tuple["ABCRule", ...] = ()
-
-    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
-        super().__init_subclass__(*args, **kwargs)
-
-        if cls.__name__ == "_RuleNode":
-            return
-        cls.dataclass = cls.generate_node_dataclass(cls)
-
-    def __new__(cls, *rules: "ABCRule") -> type[Node]:
-        return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
-
-    def __class_getitem__(cls, items: "ABCRule | tuple[ABCRule, ...]", /) -> typing.Self:
-        if not isinstance(items, tuple):
-            items = (items,)
-        return cls(*items)
-
-    @staticmethod
-    def generate_node_dataclass(cls_: type["RuleChain"]):  # noqa: ANN205
-        return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
-
-    @classmethod
-    async def compose(cls, update: UpdateNode) -> typing.Any:
-        # Hack to avoid circular import
-        globalns = globals()
-        if "check_rule" not in globalns:
-            globalns.update(
-                {
-                    "check_rule": getattr(
-                        importlib.import_module("telegrinder.bot.dispatch.process"),
-                        "check_rule",
-                    ),
-                },
-            )
-
-        ctx = Context()
-        for rule in cls.rules:
-            if not await check_rule(update.api, rule, update, ctx):
-                raise ComposeError(f"Rule {rule!r} failed!")
-
-        try:
-            if dataclasses.is_dataclass(cls.dataclass):
-                return cls.dataclass(**{k: ctx[k] for k in cls.__annotations__})
-            return cls.dataclass(**ctx)
-        except Exception as exc:
-            raise ComposeError(f"Dataclass validation error: {exc}")
-
-    @classmethod
-    def as_node(cls) -> type[typing.Self]:
-        return cls
-
-    @classmethod
-    def get_subnodes(cls) -> dict[typing.Literal["update"], type[UpdateNode]]:
-        return {"update": UpdateNode}
-
-    @classmethod
-    def is_generator(cls) -> typing.Literal[False]:
-        return False
-
-
-__all__ = ("RuleChain",)
+import dataclasses
+import importlib
+import typing
+
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.base import ComposeError, Node
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.process import check_rule
+    from telegrinder.bot.rules.abc import ABCRule
+
+
+class RuleChain(dict[str, typing.Any], Node):
+    dataclass: type[typing.Any] = dict
+    rules: tuple["ABCRule", ...] = ()
+
+    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
+        super().__init_subclass__(*args, **kwargs)
+
+        if cls.__name__ == "_RuleNode":
+            return
+        cls.dataclass = cls.generate_node_dataclass(cls)
+
+    def __new__(cls, *rules: "ABCRule") -> type[Node]:
+        return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
+
+    def __class_getitem__(cls, items: "ABCRule | tuple[ABCRule, ...]", /) -> typing.Self:
+        if not isinstance(items, tuple):
+            items = (items,)
+        return cls(*items)
+
+    @staticmethod
+    def generate_node_dataclass(cls_: type["RuleChain"]):  # noqa: ANN205
+        return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
+
+    @classmethod
+    async def compose(cls, update: UpdateCute) -> typing.Any:
+        # Hack to avoid circular import
+        globalns = globals()
+        if "check_rule" not in globalns:
+            globalns.update(
+                {
+                    "check_rule": getattr(
+                        importlib.import_module("telegrinder.bot.dispatch.process"),
+                        "check_rule",
+                    ),
+                },
+            )
+
+        ctx = Context()
+        for rule in cls.rules:
+            if not await check_rule(update.api, rule, update, ctx):
+                raise ComposeError(f"Rule {rule!r} failed!")
+
+        try:
+            if dataclasses.is_dataclass(cls.dataclass):
+                return cls.dataclass(**{k: ctx[k] for k in cls.__annotations__})
+            return cls.dataclass(**ctx)
+        except Exception as exc:
+            raise ComposeError(f"Dataclass validation error: {exc}")
+
+    @classmethod
+    def as_node(cls) -> type[typing.Self]:
+        return cls
+
+    @classmethod
+    def is_generator(cls) -> typing.Literal[False]:
+        return False
+
+
+__all__ = ("RuleChain",)

telegrinder/node/scope.py

@@ -1,44 +1,42 @@
-import enum
-import typing
-
-if typing.TYPE_CHECKING:
-    from .base import Node
-
-T = typing.TypeVar("T", bound=type["Node"])
-
-
-class NodeScope(enum.Enum):
-    GLOBAL = enum.auto()
-    PER_EVENT = enum.auto()
-    PER_CALL = enum.auto()
-
-
-PER_EVENT = NodeScope.PER_EVENT
-PER_CALL = NodeScope.PER_CALL
-GLOBAL = NodeScope.GLOBAL
-
-
-def per_call(node: T) -> T:
-    setattr(node, "scope", PER_CALL)
-    return node
-
-
-def per_event(node: T) -> T:
-    setattr(node, "scope", PER_EVENT)
-    return node
-
-
-def global_node(node: T) -> T:
-    setattr(node, "scope", GLOBAL)
-    return node
-
-
-__all__ = (
+import enum
+import typing
+
+if typing.TYPE_CHECKING:
+    from .base import IsNode
+
+
+class NodeScope(enum.Enum):
+    GLOBAL = enum.auto()
+    PER_EVENT = enum.auto()
+    PER_CALL = enum.auto()
+
+
+PER_EVENT = NodeScope.PER_EVENT
+PER_CALL = NodeScope.PER_CALL
+GLOBAL = NodeScope.GLOBAL
+
+
+def per_call[T: IsNode](node: type[T]) -> type[T]:
+    setattr(node, "scope", PER_CALL)
+    return node
+
+
+def per_event[T: IsNode](node: type[T]) -> type[T]:
+    setattr(node, "scope", PER_EVENT)
+    return node
+
+
+def global_node[T: IsNode](node: type[T]) -> type[T]:
+    setattr(node, "scope", GLOBAL)
+    return node
+
+
+__all__ = (
     "GLOBAL",
     "NodeScope",
     "PER_CALL",
     "PER_EVENT",
     "global_node",
     "per_call",
-    "per_event",
-)
+    "per_event",
+)

telegrinder/node/source.py

@@ -1,71 +1,87 @@
-import dataclasses
-import typing
-
-from fntypes.option import Nothing, Option
-
-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.node.polymorphic import Polymorphic, impl
-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())
-
-    @impl
-    def compose_message(cls, message: MessageNode) -> typing.Self:
-        return cls(
-            api=message.ctx_api,
-            chat=message.chat,
-            from_user=message.from_.expect(ComposeError("MessageNode has no from_user")),
-            thread_id=message.message_thread_id,
-        )
-
-    @impl
-    def compose_callback_query(cls, callback_query: CallbackQueryNode) -> 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,
-            thread_id=callback_query.message_thread_id,
-        )
-
-    @impl
-    def compose_chat_join_request(cls, chat_join_request: EventNode[ChatJoinRequestCute]) -> typing.Self:
-        return cls(
-            api=chat_join_request.ctx_api,
-            chat=chat_join_request.chat,
-            from_user=chat_join_request.from_user,
-            thread_id=Nothing(),
-        )
-
-    async def send(self, text: str) -> Message:
-        result = await self.api.send_message(
-            chat_id=self.chat.id,
-            message_thread_id=self.thread_id.unwrap_or_none(),
-            text=text,
-        )
-        return result.unwrap()
-
-
-class ChatSource(ScalarNode, Chat):
-    @classmethod
-    def compose(cls, source: Source) -> Chat:
-        return source.chat
-
-
-class UserSource(ScalarNode, User):
-    @classmethod
-    def compose(cls, source: Source) -> User:
-        return source.from_user
-
-
-__all__ = ("ChatSource", "Source", "UserSource")
+import dataclasses
+import typing
+
+from fntypes.option import Nothing, Option, Some
+
+from telegrinder.api.api import API
+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
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class Source(Polymorphic, DataNode):
+    api: API
+    from_user: User
+    chat: Option[Chat] = dataclasses.field(default_factory=Nothing)
+    thread_id: Option[int] = dataclasses.field(default_factory=Nothing)
+
+    @impl
+    def compose_message(cls, message: MessageCute) -> typing.Self:
+        return cls(
+            api=message.ctx_api,
+            from_user=message.from_user,
+            chat=Some(message.chat),
+            thread_id=message.message_thread_id,
+        )
+
+    @impl
+    def compose_callback_query(cls, callback_query: CallbackQueryCute) -> typing.Self:
+        return cls(
+            api=callback_query.ctx_api,
+            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: ChatJoinRequestCute) -> typing.Self:
+        return cls(
+            api=chat_join_request.ctx_api,
+            from_user=chat_join_request.from_user,
+            chat=Some(chat_join_request.chat),
+            thread_id=Nothing(),
+        )
+
+    @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.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()
+
+
+@scalar_node
+class ChatSource:
+    @classmethod
+    def compose(cls, source: Source) -> Chat:
+        return source.chat.expect(ComposeError("Source has no chat."))
+
+
+@scalar_node
+class UserSource:
+    @classmethod
+    def compose(cls, source: Source) -> User:
+        return source.from_user
+
+
+@scalar_node
+class UserId:
+    @classmethod
+    def compose(cls, user: UserSource) -> int:
+        return user.id
+
+
+__all__ = ("ChatSource", "Source", "UserId", "UserSource")