telegrinder 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

telegrinder/node/__init__.py

@@ -1,6 +1,6 @@
 from .attachment import Attachment, Audio, Photo, Video
-from .base import ComposeError, DataNode, Node, ScalarNode, is_node
-from .callback_query import CallbackQueryNode
+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
@@ -11,13 +11,14 @@ 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
+from .text import Text, TextInteger, TextLiteral
 from .tools import generate_node
 from .update import UpdateNode
 
 __all__ = (
     "Attachment",
     "Audio",
+    "CallbackQueryData",
     "CallbackQueryNode",
     "ChatSource",
     "CommandInfo",
@@ -26,9 +27,11 @@ __all__ = (
     "ContainerNode",
     "DataNode",
     "EventNode",
+    "Field",
     "GLOBAL",
     "Me",
     "MessageNode",
+    "Name",
     "Node",
     "NodeCollection",
     "NodeScope",
@@ -42,6 +45,7 @@ __all__ = (
     "Source",
     "Text",
     "TextInteger",
+    "TextLiteral",
     "UpdateNode",
     "UserSource",
     "Video",

telegrinder/node/attachment.py

@@ -1,92 +1,92 @@
-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.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__ = (
     "Attachment",
     "Audio",
     "Document",
     "Photo",
     "Poll",
-    "Video",
-)
+    "Video",
+)

telegrinder/node/base.py

@@ -1,144 +1,166 @@
-import abc
-import inspect
-import typing
-from types import AsyncGeneratorType
-
-from telegrinder.node.scope import NodeScope
-from telegrinder.tools.magic import cache_magic_value, get_annotations
-
-ComposeResult: typing.TypeAlias = (
-    typing.Awaitable[typing.Any] | typing.AsyncGenerator[typing.Any, None] | typing.Any
-)
-
-
-def is_node(maybe_node: typing.Any) -> typing.TypeGuard[type["Node"]]:
-    maybe_node = maybe_node if isinstance(maybe_node, type) else typing.get_origin(maybe_node)
-    return (
-        isinstance(maybe_node, type)
-        and issubclass(maybe_node, Node)
-        or isinstance(maybe_node, Node)
-        or hasattr(maybe_node, "as_node")
-    )
-
-
-@cache_magic_value("__nodes__")
-def get_nodes(function: typing.Callable[..., typing.Any]) -> dict[str, type["Node"]]:
-    return {k: v for k, v in get_annotations(function).items() if is_node(v)}
-
-
-@cache_magic_value("__is_generator__")
-def is_generator(
-    function: typing.Callable[..., typing.Any],
-) -> typing.TypeGuard[AsyncGeneratorType[typing.Any, None]]:
-    return inspect.isasyncgenfunction(function)
-
-
-def get_node_calc_lst(node: type["Node"]) -> list[type["Node"]]:
-    """Returns flattened list of node types in ordering required to calculate given node.
-    Provides caching for passed node type"""
-
-    if calc_lst := getattr(node, "__nodes_calc_lst__", None):
-        return calc_lst
-    nodes_lst: list[type["Node"]] = []
-    annotations = list(node.as_node().get_subnodes().values())
-    for node_type in annotations:
-        nodes_lst.extend(get_node_calc_lst(node_type))
-    calc_lst = [*nodes_lst, node]
-    setattr(node, "__nodes_calc_lst__", calc_lst)
-    return calc_lst
-
-
-class ComposeError(BaseException):
-    pass
-
-
-class Node(abc.ABC):
-    node: str = "node"
-    scope: NodeScope = NodeScope.PER_EVENT
-
-    @classmethod
-    @abc.abstractmethod
-    def compose(cls, *args, **kwargs) -> ComposeResult:
-        pass
-
-    @classmethod
-    def compose_error(cls, error: str | None = None) -> typing.NoReturn:
-        raise ComposeError(error)
-
-    @classmethod
-    def get_subnodes(cls) -> dict[str, type["Node"]]:
-        return get_nodes(cls.compose)
-
-    @classmethod
-    def as_node(cls) -> type[typing.Self]:
-        return cls
-
-    @classmethod
-    def is_generator(cls) -> bool:
-        return is_generator(cls.compose)
-
-
-class DataNode(Node, abc.ABC):
-    node = "data"
-
-    @typing.dataclass_transform()
-    @classmethod
-    @abc.abstractmethod
-    async def compose(cls, *args, **kwargs) -> ComposeResult:
-        pass
-
-
-class ScalarNodeProto(Node, abc.ABC):
-    @classmethod
-    @abc.abstractmethod
-    async def compose(cls, *args, **kwargs) -> ComposeResult:
-        pass
-
-
-SCALAR_NODE = type("ScalarNode", (), {"node": "scalar"})
-
-
-if typing.TYPE_CHECKING:
-
-    class ScalarNode(ScalarNodeProto, abc.ABC):
-        pass
-
-else:
-
-    def __init_subclass__(cls, *args, **kwargs):  # noqa: N807
-        if any(issubclass(base, ScalarNodeProto) for base in cls.__bases__ if base is not ScalarNode):
-            raise RuntimeError("Scalar nodes do not support inheritance.")
-
-    def _as_node(cls, bases, dct):
-        if not hasattr(cls, "_scalar_node_type"):
-            dct.update(cls.__dict__)
-            scalar_node_type = type(cls.__name__, bases, dct)
-            setattr(cls, "_scalar_node_type", scalar_node_type)
-            return scalar_node_type
-        return getattr(cls, "_scalar_node_type")
-
-    def create_class(name, bases, dct):
-        return type(
-            "Scalar",
-            (SCALAR_NODE,),
-            {
-                "as_node": classmethod(lambda cls: _as_node(cls, bases, dct)),
-                "scope": Node.scope,
-                "__init_subclass__": __init_subclass__,
-            },
-        )
-
-    class ScalarNode(ScalarNodeProto, abc.ABC, metaclass=create_class):
-        pass
-
-
-__all__ = (
-    "ComposeError",
-    "DataNode",
-    "Node",
-    "SCALAR_NODE",
-    "ScalarNode",
-    "ScalarNodeProto",
-    "get_nodes",
-    "is_node",
-)
+import abc
+import inspect
+from types import AsyncGeneratorType
+
+import typing_extensions as typing
+
+from telegrinder.node.scope import NodeScope
+from telegrinder.tools.magic import cache_magic_value, get_annotations
+
+T = typing.TypeVar("T", default=typing.Any)
+
+ComposeResult: typing.TypeAlias = T | typing.Awaitable[T] | typing.AsyncGenerator[T, None]
+
+
+def is_node(maybe_node: typing.Any) -> typing.TypeGuard[type["Node"]]:
+    maybe_node = maybe_node if isinstance(maybe_node, type) else typing.get_origin(maybe_node)
+    return (
+        isinstance(maybe_node, type)
+        and issubclass(maybe_node, Node)
+        or isinstance(maybe_node, Node)
+        or hasattr(maybe_node, "as_node")
+    )
+
+
+@cache_magic_value("__nodes__")
+def get_nodes(function: typing.Callable[..., typing.Any]) -> dict[str, type["Node"]]:
+    return {k: v for k, v in get_annotations(function).items() if is_node(v)}
+
+
+@cache_magic_value("__is_generator__")
+def is_generator(
+    function: typing.Callable[..., typing.Any],
+) -> typing.TypeGuard[AsyncGeneratorType[typing.Any, None]]:
+    return inspect.isasyncgenfunction(function)
+
+
+def get_node_calc_lst(node: type["Node"]) -> list[type["Node"]]:
+    """Returns flattened list of node types in ordering required to calculate given node.
+    Provides caching for passed node type."""
+
+    if calc_lst := getattr(node, "__nodes_calc_lst__", None):
+        return calc_lst
+    nodes_lst: list[type[Node]] = []
+    for node_type in node.as_node().get_subnodes().values():
+        nodes_lst.extend(get_node_calc_lst(node_type))
+    calc_lst = [*nodes_lst, node]
+    setattr(node, "__nodes_calc_lst__", calc_lst)
+    return calc_lst
+
+
+class ComposeError(BaseException):
+    pass
+
+
+class Node(abc.ABC):
+    node: str = "node"
+    scope: NodeScope = NodeScope.PER_EVENT
+
+    @classmethod
+    @abc.abstractmethod
+    def compose(cls, *args, **kwargs) -> ComposeResult:
+        pass
+
+    @classmethod
+    def compose_error(cls, error: str | None = None) -> typing.NoReturn:
+        raise ComposeError(error)
+
+    @classmethod
+    def get_subnodes(cls) -> dict[str, type["Node"]]:
+        return get_nodes(cls.compose)
+
+    @classmethod
+    def as_node(cls) -> type[typing.Self]:
+        return cls
+
+    @classmethod
+    def is_generator(cls) -> bool:
+        return is_generator(cls.compose)
+
+
+@typing.dataclass_transform(kw_only_default=True)
+class FactoryNode(Node, abc.ABC):
+    node = "factory"
+
+    @classmethod
+    @abc.abstractmethod
+    def compose(cls, *args, **kwargs) -> ComposeResult:
+        pass
+
+    def __new__(cls, **context: typing.Any) -> typing.Self:
+        namespace = dict(**cls.__dict__)
+        namespace.pop("__new__", None)
+        return type(cls.__name__, (cls,), context | namespace)  # type: ignore
+
+
+@typing.dataclass_transform()
+class DataNode(Node, abc.ABC):
+    node = "data"
+
+    @classmethod
+    @abc.abstractmethod
+    def compose(cls, *args, **kwargs) -> ComposeResult[typing.Self]:
+        pass
+
+
+class ScalarNodeProto(Node, abc.ABC):
+    @classmethod
+    @abc.abstractmethod
+    def compose(cls, *args, **kwargs) -> ComposeResult:
+        pass
+
+
+SCALAR_NODE = type("ScalarNode", (), {"node": "scalar"})
+
+
+if typing.TYPE_CHECKING:
+
+    class ScalarNode(ScalarNodeProto, abc.ABC):
+        pass
+
+else:
+
+    def __init_subclass__(cls, *args, **kwargs):  # noqa: N807
+        if any(issubclass(base, ScalarNodeProto) for base in cls.__bases__ if base is not ScalarNode):
+            raise RuntimeError("Scalar nodes do not support inheritance.")
+
+    def _as_node(cls, bases, dct):
+        if not hasattr(cls, "_scalar_node_type"):
+            dct.update(cls.__dict__)
+            scalar_node_type = type(cls.__name__, bases, dct)
+            setattr(cls, "_scalar_node_type", scalar_node_type)
+            return scalar_node_type
+        return getattr(cls, "_scalar_node_type")
+
+    def create_class(name, bases, dct):
+        return type(
+            "Scalar",
+            (SCALAR_NODE,),
+            {
+                "as_node": classmethod(lambda cls: _as_node(cls, bases, dct)),
+                "scope": Node.scope,
+                "__init_subclass__": __init_subclass__,
+            },
+        )
+
+    class ScalarNode(ScalarNodeProto, abc.ABC, metaclass=create_class):
+        pass
+
+
+class Name(ScalarNode, str):
+    @classmethod
+    def compose(cls) -> str: ...
+
+
+__all__ = (
+    "ComposeError",
+    "FactoryNode",
+    "DataNode",
+    "Name",
+    "Node",
+    "SCALAR_NODE",
+    "ScalarNode",
+    "ScalarNodeProto",
+    "get_nodes",
+    "is_node",
+)

telegrinder/node/callback_query.py

@@ -1,14 +1,53 @@
-from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
-from telegrinder.node.base import ComposeError, ScalarNode
-from telegrinder.node.update import UpdateNode
-
-
-class CallbackQueryNode(ScalarNode, CallbackQueryCute):
-    @classmethod
-    def compose(cls, update: UpdateNode) -> CallbackQueryCute:
-        if not update.callback_query:
-            raise ComposeError("Update is not a callback_query.")
-        return update.callback_query.unwrap()
-
-
-__all__ = ("CallbackQueryNode",)
+import typing
+
+from fntypes.result import Error, Ok
+
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.msgspec_utils import msgspec_convert
+from telegrinder.node.base import ComposeError, FactoryNode, Name, ScalarNode
+from telegrinder.node.update import UpdateNode
+
+FieldType = typing.TypeVar("FieldType")
+
+
+class CallbackQueryNode(ScalarNode, CallbackQueryCute):
+    @classmethod
+    def compose(cls, update: UpdateNode) -> CallbackQueryCute:
+        if not update.callback_query:
+            raise ComposeError("Update is not a callback_query.")
+        return update.callback_query.unwrap()
+
+
+class CallbackQueryData(ScalarNode, dict[str, typing.Any]):
+    @classmethod
+    def compose(cls, callback_query: CallbackQueryNode) -> dict[str, typing.Any]:
+        return callback_query.decode_callback_data().expect(
+            ComposeError("Cannot complete decode callback query data.")
+        )
+
+
+class _Field(FactoryNode):
+    field_type: type[typing.Any]
+
+    def __class_getitem__(cls, field_type: type[typing.Any], /) -> typing.Self:
+        return cls(field_type=field_type)
+
+    @classmethod
+    def compose(cls, callback_query_data: CallbackQueryData, data_name: Name) -> typing.Any:
+        if data := callback_query_data.get(data_name):
+            match msgspec_convert(data, cls.field_type):
+                case Ok(value):
+                    return value
+                case Error(err):
+                    raise ComposeError(err)
+
+        raise ComposeError(f"Cannot find callback data with name {data_name!r}.")
+
+
+if typing.TYPE_CHECKING:
+    Field = typing.Annotated[FieldType, ...]
+else:
+    Field = _Field
+
+
+__all__ = ("CallbackQueryData", "CallbackQueryNode", "Field")

telegrinder/node/command.py

@@ -1,33 +1,33 @@
-import typing
-from dataclasses import dataclass, field
-
-from fntypes.option import Nothing, Option, Some
-
-from telegrinder.node.base import DataNode
-from telegrinder.node.text import 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(slots=True)
-class CommandInfo(DataNode):
-    name: str
-    arguments: str
-    mention: Option[str] = field(default_factory=Nothing)
-
-    @classmethod
-    def compose(cls, text: Text) -> typing.Self:
-        name, arguments = single_split(text, separator=" ")
-        name, mention = cut_mention(name)
-        return cls(name, arguments, mention)
-
-
-__all__ = ("CommandInfo", "cut_mention", "single_split")
+import typing
+from dataclasses import dataclass, field
+
+from fntypes.option import Nothing, Option, Some
+
+from telegrinder.node.base import DataNode
+from telegrinder.node.text import 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(slots=True)
+class CommandInfo(DataNode):
+    name: str
+    arguments: str
+    mention: Option[str] = field(default_factory=Nothing)
+
+    @classmethod
+    def compose(cls, text: Text) -> typing.Self:
+        name, arguments = single_split(text, separator=" ")
+        name, mention = cut_mention(name)
+        return cls(name, arguments, mention)
+
+
+__all__ = ("CommandInfo", "cut_mention", "single_split")