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

telegrinder/node/attachment.py

@@ -1,42 +1,74 @@
 import dataclasses
 import typing
 
-from fntypes.co import Option, Some
-from fntypes.option import Nothing
+from fntypes.option import Nothing, Option, Some
 
 import telegrinder.types
-from telegrinder.node.base import ComposeError, DataNode, ScalarNode
-from telegrinder.node.message import MessageNode
+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: typing.Literal["audio", "document", "photo", "poll", "video"]
+    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=lambda: Nothing(),
+        default_factory=Nothing,
         kw_only=True,
     )
     document: Option[telegrinder.types.Document] = dataclasses.field(
-        default_factory=lambda: Nothing(),
+        default_factory=Nothing,
         kw_only=True,
     )
     photo: Option[list[telegrinder.types.PhotoSize]] = dataclasses.field(
-        default_factory=lambda: Nothing(),
+        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=lambda: Nothing(),
+        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: MessageNode) -> "Attachment":
-        for attachment_type in ("audio", "document", "photo", "poll", "video"):
+    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)})
-        return cls.compose_error("No attachment found in message.")
+        raise ComposeError("No attachment found in message.")
 
 
 @dataclasses.dataclass(slots=True)
@@ -50,7 +82,8 @@ class Photo(DataNode):
         return cls(attachment.photo.unwrap())
 
 
-class Video(ScalarNode, telegrinder.types.Video):
+@scalar_node
+class Video:
     @classmethod
     def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
         if not attachment.video:
@@ -58,7 +91,17 @@ class Video(ScalarNode, telegrinder.types.Video):
         return attachment.video.unwrap()
 
 
-class Audio(ScalarNode, telegrinder.types.Audio):
+@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:
@@ -66,7 +109,26 @@ class Audio(ScalarNode, telegrinder.types.Audio):
         return attachment.audio.unwrap()
 
 
-class Document(ScalarNode, telegrinder.types.Document):
+@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:
@@ -74,7 +136,8 @@ class Document(ScalarNode, telegrinder.types.Document):
         return attachment.document.unwrap()
 
 
-class Poll(ScalarNode, telegrinder.types.Poll):
+@scalar_node
+class Poll:
     @classmethod
     def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
         if not attachment.poll:
@@ -82,11 +145,24 @@ class Poll(ScalarNode, telegrinder.types.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",
+    "SuccessfulPayment",
     "Video",
+    "VideoNote",
+    "Voice",
 )

telegrinder/node/base.py

@@ -1,57 +1,164 @@
+from __future__ import annotations
+
 import abc
 import inspect
-from types import AsyncGeneratorType
+from collections import deque
+from types import AsyncGeneratorType, CodeType, resolve_bases
 
 import typing_extensions as typing
 
 from telegrinder.node.scope import NodeScope
 from telegrinder.tools.magic import cache_magic_value, get_annotations
+from telegrinder.tools.strings import to_pascal_case
+
+if typing.TYPE_CHECKING:
+    from telegrinder.node.tools.generator import generate_node
+else:
+
+    def generate_node(*args, **kwargs):
+        globalns = globals()
+        if "__generate_node" not in globalns:
+            import telegrinder.node.tools.generator
+
+            globals()["__generate_node"] = telegrinder.node.tools.generator.generate_node
+
+        return globals()["__generate_node"](*args, **kwargs)
+
+
+type NodeType = Node | NodeProto[typing.Any]
+type IsNode = NodeType | type[NodeType]
 
 T = typing.TypeVar("T", default=typing.Any)
 
 ComposeResult: typing.TypeAlias = T | typing.Awaitable[T] | typing.AsyncGenerator[T, None]
 
+UNWRAPPED_NODE_KEY = "__unwrapped_node__"
+
+
+@typing.overload
+def is_node(maybe_node: type[typing.Any], /) -> typing.TypeIs[type[NodeType]]: ...
+
+
+@typing.overload
+def is_node(maybe_node: typing.Any, /) -> typing.TypeIs[NodeType]: ...
+
+
+def is_node(maybe_node: typing.Any, /) -> bool:
+    if isinstance(maybe_node, typing.TypeAliasType):
+        maybe_node = maybe_node.__value__
+    if not isinstance(maybe_node, type):
+        maybe_node = typing.get_origin(maybe_node) or maybe_node
 
-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")
+        hasattr(maybe_node, "as_node")
+        or isinstance(maybe_node, type)
+        and issubclass(maybe_node, (Node, NodeProto))
+        or not isinstance(maybe_node, type)
+        and isinstance(maybe_node, (Node, NodeProto))
     )
 
 
+@typing.overload
+def as_node(maybe_node: type[typing.Any], /) -> type[NodeType]: ...
+
+
+@typing.overload
+def as_node(maybe_node: typing.Any, /) -> NodeType: ...
+
+
+@typing.overload
+def as_node(*maybe_nodes: type[typing.Any]) -> tuple[type[NodeType], ...]: ...
+
+
+@typing.overload
+def as_node(*maybe_nodes: typing.Any) -> tuple[NodeType, ...]: ...
+
+
+@typing.overload
+def as_node(*maybe_nodes: type[typing.Any] | typing.Any) -> tuple[IsNode, ...]: ...
+
+
+def as_node(*maybe_nodes: typing.Any) -> typing.Any | tuple[typing.Any, ...]:
+    for maybe_node in maybe_nodes:
+        if not is_node(maybe_node):
+            is_type = isinstance(maybe_node, type)
+            raise LookupError(
+                f"{'Type of' if is_type else 'Object of type'} "
+                f"{maybe_node.__name__ if is_type else maybe_node.__class__.__name__!r} "
+                "cannot be resolved as Node."
+            )
+    return maybe_nodes[0] if len(maybe_nodes) == 1 else maybe_nodes
+
+
 @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)}
+def get_nodes(function: typing.Callable[..., typing.Any], /) -> dict[str, type[NodeType]]:
+    return {k: v.as_node() 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."""
+def unwrap_node(node: type[NodeType], /) -> tuple[type[NodeType], ...]:
+    """Unwrap node as flattened tuple of node types in ordering required to calculate given node.
 
-    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
+    Provides caching for passed node type.
+    """
+    if (unwrapped := getattr(node, UNWRAPPED_NODE_KEY, None)) is not None:
+        return unwrapped
+
+    stack = deque([(node, node.get_subnodes().values())])
+    visited = list[type[NodeType]]()
+
+    while stack:
+        parent, child_nodes = stack.pop()
+
+        if parent not in visited:
+            visited.insert(0, parent)
+
+        for child in child_nodes:
+            stack.append((child, child.get_subnodes().values()))
+
+    unwrapped = tuple(visited)
+    setattr(node, UNWRAPPED_NODE_KEY, unwrapped)
+    return unwrapped
 
 
 class ComposeError(BaseException):
     pass
 
 
+@typing.runtime_checkable
+class Composable[R](typing.Protocol):
+    @classmethod
+    def compose(cls, *args: typing.Any, **kwargs: typing.Any) -> ComposeResult[R]: ...
+
+
+class NodeImpersonation(typing.Protocol):
+    @classmethod
+    def as_node(cls) -> type[NodeProto[typing.Any]]: ...
+
+
+class NodeComposeFunction[R](typing.Protocol):
+    __name__: str
+    __code__: CodeType
+
+    def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> ComposeResult[R]: ...
+
+
+@typing.runtime_checkable
+class NodeProto[R](Composable[R], NodeImpersonation, typing.Protocol):
+    @classmethod
+    def get_subnodes(cls) -> dict[str, type[NodeType]]: ...
+
+    @classmethod
+    def is_generator(cls) -> bool: ...
+
+
 class Node(abc.ABC):
     node: str = "node"
     scope: NodeScope = NodeScope.PER_EVENT
@@ -62,11 +169,7 @@ class Node(abc.ABC):
         pass
 
     @classmethod
-    def compose_error(cls, error: str | None = None) -> typing.NoReturn:
-        raise ComposeError(error)
-
-    @classmethod
-    def get_subnodes(cls) -> dict[str, type["Node"]]:
+    def get_subnodes(cls) -> dict[str, type[NodeType]]:
         return get_nodes(cls.compose)
 
     @classmethod
@@ -78,6 +181,41 @@ class Node(abc.ABC):
         return is_generator(cls.compose)
 
 
+class scalar_node[T]:  # noqa: N801
+    @typing.overload
+    def __new__(cls, x: NodeComposeFunction[Composable[T]], /) -> type[T]: ...
+
+    @typing.overload
+    def __new__(cls, x: NodeComposeFunction[T], /) -> type[T]: ...
+
+    @typing.overload
+    def __new__(
+        cls,
+        /,
+        *,
+        scope: NodeScope,
+    ) -> typing.Callable[[NodeComposeFunction[Composable[T]] | NodeComposeFunction[T]], type[T]]: ...
+
+    def __new__(cls, x=None, /, *, scope=NodeScope.PER_EVENT) -> typing.Any:
+        def inner(node_or_func, /) -> typing.Any:
+            namespace = {"node": "scalar", "scope": scope, "__module__": node_or_func.__module__}
+
+            if isinstance(node_or_func, type):
+                bases: list[type[typing.Any]] = [node_or_func]
+                node_bases = resolve_bases(node_or_func.__bases__)
+                if not any(issubclass(base, Node) for base in node_bases if isinstance(base, type)):
+                    bases.append(Node)
+                return type(node_or_func.__name__, tuple(bases), namespace)
+            else:
+                base_node = generate_node(
+                    func=node_or_func,
+                    subnodes=tuple(get_nodes(node_or_func).values()),
+                )
+                return type(to_pascal_case(node_or_func.__name__), (base_node,), namespace)
+
+        return inner if x is None else inner(x)
+
+
 @typing.dataclass_transform(kw_only_default=True)
 class FactoryNode(Node, abc.ABC):
     node = "factory"
@@ -87,10 +225,10 @@ class FactoryNode(Node, abc.ABC):
     def compose(cls, *args, **kwargs) -> ComposeResult:
         pass
 
-    def __new__(cls, **context: typing.Any) -> typing.Self:
+    def __new__(cls, **context: typing.Any) -> type[typing.Self]:
         namespace = dict(**cls.__dict__)
         namespace.pop("__new__", None)
-        return type(cls.__name__, (cls,), context | namespace)  # type: ignore
+        return type(cls.__name__, (cls,), namespace | context)  # type: ignore
 
 
 @typing.dataclass_transform()
@@ -103,64 +241,54 @@ class DataNode(Node, abc.ABC):
         pass
 
 
-class ScalarNodeProto(Node, abc.ABC):
+@scalar_node(scope=NodeScope.PER_CALL)
+class Name:
     @classmethod
-    @abc.abstractmethod
-    def compose(cls, *args, **kwargs) -> ComposeResult:
-        pass
-
-
-SCALAR_NODE = type("ScalarNode", (), {"node": "scalar"})
+    def compose(cls) -> str: ...
 
 
-if typing.TYPE_CHECKING:
+class GlobalNode[Value](Node):
+    scope = NodeScope.GLOBAL
 
-    class ScalarNode(ScalarNodeProto, abc.ABC):
-        pass
+    @classmethod
+    def set(cls, value: Value, /) -> None:
+        setattr(cls, "_value", value)
 
-else:
+    @typing.overload
+    @classmethod
+    def get(cls) -> Value: ...
 
-    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
+    @typing.overload
+    @classmethod
+    def get[Default](cls, *, default: Default) -> Value | Default: ...
 
+    @classmethod
+    def get(cls, **kwargs: typing.Any) -> typing.Any:
+        sentinel = object()
+        default = kwargs.pop("default", sentinel)
+        return getattr(cls, "_value") if default is sentinel else getattr(cls, "_value", default)
 
-class Name(ScalarNode, str):
     @classmethod
-    def compose(cls) -> str: ...
+    def unset(cls) -> None:
+        if hasattr(cls, "_value"):
+            delattr(cls, "_value")
 
 
 __all__ = (
+    "Composable",
     "ComposeError",
     "DataNode",
     "FactoryNode",
+    "GlobalNode",
+    "IsNode",
     "Name",
     "Node",
-    "SCALAR_NODE",
-    "ScalarNode",
-    "ScalarNodeProto",
+    "NodeImpersonation",
+    "NodeProto",
+    "NodeType",
+    "as_node",
     "get_nodes",
     "is_node",
+    "scalar_node",
+    "unwrap_node",
 )

telegrinder/node/callback_query.py

@@ -4,25 +4,22 @@ 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
+from telegrinder.node.base import ComposeError, FactoryNode, Name, scalar_node
 
-FieldType = typing.TypeVar("FieldType")
 
-
-class CallbackQueryNode(ScalarNode, CallbackQueryCute):
+@scalar_node
+class CallbackQueryData:
     @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()
+    def compose(cls, callback_query: CallbackQueryCute) -> str:
+        return callback_query.data.expect(ComposeError("Cannot complete decode callback query data."))
 
 
-class CallbackQueryData(ScalarNode, dict[str, typing.Any]):
+@scalar_node
+class CallbackQueryDataJson:
     @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.")
+    def compose(cls, callback_query: CallbackQueryCute) -> dict:
+        return callback_query.decode_data().expect(
+            ComposeError("Cannot complete decode callback query data."),
         )
 
 
@@ -33,7 +30,7 @@ class _Field(FactoryNode):
         return cls(field_type=field_type)
 
     @classmethod
-    def compose(cls, callback_query_data: CallbackQueryData, data_name: Name) -> typing.Any:
+    def compose(cls, callback_query_data: CallbackQueryDataJson, data_name: Name) -> typing.Any:
         if data := callback_query_data.get(data_name):
             match msgspec_convert(data, cls.field_type):
                 case Ok(value):
@@ -45,9 +42,13 @@ class _Field(FactoryNode):
 
 
 if typing.TYPE_CHECKING:
-    Field = typing.Annotated[FieldType, ...]
+    type Field[FieldType] = typing.Annotated[FieldType, ...]
 else:
     Field = _Field
 
 
-__all__ = ("CallbackQueryData", "CallbackQueryNode", "Field")
+__all__ = (
+    "CallbackQueryData",
+    "CallbackQueryDataJson",
+    "Field",
+)

telegrinder/node/command.py

@@ -4,7 +4,8 @@ from dataclasses import dataclass, field
 from fntypes.option import Nothing, Option, Some
 
 from telegrinder.node.base import DataNode
-from telegrinder.node.text import Text
+from telegrinder.node.either import Either
+from telegrinder.node.text import Caption, Text
 
 
 def single_split(s: str, separator: str) -> tuple[str, str]:
@@ -24,7 +25,7 @@ class CommandInfo(DataNode):
     mention: Option[str] = field(default_factory=Nothing)
 
     @classmethod
-    def compose(cls, text: Text) -> typing.Self:
+    def compose(cls, text: Either[Text, Caption]) -> typing.Self:
         name, arguments = single_split(text, separator=" ")
         name, mention = cut_mention(name)
         return cls(name, arguments, mention)