telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/node/nodes/payload.py

@@ -0,0 +1,84 @@
+import dataclasses
+import typing
+
+from kungfu.library.monad.result import Error, Ok
+from nodnod.error import NodeError
+from nodnod.interface.generic import generic_node
+from nodnod.interface.polymorphic import case, polymorphic
+from nodnod.interface.scalar import scalar_node
+
+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.bot.cute_types.shipping_query import ShippingQueryCute
+from telegrinder.node.nodes.global_node import GlobalNode
+from telegrinder.tools.serialization.abc import ABCDataSerializer
+from telegrinder.tools.serialization.json_ser import JSONSerializer
+
+type _UndefinedSerializer = typing.Any
+
+
+@scalar_node
+@polymorphic[str]
+class Payload:
+    @case
+    def compose_callback_query(cls, event: CallbackQueryCute) -> str:
+        return event.data.expect(NodeError("CallbackQuery has no data."))
+
+    @case
+    def compose_pre_checkout_query(cls, event: PreCheckoutQueryCute) -> str:
+        return event.invoice_payload
+
+    @case
+    def compose_shipping_query(cls, event: ShippingQueryCute) -> str:
+        return event.invoice_payload
+
+    @case
+    def compose_message(cls, event: MessageCute) -> str:
+        return event.successful_payment.map(
+            lambda payment: payment.invoice_payload,
+        ).expect(NodeError("Message has no successful payment."))
+
+
+@dataclasses.dataclass(frozen=True)
+class PayloadSerializer[T: type[ABCDataSerializer] = typing.Any](GlobalNode[T]):
+    serializer: type[ABCDataSerializer[typing.Any]]
+
+    @classmethod
+    def __compose__(cls) -> typing.Self:
+        return cls(serializer=JSONSerializer)
+
+
+@generic_node
+class _PayloadData[Data, Serializer: ABCDataSerializer = _UndefinedSerializer]:
+    @classmethod
+    def __compose__(
+        cls,
+        payload: Payload,
+        data: type[Data],
+        payload_serializer: type[Serializer],
+        global_serializer: PayloadSerializer,
+    ) -> typing.Any:
+        if payload_serializer is _UndefinedSerializer:
+            serializer = getattr(data, "__serializer__", global_serializer.serializer)
+        else:
+            serializer = payload_serializer
+
+        match serializer(data).deserialize(payload):
+            case Ok(value):
+                return value
+            case Error(err):
+                raise NodeError(err)
+
+
+if typing.TYPE_CHECKING:
+    type PayloadData[
+        DataType = typing.Any,
+        Serializer: ABCDataSerializer = _UndefinedSerializer,
+    ] = typing.Annotated[DataType, Serializer]
+
+else:
+    PayloadData = _PayloadData
+
+
+__all__ = ("Payload", "PayloadData", "PayloadSerializer")

telegrinder/node/nodes/reply_message.py

@@ -0,0 +1,14 @@
+from nodnod.error import NodeError
+from nodnod.interface.scalar import scalar_node
+
+from telegrinder.bot.cute_types.message import MessageCute
+
+
+@scalar_node
+class ReplyMessage:
+    @classmethod
+    def __compose__(cls, message: MessageCute) -> MessageCute:
+        return message.reply_to_message.expect(NodeError("Message doesn't have reply"))
+
+
+__all__ = ("ReplyMessage",)

telegrinder/node/nodes/source.py

@@ -0,0 +1,172 @@
+import dataclasses
+import typing
+
+from kungfu.library.monad.option import Nothing, Option, Some
+from nodnod.error import NodeError
+from nodnod.interface.polymorphic import case, polymorphic
+from nodnod.interface.scalar import scalar_node
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types import (
+    CallbackQueryCute,
+    ChatJoinRequestCute,
+    ChatMemberUpdatedCute,
+    ChosenInlineResultCute,
+    InlineQueryCute,
+    MessageCute,
+    MessageReactionUpdatedCute,
+    PaidMediaPurchasedCute,
+    PollAnswerCute,
+    PreCheckoutQueryCute,
+    ShippingQueryCute,
+)
+from telegrinder.types.objects import Chat, Message, User
+
+
+@scalar_node
+@polymorphic["Source"]
+@dataclasses.dataclass(kw_only=True)
+class Source:
+    api: API
+    from_user: User
+    chat: Option[Chat] = dataclasses.field(default_factory=Nothing)
+    thread_id: Option[int] = dataclasses.field(default_factory=Nothing)
+
+    @case
+    def compose_message(cls, message: MessageCute) -> typing.Self:
+        return cls(
+            api=message.api,
+            from_user=message.from_.expect(NodeError("Message is from a channel.")),
+            chat=Some(message.chat),
+            thread_id=message.message_thread_id,
+        )
+
+    @case
+    def compose_callback_query(cls, callback_query: CallbackQueryCute) -> typing.Self:
+        return cls(
+            api=callback_query.api,
+            from_user=callback_query.from_user,
+            chat=callback_query.chat,
+            thread_id=callback_query.message_thread_id,
+        )
+
+    @case
+    def compose_inline_query(cls, inline_query: InlineQueryCute) -> typing.Self:
+        return cls(
+            api=inline_query.api,
+            from_user=inline_query.from_user,
+        )
+
+    @case
+    def compose_chosen_inline_result(cls, chosen_inline_result: ChosenInlineResultCute) -> typing.Self:
+        return cls(
+            api=chosen_inline_result.api,
+            from_user=chosen_inline_result.from_user,
+        )
+
+    @case
+    def compose_chat_member_updated(cls, chat_member_updated: ChatMemberUpdatedCute) -> typing.Self:
+        return cls(
+            api=chat_member_updated.api,
+            from_user=chat_member_updated.from_user,
+            chat=Some(chat_member_updated.chat),
+        )
+
+    @case
+    def compose_chat_join_request(cls, chat_join_request: ChatJoinRequestCute) -> typing.Self:
+        return cls(
+            api=chat_join_request.api,
+            from_user=chat_join_request.from_user,
+            chat=Some(chat_join_request.chat),
+        )
+
+    @case
+    def compose_pre_checkout_query(cls, pre_checkout_query: PreCheckoutQueryCute) -> typing.Self:
+        return cls(
+            api=pre_checkout_query.api,
+            from_user=pre_checkout_query.from_user,
+        )
+
+    @case
+    def compose_message_reaction_updated(cls, message_reaction_updated: MessageReactionUpdatedCute) -> typing.Self:
+        return cls(
+            api=message_reaction_updated.api,
+            from_user=message_reaction_updated.user.expect(NodeError("Message reaction is from an anonymous user.")),
+            chat=Some(message_reaction_updated.chat),
+        )
+
+    @case
+    def compose_paid_media_purchased(cls, paid_media_purchased: PaidMediaPurchasedCute) -> typing.Self:
+        return cls(
+            api=paid_media_purchased.api,
+            from_user=paid_media_purchased.from_user,
+        )
+
+    @case
+    def compose_poll_answer(cls, poll_answer: PollAnswerCute) -> typing.Self:
+        return cls(
+            api=poll_answer.api,
+            from_user=poll_answer.user.expect(NodeError("Poll answer is from an anonymous user.")),
+            chat=poll_answer.voter_chat,
+        )
+
+    @case
+    def compose_shipping_query(cls, shipping_query: ShippingQueryCute) -> typing.Self:
+        return cls(
+            api=shipping_query.api,
+            from_user=shipping_query.from_user,
+        )
+
+    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(NodeError("Source has no chat."))
+
+
+@scalar_node
+class UserSource:
+    @classmethod
+    def __compose__(cls, source: Source) -> User:
+        return source.from_user
+
+
+@scalar_node
+class ChatId:
+    @classmethod
+    def __compose__(cls, chat: ChatSource) -> int:
+        return chat.id
+
+
+@scalar_node
+class UserId:
+    @classmethod
+    def __compose__(cls, user: UserSource) -> int:
+        return user.id
+
+
+@scalar_node
+class Locale:
+    @classmethod
+    def __compose__(cls, user: UserSource) -> str:
+        return user.language_code.expect(NodeError("User has no language code."))
+
+
+__all__ = (
+    "ChatId",
+    "ChatSource",
+    "Locale",
+    "Source",
+    "UserId",
+    "UserSource",
+)

telegrinder/node/nodes/state_mutator.py

@@ -0,0 +1,71 @@
+import typing
+
+from kungfu.library.monad.option import Some
+from nodnod.error import NodeError
+from nodnod.node import Node
+
+from telegrinder.node.nodes.payload import PayloadSerializer
+from telegrinder.node.nodes.source import Source
+from telegrinder.tools.fullname import fullname
+from telegrinder.tools.serialization import ABCDataSerializer
+from telegrinder.tools.state_storage.memory import ABCStateStorage, MemoryStateStorage
+
+
+class StateMutator(Node):
+    STORAGE = MemoryStateStorage[str]()  # TODO: use nodnod injection to get storage inside StateMutator.compose
+    KEY_MAP: dict[str, type[State]] = {}
+
+    def __init__(
+        self,
+        storage: ABCStateStorage[str],
+        user_id: int,
+        serializer: type[ABCDataSerializer[State]],
+    ) -> None:
+        self.storage = storage
+        self.user_id = user_id
+        self.serializer = serializer
+
+    async def get(self) -> State | None:
+        match await self.storage.get(self.user_id):
+            case Some(state_data) if state_data.key in self.KEY_MAP:
+                return (
+                    self.serializer(self.KEY_MAP[state_data.key])
+                    .deserialize(state_data.payload)
+                    .map(lambda state: state.bind(self))
+                    .unwrap_or_none()
+                )
+
+        return None
+
+    async def set(self, state: State) -> None:
+        state_cls = state.__class__
+        key = fullname(state_cls)
+        payload = self.serializer(state_cls).serialize(state)
+        await self.storage.set(self.user_id, key, payload)
+        self.KEY_MAP[key] = state_cls
+
+    @classmethod
+    def __compose__(cls, src: Source, serializer: PayloadSerializer) -> typing.Self:
+        return cls(cls.STORAGE, src.from_user.id, serializer.serializer)
+
+
+class State:
+    def bind(self, mutator: StateMutator) -> typing.Self:
+        self.__mutator__ = mutator
+        return self
+
+    async def enter(self) -> None:
+        await self.__mutator__.set(state=self)
+
+    async def exit(self) -> None:
+        pass
+
+    @classmethod
+    async def __compose__(cls, mutator: StateMutator) -> typing.Self:
+        current_state = await mutator.get()
+        if current_state is None or not isinstance(current_state, cls):
+            raise NodeError("State mismatch.")
+        return current_state
+
+
+__all__ = ("State", "StateMutator")

telegrinder/node/nodes/text.py

@@ -0,0 +1,62 @@
+import typing
+
+from nodnod.error import NodeError
+from nodnod.interface.node_constructor import NodeConstructor
+from nodnod.interface.scalar import scalar_node
+
+from telegrinder.bot.cute_types.message import MessageCute
+
+
+@scalar_node
+class Caption:
+    @classmethod
+    def __compose__(cls, message: MessageCute) -> str:
+        return message.caption.expect(NodeError("Message has no caption."))
+
+
+@scalar_node
+class HTMLCaption:
+    @classmethod
+    def __compose__(cls, message: MessageCute) -> str:
+        return message.html_caption.expect(NodeError("Message has no HTML caption."))
+
+
+@scalar_node
+class Text:
+    @classmethod
+    def __compose__(cls, message: MessageCute) -> str:
+        return message.text.expect(NodeError("Message has no text."))
+
+
+@scalar_node
+class HTMLText:
+    @classmethod
+    def __compose__(cls, message: MessageCute) -> str:
+        return message.html_text.expect(NodeError("Message has no HTML text."))
+
+
+@scalar_node
+class TextInteger:
+    @classmethod
+    def __compose__(cls, text: Text | Caption) -> int:
+        if not text.isdigit():
+            raise NodeError("Text is not digit.")
+        return int(text)
+
+
+if typing.TYPE_CHECKING:
+    from typing import Literal as TextLiteral
+
+else:
+
+    class TextLiteral(NodeConstructor):
+        def __init__(self, *texts: str) -> None:
+            self.texts = texts
+
+        def __compose__(self, text: Text | Caption) -> str:
+            if text in self.texts:
+                return text
+            raise NodeError("Text mismatched literal.")
+
+
+__all__ = ("Caption", "HTMLCaption", "HTMLText", "Text", "TextInteger", "TextLiteral")

telegrinder/node/scope.py

@@ -0,0 +1,88 @@
+"""Specific `scopes` for node scope system.
+
+Scopes:
+- `GLOBAL`: compose only once during runtime, and later be stored and reused when needed ~ `@global_node`
+- `PER_EVENT`: compose once per event, so if during the composition the node was already composed, it will be reused and won't be composed twice ~ `@per_event`
+- `PER_CALL`: compose each time any node will require it to build itself or if we require it to be delivered into the handler ~ `@per_call`
+"""
+
+from __future__ import annotations
+
+import enum
+import typing
+
+from nodnod.node import Node
+from nodnod.scope import Scope
+
+from telegrinder.modules import logger
+from telegrinder.node.utils import as_node
+from telegrinder.tools.global_context.builtin_context import TelegrinderContext
+
+if typing.TYPE_CHECKING:
+    from telegrinder.node.scope import NodeScope
+
+    # Import members from NodeScope
+    GLOBAL, PER_CALL, PER_EVENT = NodeScope.GLOBAL, NodeScope.PER_CALL, NodeScope.PER_EVENT
+
+TELEGRINDER_CONTEXT: typing.Final = TelegrinderContext()
+
+
+@TELEGRINDER_CONTEXT.loop_wrapper.lifespan.on_shutdown
+async def close_node_global_scope() -> None:
+    logger.debug("Closing node global scope")
+
+    try:
+        await TELEGRINDER_CONTEXT.close_global_scope()
+    except Exception as error:
+        logger.error("While closing node global scope, an error occurred: {!r}", error)
+
+
+class NodeScopeInfo(dict[type[Node], "NodeScope"]):
+    def set_node_scope[T: Node[typing.Any, typing.Any]](self, node: type[T], scope: NodeScope, /) -> None:
+        self[node] = scope
+
+    def get_node_scope[T: Node[typing.Any, typing.Any]](self, node: type[T], /) -> NodeScope | None:
+        return self.get(node, None)
+
+
+NODE_SCOPE_INFO: typing.Final = NodeScopeInfo()
+
+
+class MappedScopes(dict[type[Node], Scope]):
+    scopes: dict[NodeScope, Scope]
+
+    def __init__(self, global_scope: Scope, per_event_scope: Scope) -> None:
+        self.scopes = {NodeScope.GLOBAL: global_scope, NodeScope.PER_EVENT: per_event_scope}
+
+    def get(self, key: type[Node], default: Scope | None = None) -> Scope | None:
+        scope = NODE_SCOPE_INFO.get_node_scope(key) or NodeScope.PER_EVENT
+        return self.scopes.get(scope, default)
+
+
+# Declare NodeScope members in a global scope
+@enum.global_enum
+class NodeScope(enum.StrEnum):
+    GLOBAL = "global"
+    PER_CALL = "local"
+    PER_EVENT = "event"
+
+    def __call__[T](self, node: type[T], /) -> type[T]:
+        NODE_SCOPE_INFO.set_node_scope(as_node(node), self)
+        return node
+
+
+# Decorators
+global_node, per_call, per_event = GLOBAL, PER_CALL, PER_EVENT
+
+
+__all__ = (
+    "GLOBAL",
+    "NODE_SCOPE_INFO",
+    "PER_CALL",
+    "PER_EVENT",
+    "MappedScopes",
+    "NodeScope",
+    "global_node",
+    "per_call",
+    "per_event",
+)

telegrinder/node/utils.py

@@ -0,0 +1,38 @@
+import sys
+import typing
+
+from nodnod.interface.is_node import is_node
+from nodnod.node import Node
+
+from telegrinder.tools.fullname import fullname
+
+
+def as_node(obj: typing.Any, /) -> type[Node[typing.Any, typing.Any]]:
+    if not is_node(obj):
+        raise TypeError(f"Object `{fullname(obj)}` is not a node.")
+    return obj
+
+
+def get_locals_from_function(func: typing.Callable[..., typing.Any], /) -> typing.Mapping[str, typing.Any] | None:
+    bound_class = func.__self__ if hasattr(func, "__self__") else None
+    bound_class = func.__objclass__ if bound_class is None and hasattr(func, "__objclass__") else None
+
+    if bound_class is not None:
+        return (bound_class if isinstance(bound_class, type) else type(bound_class)).__dict__
+
+    return None
+
+
+def get_globals_from_function(func: typing.Callable[..., typing.Any], /) -> dict[str, typing.Any]:
+    if hasattr(func, "__globals__"):
+        return getattr(func, "__globals__")
+
+    module = getattr(func, "__module__", type(func).__module__)
+
+    if module in sys.modules:
+        return vars(sys.modules[module])
+
+    return {}
+
+
+__all__ = ("as_node", "get_globals_from_function", "get_locals_from_function", "is_node")

telegrinder/rules.py

@@ -0,0 +1 @@
+from telegrinder.bot.rules import *