telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/node/nodes/attachment.py

@@ -0,0 +1,169 @@
+import dataclasses
+import typing
+
+from kungfu.library.monad.option import NOTHING, Nothing, Option
+from nodnod.error import NodeError
+from nodnod.interface.scalar import scalar_node
+from nodnod.node import Node
+
+import telegrinder.types
+from telegrinder.bot.cute_types.message import MessageCute
+
+type AttachmentType = typing.Literal[
+    "animation",
+    "audio",
+    "document",
+    "photo",
+    "poll",
+    "video",
+    "video_note",
+    "voice",
+    "successful_payment",
+]
+
+ATTACHMENT_TYPES: typing.Final[tuple[AttachmentType, ...]] = typing.get_args(AttachmentType.__value__)
+
+
+@dataclasses.dataclass
+class Attachment(Node):
+    attachment_type: AttachmentType
+
+    animation: Option[telegrinder.types.Animation] = dataclasses.field(
+        default_factory=Nothing,
+        kw_only=True,
+    )
+    audio: Option[telegrinder.types.Audio] = dataclasses.field(
+        default_factory=Nothing,
+        kw_only=True,
+    )
+    document: Option[telegrinder.types.Document] = dataclasses.field(
+        default_factory=Nothing,
+        kw_only=True,
+    )
+    photo: Option[list[telegrinder.types.PhotoSize]] = dataclasses.field(
+        default_factory=Nothing,
+        kw_only=True,
+    )
+    poll: Option[telegrinder.types.Poll] = dataclasses.field(
+        default_factory=Nothing,
+        kw_only=True,
+    )
+    voice: Option[telegrinder.types.Voice] = dataclasses.field(
+        default_factory=Nothing,
+        kw_only=True,
+    )
+    video: Option[telegrinder.types.Video] = dataclasses.field(
+        default_factory=Nothing,
+        kw_only=True,
+    )
+    video_note: Option[telegrinder.types.VideoNote] = dataclasses.field(
+        default_factory=Nothing,
+        kw_only=True,
+    )
+    successful_payment: Option[telegrinder.types.SuccessfulPayment] = dataclasses.field(
+        default_factory=Nothing,
+        kw_only=True,
+    )
+
+    @classmethod
+    def __compose__(cls, message: MessageCute) -> typing.Self:
+        for attachment_type in ATTACHMENT_TYPES:
+            attachment = getattr(message, attachment_type, NOTHING)
+
+            if attachment:
+                return cls(attachment_type, **{attachment_type: attachment})
+
+        raise NodeError("No attachment found in message.")
+
+
+@dataclasses.dataclass
+class Photo(Node):
+    sizes: list[telegrinder.types.PhotoSize]
+
+    @classmethod
+    def __compose__(cls, attachment: Attachment) -> typing.Self:
+        return cls(attachment.photo.expect(NodeError("Attachment is not a photo.")))
+
+
+@scalar_node
+class Video:
+    @classmethod
+    def __compose__(cls, attachment: Attachment) -> telegrinder.types.Video:
+        return attachment.video.expect(NodeError("Attachment is not a video."))
+
+
+@scalar_node
+class VideoNote:
+    @classmethod
+    def __compose__(cls, attachment: Attachment) -> telegrinder.types.VideoNote:
+        return attachment.video_note.expect(NodeError("Attachment is not a video note."))
+
+
+@scalar_node
+class Audio:
+    @classmethod
+    def __compose__(cls, attachment: Attachment) -> telegrinder.types.Audio:
+        return attachment.audio.expect(NodeError("Attachment is not an audio."))
+
+
+@scalar_node
+class Animation:
+    @classmethod
+    def __compose__(cls, attachment: Attachment) -> telegrinder.types.Animation:
+        return attachment.animation.expect(NodeError("Attachment is not an animation."))
+
+
+@scalar_node
+class Voice:
+    @classmethod
+    def __compose__(cls, attachment: Attachment) -> telegrinder.types.Voice:
+        return attachment.voice.expect(NodeError("Attachment is not a voice."))
+
+
+@scalar_node
+class Document:
+    @classmethod
+    def __compose__(cls, attachment: Attachment) -> telegrinder.types.Document:
+        return attachment.document.expect(NodeError("Attachment is not a document."))
+
+
+@scalar_node
+class Poll:
+    @classmethod
+    def __compose__(cls, attachment: Attachment) -> telegrinder.types.Poll:
+        return attachment.poll.expect(NodeError("Attachment is not a poll."))
+
+
+@scalar_node
+class SuccessfulPayment:
+    @classmethod
+    def __compose__(cls, attachment: Attachment) -> telegrinder.types.SuccessfulPayment:
+        return attachment.successful_payment.expect(NodeError("Attachment is not a successful payment."))
+
+
+@dataclasses.dataclass
+class MediaGroup(Node):
+    id: str
+    items: list[MessageCute]
+
+    @classmethod
+    def __compose__(cls, message: MessageCute) -> typing.Self:
+        return cls(
+            id=message.media_group_id.expect(NodeError("No media group id.")),
+            items=message.media_group_messages.expect(NodeError("No messages collected for media group.")),
+        )
+
+
+__all__ = (
+    "Animation",
+    "Attachment",
+    "Audio",
+    "Document",
+    "MediaGroup",
+    "Photo",
+    "Poll",
+    "SuccessfulPayment",
+    "Video",
+    "VideoNote",
+    "Voice",
+)

telegrinder/node/nodes/callback_query.py

@@ -0,0 +1,25 @@
+import typing
+
+from nodnod.error import NodeError
+from nodnod.interface.scalar import scalar_node
+
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+
+
+@scalar_node
+class CallbackQueryData:
+    @classmethod
+    def __compose__(cls, callback_query: CallbackQueryCute) -> str:
+        return callback_query.data.expect(NodeError("Cannot complete decode callback query data."))
+
+
+@scalar_node
+class CallbackQueryDataJson:
+    @classmethod
+    def __compose__(cls, callback_query: CallbackQueryCute) -> dict[str, typing.Any]:
+        return callback_query.decode_data().expect(
+            NodeError("Cannot complete decode callback query data."),
+        )
+
+
+__all__ = ("CallbackQueryData", "CallbackQueryDataJson")

telegrinder/node/nodes/channel.py

@@ -0,0 +1,97 @@
+from nodnod.error import NodeError
+from nodnod.interface.scalar import scalar_node
+from nodnod.node import Scalar
+
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.types.enums import ChatType
+from telegrinder.types.objects import Chat, MessageOriginChannel
+
+type MessageChannelPost = MessageOriginChannel
+type Post = MessageCute
+type PostId = int
+
+
+@scalar_node
+class ChatMessageChannelPost:
+    @classmethod
+    def __compose__(cls, message: MessageCute) -> MessageChannelPost:
+        forward_origin = message.forward_origin.expect(NodeError("Message has no forward origin."))
+        return forward_origin.only(MessageOriginChannel).expect(NodeError("Message forward origin is not a channel."))
+
+
+@scalar_node
+class ChatMessageChannelPostId:
+    @classmethod
+    def __compose__(cls, message_channel_post: ChatMessageChannelPost) -> PostId:
+        return message_channel_post.message_id
+
+
+@scalar_node
+class ChatMessageChannelPostChannel:
+    @classmethod
+    def __compose__(cls, message_channel_post: ChatMessageChannelPost) -> Channel:
+        return message_channel_post.chat
+
+
+@scalar_node
+class ChatMessageChannelPostChannelId:
+    @classmethod
+    def __compose__(cls, message_channel_post: ChatMessageChannelPost) -> ChannelId:
+        return message_channel_post.chat.id
+
+
+@scalar_node
+class ChatMessageChannelPostAuthor:
+    @classmethod
+    def __compose__(cls, message_channel_post: ChatMessageChannelPost) -> str:
+        return message_channel_post.author_signature.expect(
+            NodeError("Discussion has no signature of the post author."),
+        )
+
+
+@scalar_node
+class ChannelPostNode:
+    @classmethod
+    def __compose__(cls, message: MessageCute) -> ChannelPost:
+        if message.chat.type != ChatType.CHANNEL:
+            raise NodeError("Message is not a channel post.")
+        return message
+
+
+@scalar_node
+class ChannelPostId:
+    @classmethod
+    def __compose__(cls, channel_post: ChannelPostNode) -> PostId:
+        return channel_post.message_id
+
+
+@scalar_node
+class ChannelNode:
+    @classmethod
+    def __compose__(cls, channel_post: ChannelPostNode) -> Channel:
+        return channel_post.chat
+
+
+@scalar_node
+class ChannelIdNode:
+    @classmethod
+    def __compose__(cls, channel_post: ChannelPostNode) -> ChannelId:
+        return channel_post.chat.id
+
+
+type Channel = Scalar[Chat, ChannelNode]
+type ChannelId = Scalar[int, ChannelIdNode]
+type ChannelPost = Scalar[MessageCute, ChannelPostNode]
+
+
+__all__ = (
+    "Channel",
+    "ChannelId",
+    "ChannelPost",
+    "ChannelPostId",
+    "ChatMessageChannelPost",
+    "ChatMessageChannelPostAuthor",
+    "ChatMessageChannelPostChannel",
+    "ChatMessageChannelPostChannelId",
+    "ChatMessageChannelPostId",
+)

telegrinder/node/nodes/command.py

@@ -0,0 +1,33 @@
+import typing
+from dataclasses import dataclass, field
+
+from kungfu.library.monad.option import NOTHING, Nothing, Option, Some
+from nodnod.interface.data import Node
+
+from telegrinder.node.nodes.text import Caption, Text
+
+
+def single_split(s: str, separator: str) -> tuple[str, str]:
+    left, *right = s.split(separator, 1)
+    return left, (right[0] if right else "")
+
+
+def cut_mention(text: str) -> tuple[str, Option[str]]:
+    left, right = single_split(text, "@")
+    return left, Some(right) if right else NOTHING
+
+
+@dataclass
+class CommandInfo(Node):
+    name: str
+    arguments: str
+    mention: Option[str] = field(default_factory=Nothing)
+
+    @classmethod
+    def __compose__(cls, text: Text | Caption) -> typing.Self:
+        name, arguments = single_split(text, separator=" ")
+        name, mention = cut_mention(name)
+        return cls(name, arguments, mention)
+
+
+__all__ = ("CommandInfo", "cut_mention", "single_split")

telegrinder/node/nodes/error.py

@@ -0,0 +1,43 @@
+import dataclasses
+import typing
+
+from nodnod.error import NodeError
+from nodnod.interface.generic import generic_node
+from nodnod.node import Node
+
+from telegrinder.bot.dispatch.context import Context
+
+type ExceptionType = type[Exception]
+
+
+def can_catch[ExceptionT: Exception](
+    exc: Exception | ExceptionType,
+    exc_types: type[ExceptionT] | tuple[type[ExceptionT], ...],
+) -> typing.TypeGuard[ExceptionT]:
+    return issubclass(exc, exc_types) if isinstance(exc, type) else isinstance(exc, exc_types)
+
+
+@generic_node
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class Error[*Exceptions = *tuple[type[Exception], ...]](Node):
+    exception_update: Exception
+
+    @property
+    def exception[T: Exception = Exception](self: Error[*tuple[T, ...]]) -> T:
+        return self.exception_update  # type: ignore[reportReturnType]
+
+    @classmethod
+    def __compose__(
+        cls,
+        exceptions: tuple[typing.Unpack[Exceptions]],
+        context: Context,
+    ) -> typing.Self:
+        exception_update = context.exception_update.expect(NodeError("No exception."))
+
+        if can_catch(exception_update, exceptions):  # type: ignore
+            return cls(exception_update=exception_update)
+
+        raise NodeError("Foreign exception.")
+
+
+__all__ = ("Error",)

telegrinder/node/nodes/event.py

@@ -0,0 +1,70 @@
+import dataclasses
+import typing
+
+import msgspec
+from nodnod.error import NodeError
+from nodnod.interface.generic import generic_node
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.msgspec_utils import decoder
+from telegrinder.tools.fullname import fullname
+from telegrinder.types.objects import Model, Update
+
+if typing.TYPE_CHECKING:
+    from _typeshed import DataclassInstance
+
+type DataclassType = DataclassInstance | msgspec.Struct | dict[str, typing.Any]
+
+
+@generic_node
+class EventNode[Dataclass: DataclassType]:  # type: ignore[reportRedeclaration]
+    @classmethod
+    def __compose__(
+        cls,
+        api: API,
+        raw_update: Update,
+        dataclass: type[Dataclass],
+        update_cute: UpdateCute,
+    ) -> DataclassType:
+        orig_dataclass = typing.get_origin(dataclass) or dataclass
+
+        if orig_dataclass is UpdateCute:
+            return update_cute
+
+        if issubclass(orig_dataclass, BaseCute | Model):
+            incoming_update = (
+                update_cute.incoming_update if issubclass(orig_dataclass, BaseCute) else raw_update.incoming_update
+            )
+
+            if type(incoming_update) is not orig_dataclass:
+                raise NodeError(f"Incoming update is not `{fullname(orig_dataclass)}`.")
+
+            return incoming_update
+
+        try:
+            if issubclass(orig_dataclass, msgspec.Struct) or dataclasses.is_dataclass(
+                orig_dataclass,
+            ):
+                obj = decoder.convert(
+                    obj=raw_update.incoming_update,
+                    type=dataclass,
+                    from_attributes=True,
+                )
+            else:
+                obj = dataclass(**raw_update.incoming_update.to_full_dict())
+
+            return obj
+        except Exception as exc:
+            raise NodeError(
+                f"Cannot parse an update object into `{fullname(dataclass)}`",
+                from_error=NodeError(exc),
+            )
+
+
+if typing.TYPE_CHECKING:
+    type EventNode[Dataclass: DataclassType] = Dataclass
+
+
+__all__ = ("EventNode",)

telegrinder/node/nodes/file.py

@@ -0,0 +1,39 @@
+import typing
+
+from nodnod.error import NodeError
+from nodnod.interface.node_constructor import NodeConstructor
+
+import telegrinder.types as tg_types
+from telegrinder.api.api import API
+from telegrinder.node.nodes.attachment import Animation, Audio, Document, Photo, Video, VideoNote, Voice
+
+type Attachment = Animation | Audio | Document | Photo | Video | VideoNote | Voice
+
+
+class FileIdNode(NodeConstructor):
+    def __init__(self, attachment_node: type[Attachment], /) -> None:
+        self.__map__ = {Attachment: attachment_node}
+
+    def __compose__(self, attach: Attachment) -> str:
+        if isinstance(attach, Photo):
+            return attach.sizes[-1].file_id
+        return attach.file_id
+
+
+class FileNode(NodeConstructor):
+    def __init__(self, attachment_node: type[Attachment], /) -> None:
+        self.__map__ = {str: FileIdNode[attachment_node]}
+
+    async def __compose__(self, api: API, file_id: str) -> tg_types.File:
+        return (await api.get_file(file_id=file_id)).expect(NodeError("File can't be downloaded."))
+
+
+if typing.TYPE_CHECKING:
+    type FileId[T: Attachment] = str
+    type File[T: Attachment] = tg_types.File
+else:
+    FileId = FileIdNode
+    File = FileNode
+
+
+__all__ = ("File", "FileId")

telegrinder/node/nodes/global_node.py

@@ -0,0 +1,66 @@
+import typing
+
+from nodnod.error import NodeError
+from nodnod.node import Node
+from nodnod.value import Value
+
+from telegrinder.node.scope import TELEGRINDER_CONTEXT, global_node
+from telegrinder.tools.fullname import fullname
+
+NODEFAULT: typing.Final = object()
+
+_Unspecialized = typing.NewType("_Unspecialized", type)
+
+
+@global_node
+class GlobalNode[T = _Unspecialized](Node, abstract=True):
+    @typing.overload
+    @classmethod
+    def set(cls: type[GlobalNode[_Unspecialized]], value: typing.Self, /) -> None: ...  # type: ignore
+
+    @typing.overload
+    @classmethod
+    def set(cls, value: T, /) -> None: ...
+
+    @classmethod
+    def set(cls, value: T | typing.Self, /) -> None:
+        TELEGRINDER_CONTEXT.node_global_scope.push(Value(cls, value))
+
+    @typing.overload
+    @classmethod
+    def get(cls: type[GlobalNode[_Unspecialized]], /) -> typing.Self:  # type: ignore
+        ...
+
+    @typing.overload
+    @classmethod
+    def get(cls) -> T: ...
+
+    @typing.overload
+    @classmethod
+    def get[Default](cls: type[GlobalNode[_Unspecialized]], *, default: Default) -> typing.Self | Default:  # type: ignore
+        ...
+
+    @typing.overload
+    @classmethod
+    def get[Default](cls, *, default: Default) -> T | Default: ...
+
+    @classmethod
+    def get(cls, *, default: typing.Any = NODEFAULT) -> typing.Any:
+        if default is not NODEFAULT and cls not in TELEGRINDER_CONTEXT.node_global_scope:
+            return default
+
+        if (value := TELEGRINDER_CONTEXT.node_global_scope.get(cls)) is None and default is NODEFAULT:
+            raise NodeError(f"Node `{fullname(cls)}` has no global value.")
+
+        return value.value if value is not None else default
+
+    @classmethod
+    def unset(cls) -> None:
+        TELEGRINDER_CONTEXT.node_global_scope.pop(cls, None)
+
+    @classmethod
+    def __compose__(cls) -> T:
+        return cls.get()
+
+
+__all__ = ("GlobalNode",)

telegrinder/node/nodes/i18n.py

@@ -0,0 +1,110 @@
+import abc
+import dataclasses
+import gettext
+import os
+import pathlib
+import typing
+from functools import cached_property
+
+from nodnod import Node
+
+from telegrinder.node.nodes.global_node import GlobalNode
+from telegrinder.node.nodes.source import Locale
+
+type Separator = KeySeparator
+
+DEFAULT_SEPARATOR: typing.Final = "-"
+
+
+@dataclasses.dataclass(frozen=True)
+class KeySeparator(GlobalNode[Separator]):
+    value: str
+
+    @classmethod
+    def set(cls, value: str, /) -> None:
+        super().set(cls(value))
+
+    @classmethod
+    def compose(cls) -> Separator:
+        return cls.get(default=cls(DEFAULT_SEPARATOR))
+
+
+@dataclasses.dataclass(kw_only=True)
+class ABCTranslator(Node, abc.ABC):
+    locale: str
+    separator: str
+    _keys: list[str] = dataclasses.field(default_factory=list[str], init=False)
+
+    @typing.overload
+    def __call__(self, **context: typing.Any) -> str: ...
+
+    @typing.overload
+    def __call__(self, message_id: str, /, **context: typing.Any) -> str: ...
+
+    def __call__(self, message_id: str | None = None, **context: typing.Any) -> str:
+        result = self.translate(message_id or self.message_id, **context)
+        if not message_id:
+            self._keys.clear()
+        return result
+
+    def __getattr__(self, __key: str) -> typing.Self:
+        self._keys.append(__key)
+        return self
+
+    @property
+    def message_id(self) -> str:
+        return self.separator.join(self._keys)
+
+    @abc.abstractmethod
+    def translate(self, message_id: str, **context: typing.Any) -> str:
+        pass
+
+    @classmethod
+    def compose(cls, locale: Locale, separator: KeySeparator) -> typing.Self:
+        return cls(locale=locale, separator=separator.value)
+
+
+@dataclasses.dataclass
+class I18NConfig:
+    domain: str
+    folder: str | pathlib.Path
+    default_locale: str = dataclasses.field(default="en")
+
+    @cached_property
+    def translators(self) -> dict[str, gettext.GNUTranslations]:
+        result = {}
+
+        for name in os.listdir(self.folder):
+            if not os.path.isdir(os.path.join(self.folder, name)):
+                continue
+
+            mo_path = os.path.join(self.folder, name, "LC_MESSAGES", f"{self.domain}.mo")
+
+            if os.path.exists(mo_path):
+                with open(mo_path, "rb") as f:
+                    result[name] = gettext.GNUTranslations(f)
+            elif os.path.exists(mo_path[:-2] + "po"):
+                raise FileNotFoundError(".po files should be compiled first")
+
+        return result
+
+    def get_translator(self, locale: str, /) -> gettext.GNUTranslations:
+        locale = locale if locale in self.translators else self.default_locale
+        return self.translators[locale]
+
+
+class BaseTranslator(ABCTranslator):
+    config: typing.ClassVar[I18NConfig]
+
+    def __class_getitem__(cls, config: I18NConfig, /) -> typing.Any:
+        return type(cls.__name__, (cls,), dict(config=config, __module__=cls.__module__))
+
+    @classmethod
+    def configure(cls, config: I18NConfig, /) -> None:
+        cls.config = config
+
+    def translate(self, message_id: str, **context: typing.Any) -> str:
+        return self.config.get_translator(self.locale).gettext(message_id).format(**context)
+
+
+__all__ = ("ABCTranslator", "BaseTranslator", "I18NConfig", "KeySeparator")

telegrinder/node/nodes/me.py

@@ -0,0 +1,26 @@
+from nodnod.error import NodeError
+from nodnod.interface.scalar import scalar_node
+
+from telegrinder.api.api import API
+from telegrinder.node.scope import global_node
+from telegrinder.types.objects import User
+
+
+@global_node
+@scalar_node
+class Me:
+    @classmethod
+    async def __compose__(cls, api: API) -> User:
+        me = await api.get_me()
+        return me.expect(NodeError("Can't complete api.get_me() request."))
+
+
+@global_node
+@scalar_node
+class BotUsername:
+    @classmethod
+    def __compose__(cls, me: Me) -> str:
+        return me.username.unwrap()
+
+
+__all__ = ("BotUsername", "Me")

telegrinder/node/nodes/message_entities.py

@@ -0,0 +1,15 @@
+from nodnod.error import NodeError
+from nodnod.interface.scalar import scalar_node
+
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.types.objects import MessageEntity
+
+
+@scalar_node
+class MessageEntities:
+    @classmethod
+    def __compose__(cls, message: MessageCute) -> list[MessageEntity]:
+        return message.entities.expect(NodeError("Message has no entities."))
+
+
+__all__ = ("MessageEntities",)