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

telegrinder/node/__init__.py

@@ -1,21 +1,21 @@
-from .attachment import Attachment, Audio, Photo, Video
-from .base import ComposeError, DataNode, Node, ScalarNode, is_node
-from .callback_query import CallbackQueryNode
-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
-from .tools import generate_node
-from .update import UpdateNode
-
-__all__ = (
+from .attachment import Attachment, Audio, Photo, Video
+from .base import ComposeError, DataNode, Node, ScalarNode, is_node
+from .callback_query import CallbackQueryNode
+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
+from .tools import generate_node
+from .update import UpdateNode
+
+__all__ = (
     "Attachment",
     "Audio",
     "CallbackQueryNode",
@@ -52,5 +52,5 @@ __all__ = (
     "impl",
     "is_node",
     "per_call",
-    "per_event",
-)
+    "per_event",
+)

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

telegrinder/node/base.py

@@ -1,144 +1,143 @@
-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
+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]] = []
+    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)
+
+
+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",
+)

telegrinder/node/callback_query.py

@@ -1,14 +1,14 @@
-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",)
+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",)

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")