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

telegrinder/node/__init__.py

@@ -1,54 +1,113 @@
-from .attachment import Attachment, Audio, Photo, Video
-from .base import ComposeError, DataNode, Name, Node, ScalarNode, is_node
-from .callback_query import CallbackQueryData, CallbackQueryNode, Field
-from .command import CommandInfo
-from .composer import Composition, NodeCollection, NodeSession, compose_node, compose_nodes
-from .container import ContainerNode
-from .event import EventNode
-from .me import Me
-from .message import MessageNode
-from .polymorphic import Polymorphic, impl
-from .rule import RuleChain
-from .scope import GLOBAL, PER_CALL, PER_EVENT, NodeScope, global_node, per_call, per_event
-from .source import ChatSource, Source, UserSource
-from .text import Text, TextInteger, TextLiteral
-from .tools import generate_node
-from .update import UpdateNode
-
-__all__ = (
+from .attachment import (
+    Animation,
+    Attachment,
+    Audio,
+    Document,
+    Photo,
+    SuccessfulPayment,
+    Video,
+    VideoNote,
+    Voice,
+)
+from .base import (
+    Composable,
+    ComposeError,
+    DataNode,
+    FactoryNode,
+    GlobalNode,
+    IsNode,
+    Name,
+    Node,
+    NodeComposeFunction,
+    NodeImpersonation,
+    NodeProto,
+    NodeType,
+    as_node,
+    is_node,
+    scalar_node,
+    unwrap_node,
+)
+from .callback_query import (
+    CallbackQueryData,
+    CallbackQueryDataJson,
+    Field,
+)
+from .command import CommandInfo
+from .composer import NodeCollection, NodeSession, compose_node, compose_nodes
+from .container import ContainerNode
+from .either import Either, Optional
+from .event import EventNode
+from .file import File, FileId
+from .me import Me
+from .payload import Payload, PayloadData, PayloadSerializer
+from .polymorphic import Polymorphic, impl
+from .rule import RuleChain
+from .scope import (
+    GLOBAL,
+    PER_CALL,
+    PER_EVENT,
+    NodeScope,
+    global_node,
+    per_call,
+    per_event,
+)
+from .source import ChatSource, Source, UserId, UserSource
+from .text import Text, TextInteger, TextLiteral
+from .tools import generate_node
+
+__all__ = (
+    "Animation",
     "Attachment",
     "Audio",
     "CallbackQueryData",
-    "CallbackQueryNode",
+    "CallbackQueryDataJson",
     "ChatSource",
     "CommandInfo",
+    "Composable",
     "ComposeError",
-    "Composition",
     "ContainerNode",
     "DataNode",
+    "Document",
+    "Either",
     "EventNode",
+    "FactoryNode",
     "Field",
+    "Field",
+    "File",
+    "FileId",
     "GLOBAL",
+    "GlobalNode",
+    "IsNode",
     "Me",
-    "MessageNode",
     "Name",
     "Node",
     "NodeCollection",
+    "NodeComposeFunction",
+    "NodeImpersonation",
+    "NodeProto",
     "NodeScope",
     "NodeSession",
+    "NodeType",
+    "Optional",
     "PER_CALL",
     "PER_EVENT",
+    "Payload",
+    "PayloadData",
+    "PayloadSerializer",
     "Photo",
     "Polymorphic",
     "RuleChain",
-    "ScalarNode",
     "Source",
+    "SuccessfulPayment",
     "Text",
     "TextInteger",
     "TextLiteral",
-    "UpdateNode",
+    "UserId",
     "UserSource",
     "Video",
+    "VideoNote",
+    "Voice",
+    "as_node",
     "compose_node",
     "compose_nodes",
     "generate_node",
@@ -56,5 +115,7 @@ __all__ = (
     "impl",
     "is_node",
     "per_call",
-    "per_event",
-)
+    "per_event",
+    "scalar_node",
+    "unwrap_node",
+)

telegrinder/node/attachment.py

@@ -1,92 +1,168 @@
-import dataclasses
-import typing
-
-from fntypes.co import Option, Some
-from fntypes.option import Nothing
-
-import telegrinder.types
-from telegrinder.node.base import ComposeError, DataNode, ScalarNode
-from telegrinder.node.message import MessageNode
-
-
-@dataclasses.dataclass(slots=True)
-class Attachment(DataNode):
-    attachment_type: typing.Literal["audio", "document", "photo", "poll", "video"]
-    audio: Option[telegrinder.types.Audio] = dataclasses.field(
-        default_factory=lambda: Nothing(),
-        kw_only=True,
-    )
-    document: Option[telegrinder.types.Document] = dataclasses.field(
-        default_factory=lambda: Nothing(),
-        kw_only=True,
-    )
-    photo: Option[list[telegrinder.types.PhotoSize]] = dataclasses.field(
-        default_factory=lambda: Nothing(),
-        kw_only=True,
-    )
-    poll: Option[telegrinder.types.Poll] = dataclasses.field(default_factory=lambda: Nothing(), kw_only=True)
-    video: Option[telegrinder.types.Video] = dataclasses.field(
-        default_factory=lambda: Nothing(),
-        kw_only=True,
-    )
-
-    @classmethod
-    def compose(cls, message: MessageNode) -> "Attachment":
-        for attachment_type in ("audio", "document", "photo", "poll", "video"):
-            match getattr(message, attachment_type, Nothing()):
-                case Some(attachment):
-                    return cls(attachment_type, **{attachment_type: Some(attachment)})
-        return cls.compose_error("No attachment found in message.")
-
-
-@dataclasses.dataclass(slots=True)
-class Photo(DataNode):
-    sizes: list[telegrinder.types.PhotoSize]
-
-    @classmethod
-    def compose(cls, attachment: Attachment) -> typing.Self:
-        if not attachment.photo:
-            raise ComposeError("Attachment is not a photo.")
-        return cls(attachment.photo.unwrap())
-
-
-class Video(ScalarNode, telegrinder.types.Video):
-    @classmethod
-    def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
-        if not attachment.video:
-            raise ComposeError("Attachment is not a video.")
-        return attachment.video.unwrap()
-
-
-class Audio(ScalarNode, telegrinder.types.Audio):
-    @classmethod
-    def compose(cls, attachment: Attachment) -> telegrinder.types.Audio:
-        if not attachment.audio:
-            raise ComposeError("Attachment is not an audio.")
-        return attachment.audio.unwrap()
-
-
-class Document(ScalarNode, telegrinder.types.Document):
-    @classmethod
-    def compose(cls, attachment: Attachment) -> telegrinder.types.Document:
-        if not attachment.document:
-            raise ComposeError("Attachment is not a document.")
-        return attachment.document.unwrap()
-
-
-class Poll(ScalarNode, telegrinder.types.Poll):
-    @classmethod
-    def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
-        if not attachment.poll:
-            raise ComposeError("Attachment is not a poll.")
-        return attachment.poll.unwrap()
-
-
-__all__ = (
+import dataclasses
+import typing
+
+from fntypes.option import Nothing, Option, Some
+
+import telegrinder.types
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.node.base import ComposeError, DataNode, scalar_node
+
+type AttachmentType = typing.Literal[
+    "audio",
+    "animation",
+    "document",
+    "photo",
+    "poll",
+    "voice",
+    "video",
+    "video_note",
+    "successful_payment",
+]
+
+
+@dataclasses.dataclass(slots=True)
+class Attachment(DataNode):
+    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=lambda: 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 get_attachment_types(cls) -> tuple[AttachmentType, ...]:
+        return typing.get_args(AttachmentType.__value__)
+
+    @classmethod
+    def compose(cls, message: MessageCute) -> typing.Self:
+        for attachment_type in cls.get_attachment_types():
+            match getattr(message, attachment_type, Nothing()):
+                case Some(attachment):
+                    return cls(attachment_type, **{attachment_type: Some(attachment)})
+        raise ComposeError("No attachment found in message.")
+
+
+@dataclasses.dataclass(slots=True)
+class Photo(DataNode):
+    sizes: list[telegrinder.types.PhotoSize]
+
+    @classmethod
+    def compose(cls, attachment: Attachment) -> typing.Self:
+        if not attachment.photo:
+            raise ComposeError("Attachment is not a photo.")
+        return cls(attachment.photo.unwrap())
+
+
+@scalar_node
+class Video:
+    @classmethod
+    def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
+        if not attachment.video:
+            raise ComposeError("Attachment is not a video.")
+        return attachment.video.unwrap()
+
+
+@scalar_node
+class VideoNote:
+    @classmethod
+    def compose(cls, attachment: Attachment) -> telegrinder.types.VideoNote:
+        if not attachment.video_note:
+            raise ComposeError("Attachment is not a video note.")
+        return attachment.video_note.unwrap()
+
+
+@scalar_node
+class Audio:
+    @classmethod
+    def compose(cls, attachment: Attachment) -> telegrinder.types.Audio:
+        if not attachment.audio:
+            raise ComposeError("Attachment is not an audio.")
+        return attachment.audio.unwrap()
+
+
+@scalar_node
+class Animation:
+    @classmethod
+    def compose(cls, attachment: Attachment) -> telegrinder.types.Animation:
+        if not attachment.animation:
+            raise ComposeError("Attachment is not an animation.")
+        return attachment.animation.unwrap()
+
+
+@scalar_node
+class Voice:
+    @classmethod
+    def compose(cls, attachment: Attachment) -> telegrinder.types.Voice:
+        if not attachment.voice:
+            raise ComposeError("Attachment is not a voice.")
+        return attachment.voice.unwrap()
+
+
+@scalar_node
+class Document:
+    @classmethod
+    def compose(cls, attachment: Attachment) -> telegrinder.types.Document:
+        if not attachment.document:
+            raise ComposeError("Attachment is not a document.")
+        return attachment.document.unwrap()
+
+
+@scalar_node
+class Poll:
+    @classmethod
+    def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
+        if not attachment.poll:
+            raise ComposeError("Attachment is not a poll.")
+        return attachment.poll.unwrap()
+
+
+@scalar_node
+class SuccessfulPayment:
+    @classmethod
+    def compose(cls, attachment: Attachment) -> telegrinder.types.SuccessfulPayment:
+        if not attachment.successful_payment:
+            raise ComposeError("Attachment is not a successful payment.")
+        return attachment.successful_payment.unwrap()
+
+
+__all__ = (
+    "Animation",
     "Attachment",
     "Audio",
     "Document",
     "Photo",
     "Poll",
-    "Video",
-)
+    "SuccessfulPayment",
+    "Video",
+    "VideoNote",
+    "Voice",
+)