telegrinder 0.3.3.post1__py3-none-any.whl → 0.3.4.post1__py3-none-any.whl

telegrinder/node/me.py

@@ -1,16 +1,16 @@
-from telegrinder.api.api import API
-from telegrinder.node.base import ComposeError, ScalarNode
-from telegrinder.node.scope import GLOBAL
-from telegrinder.types.objects import User
-
-
-class Me(ScalarNode, User):
-    scope = GLOBAL
-
-    @classmethod
-    async def compose(cls, api: API) -> User:
-        me = await api.get_me()
-        return me.expect(ComposeError("Can't complete get_me request"))
-
-
-__all__ = ("Me",)
+from telegrinder.api.api import API
+from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.scope import GLOBAL
+from telegrinder.types.objects import User
+
+
+class Me(ScalarNode, User):
+    scope = GLOBAL
+
+    @classmethod
+    async def compose(cls, api: API) -> User:
+        me = await api.get_me()
+        return me.expect(ComposeError("Can't complete get_me request"))
+
+
+__all__ = ("Me",)

telegrinder/node/message.py

@@ -1,14 +1,14 @@
-from telegrinder.bot.cute_types.message import MessageCute
-from telegrinder.node.base import ComposeError, ScalarNode
-from telegrinder.node.update import UpdateNode
-
-
-class MessageNode(ScalarNode, MessageCute):
-    @classmethod
-    def compose(cls, update: UpdateNode) -> MessageCute:
-        if not update.message:
-            raise ComposeError("Update is not a message.")
-        return update.message.unwrap()
-
-
-__all__ = ("MessageNode",)
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.update import UpdateNode
+
+
+class MessageNode(ScalarNode, MessageCute):
+    @classmethod
+    def compose(cls, update: UpdateNode) -> MessageCute:
+        if not update.message:
+            raise ComposeError("Update is not a message.")
+        return update.message.unwrap()
+
+
+__all__ = ("MessageNode",)

telegrinder/node/polymorphic.py

@@ -1,48 +1,48 @@
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.modules import logger
-from telegrinder.node.base import ComposeError, Node
-from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
-from telegrinder.node.scope import NodeScope
-from telegrinder.node.update import UpdateNode
-from telegrinder.tools.magic import get_impls, impl
-
-
-class Polymorphic(Node):
-    @classmethod
-    async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
-        logger.debug(f"Composing polymorphic node {cls.__name__!r}...")
-        scope = getattr(cls, "scope", None)
-        node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
-
-        for i, impl_ in enumerate(get_impls(cls)):
-            logger.debug("Checking impl {!r}...", impl_.__name__)
-            composition = Composition(impl_, True)
-            node_collection = await composition.compose_nodes(update, context)
-            if node_collection is None:
-                logger.debug("Impl {!r} composition failed!", impl_.__name__)
-                continue
-
-            # To determine whether this is a right morph, all subnodes must be resolved
-            if scope is NodeScope.PER_EVENT and (cls, i) in node_ctx:
-                logger.debug(
-                    "Morph is already cached as per_event node, using its value. Impl {!r} succeeded!",
-                    impl_.__name__,
-                )
-                res: NodeSession = node_ctx[(cls, i)]
-                await node_collection.close_all()
-                return res.value
-
-            result = await composition(cls, **node_collection.values)
-            if scope is NodeScope.PER_EVENT:
-                node_ctx[(cls, i)] = NodeSession(cls, result, {})
-
-            await node_collection.close_all(with_value=result)
-            logger.debug("Impl {!r} succeeded with value: {!r}", impl_.__name__, result)
-            return result
-
-        raise ComposeError("No implementation found.")
-
-
-__all__ = ("Polymorphic", "impl")
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.modules import logger
+from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
+from telegrinder.node.scope import NodeScope
+from telegrinder.node.update import UpdateNode
+from telegrinder.tools.magic import get_impls, impl
+
+
+class Polymorphic(Node):
+    @classmethod
+    async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
+        logger.debug(f"Composing polymorphic node {cls.__name__!r}...")
+        scope = getattr(cls, "scope", None)
+        node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+
+        for i, impl_ in enumerate(get_impls(cls)):
+            logger.debug("Checking impl {!r}...", impl_.__name__)
+            composition = Composition(impl_, True)
+            node_collection = await composition.compose_nodes(update, context)
+            if node_collection is None:
+                logger.debug("Impl {!r} composition failed!", impl_.__name__)
+                continue
+
+            # To determine whether this is a right morph, all subnodes must be resolved
+            if scope is NodeScope.PER_EVENT and (cls, i) in node_ctx:
+                logger.debug(
+                    "Morph is already cached as per_event node, using its value. Impl {!r} succeeded!",
+                    impl_.__name__,
+                )
+                res: NodeSession = node_ctx[(cls, i)]
+                await node_collection.close_all()
+                return res.value
+
+            result = await composition(cls, **node_collection.values)
+            if scope is NodeScope.PER_EVENT:
+                node_ctx[(cls, i)] = NodeSession(cls, result, {})
+
+            await node_collection.close_all(with_value=result)
+            logger.debug("Impl {!r} succeeded with value: {!r}", impl_.__name__, result)
+            return result
+
+        raise ComposeError("No implementation found.")
+
+
+__all__ = ("Polymorphic", "impl")

telegrinder/node/rule.py

@@ -1,76 +1,76 @@
-import dataclasses
-import importlib
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.base import ComposeError, Node
-from telegrinder.node.update import UpdateNode
-
-if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch.process import check_rule
-    from telegrinder.bot.rules.abc import ABCRule
-
-
-class RuleChain(dict[str, typing.Any], Node):
-    dataclass: type[typing.Any] = dict
-    rules: tuple["ABCRule", ...] = ()
-
-    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
-        super().__init_subclass__(*args, **kwargs)
-
-        if cls.__name__ == "_RuleNode":
-            return
-        cls.dataclass = cls.generate_node_dataclass(cls)
-
-    def __new__(cls, *rules: "ABCRule") -> type[Node]:
-        return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
-
-    def __class_getitem__(cls, items: "ABCRule | tuple[ABCRule, ...]", /) -> typing.Self:
-        if not isinstance(items, tuple):
-            items = (items,)
-        return cls(*items)
-
-    @staticmethod
-    def generate_node_dataclass(cls_: type["RuleChain"]):  # noqa: ANN205
-        return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
-
-    @classmethod
-    async def compose(cls, update: UpdateNode) -> typing.Any:
-        # Hack to avoid circular import
-        globalns = globals()
-        if "check_rule" not in globalns:
-            globalns.update(
-                {
-                    "check_rule": getattr(
-                        importlib.import_module("telegrinder.bot.dispatch.process"),
-                        "check_rule",
-                    ),
-                },
-            )
-
-        ctx = Context()
-        for rule in cls.rules:
-            if not await check_rule(update.api, rule, update, ctx):
-                raise ComposeError(f"Rule {rule!r} failed!")
-
-        try:
-            if dataclasses.is_dataclass(cls.dataclass):
-                return cls.dataclass(**{k: ctx[k] for k in cls.__annotations__})
-            return cls.dataclass(**ctx)
-        except Exception as exc:
-            raise ComposeError(f"Dataclass validation error: {exc}")
-
-    @classmethod
-    def as_node(cls) -> type[typing.Self]:
-        return cls
-
-    @classmethod
-    def get_subnodes(cls) -> dict[typing.Literal["update"], type[UpdateNode]]:
-        return {"update": UpdateNode}
-
-    @classmethod
-    def is_generator(cls) -> typing.Literal[False]:
-        return False
-
-
-__all__ = ("RuleChain",)
+import dataclasses
+import importlib
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.update import UpdateNode
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.process import check_rule
+    from telegrinder.bot.rules.abc import ABCRule
+
+
+class RuleChain(dict[str, typing.Any], Node):
+    dataclass: type[typing.Any] = dict
+    rules: tuple["ABCRule", ...] = ()
+
+    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
+        super().__init_subclass__(*args, **kwargs)
+
+        if cls.__name__ == "_RuleNode":
+            return
+        cls.dataclass = cls.generate_node_dataclass(cls)
+
+    def __new__(cls, *rules: "ABCRule") -> type[Node]:
+        return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
+
+    def __class_getitem__(cls, items: "ABCRule | tuple[ABCRule, ...]", /) -> typing.Self:
+        if not isinstance(items, tuple):
+            items = (items,)
+        return cls(*items)
+
+    @staticmethod
+    def generate_node_dataclass(cls_: type["RuleChain"]):  # noqa: ANN205
+        return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
+
+    @classmethod
+    async def compose(cls, update: UpdateNode) -> typing.Any:
+        # Hack to avoid circular import
+        globalns = globals()
+        if "check_rule" not in globalns:
+            globalns.update(
+                {
+                    "check_rule": getattr(
+                        importlib.import_module("telegrinder.bot.dispatch.process"),
+                        "check_rule",
+                    ),
+                },
+            )
+
+        ctx = Context()
+        for rule in cls.rules:
+            if not await check_rule(update.api, rule, update, ctx):
+                raise ComposeError(f"Rule {rule!r} failed!")
+
+        try:
+            if dataclasses.is_dataclass(cls.dataclass):
+                return cls.dataclass(**{k: ctx[k] for k in cls.__annotations__})
+            return cls.dataclass(**ctx)
+        except Exception as exc:
+            raise ComposeError(f"Dataclass validation error: {exc}")
+
+    @classmethod
+    def as_node(cls) -> type[typing.Self]:
+        return cls
+
+    @classmethod
+    def get_subnodes(cls) -> dict[typing.Literal["update"], type[UpdateNode]]:
+        return {"update": UpdateNode}
+
+    @classmethod
+    def is_generator(cls) -> typing.Literal[False]:
+        return False
+
+
+__all__ = ("RuleChain",)

telegrinder/node/scope.py

@@ -1,44 +1,44 @@
-import enum
-import typing
-
-if typing.TYPE_CHECKING:
-    from .base import Node
-
-T = typing.TypeVar("T", bound=type["Node"])
-
-
-class NodeScope(enum.Enum):
-    GLOBAL = enum.auto()
-    PER_EVENT = enum.auto()
-    PER_CALL = enum.auto()
-
-
-PER_EVENT = NodeScope.PER_EVENT
-PER_CALL = NodeScope.PER_CALL
-GLOBAL = NodeScope.GLOBAL
-
-
-def per_call(node: T) -> T:
-    setattr(node, "scope", PER_CALL)
-    return node
-
-
-def per_event(node: T) -> T:
-    setattr(node, "scope", PER_EVENT)
-    return node
-
-
-def global_node(node: T) -> T:
-    setattr(node, "scope", GLOBAL)
-    return node
-
-
-__all__ = (
+import enum
+import typing
+
+if typing.TYPE_CHECKING:
+    from .base import Node
+
+T = typing.TypeVar("T", bound=type["Node"])
+
+
+class NodeScope(enum.Enum):
+    GLOBAL = enum.auto()
+    PER_EVENT = enum.auto()
+    PER_CALL = enum.auto()
+
+
+PER_EVENT = NodeScope.PER_EVENT
+PER_CALL = NodeScope.PER_CALL
+GLOBAL = NodeScope.GLOBAL
+
+
+def per_call(node: T) -> T:
+    setattr(node, "scope", PER_CALL)
+    return node
+
+
+def per_event(node: T) -> T:
+    setattr(node, "scope", PER_EVENT)
+    return node
+
+
+def global_node(node: T) -> T:
+    setattr(node, "scope", GLOBAL)
+    return node
+
+
+__all__ = (
     "GLOBAL",
     "NodeScope",
     "PER_CALL",
     "PER_EVENT",
     "global_node",
     "per_call",
-    "per_event",
-)
+    "per_event",
+)

telegrinder/node/source.py

@@ -1,71 +1,71 @@
-import dataclasses
-import typing
-
-from fntypes.option import Nothing, Option
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types import ChatJoinRequestCute
-from telegrinder.node.base import ComposeError, DataNode, ScalarNode
-from telegrinder.node.callback_query import CallbackQueryNode
-from telegrinder.node.event import EventNode
-from telegrinder.node.message import MessageNode
-from telegrinder.node.polymorphic import Polymorphic, impl
-from telegrinder.types.objects import Chat, Message, User
-
-
-@dataclasses.dataclass(kw_only=True, slots=True)
-class Source(Polymorphic, DataNode):
-    api: API
-    chat: Chat
-    from_user: User
-    thread_id: Option[int] = dataclasses.field(default_factory=lambda: Nothing())
-
-    @impl
-    def compose_message(cls, message: MessageNode) -> typing.Self:
-        return cls(
-            api=message.ctx_api,
-            chat=message.chat,
-            from_user=message.from_.expect(ComposeError("MessageNode has no from_user")),
-            thread_id=message.message_thread_id,
-        )
-
-    @impl
-    def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
-        return cls(
-            api=callback_query.ctx_api,
-            chat=callback_query.chat.expect(ComposeError("CallbackQueryNode has no chat")),
-            from_user=callback_query.from_user,
-            thread_id=callback_query.message_thread_id,
-        )
-
-    @impl
-    def compose_chat_join_request(cls, chat_join_request: EventNode[ChatJoinRequestCute]) -> typing.Self:
-        return cls(
-            api=chat_join_request.ctx_api,
-            chat=chat_join_request.chat,
-            from_user=chat_join_request.from_user,
-            thread_id=Nothing(),
-        )
-
-    async def send(self, text: str) -> Message:
-        result = await self.api.send_message(
-            chat_id=self.chat.id,
-            message_thread_id=self.thread_id.unwrap_or_none(),
-            text=text,
-        )
-        return result.unwrap()
-
-
-class ChatSource(ScalarNode, Chat):
-    @classmethod
-    def compose(cls, source: Source) -> Chat:
-        return source.chat
-
-
-class UserSource(ScalarNode, User):
-    @classmethod
-    def compose(cls, source: Source) -> User:
-        return source.from_user
-
-
-__all__ = ("ChatSource", "Source", "UserSource")
+import dataclasses
+import typing
+
+from fntypes.option import Nothing, Option
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types import ChatJoinRequestCute
+from telegrinder.node.base import ComposeError, DataNode, ScalarNode
+from telegrinder.node.callback_query import CallbackQueryNode
+from telegrinder.node.event import EventNode
+from telegrinder.node.message import MessageNode
+from telegrinder.node.polymorphic import Polymorphic, impl
+from telegrinder.types.objects import Chat, Message, User
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class Source(Polymorphic, DataNode):
+    api: API
+    chat: Chat
+    from_user: User
+    thread_id: Option[int] = dataclasses.field(default_factory=lambda: Nothing())
+
+    @impl
+    def compose_message(cls, message: MessageNode) -> typing.Self:
+        return cls(
+            api=message.ctx_api,
+            chat=message.chat,
+            from_user=message.from_.expect(ComposeError("MessageNode has no from_user")),
+            thread_id=message.message_thread_id,
+        )
+
+    @impl
+    def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
+        return cls(
+            api=callback_query.ctx_api,
+            chat=callback_query.chat.expect(ComposeError("CallbackQueryNode has no chat")),
+            from_user=callback_query.from_user,
+            thread_id=callback_query.message_thread_id,
+        )
+
+    @impl
+    def compose_chat_join_request(cls, chat_join_request: EventNode[ChatJoinRequestCute]) -> typing.Self:
+        return cls(
+            api=chat_join_request.ctx_api,
+            chat=chat_join_request.chat,
+            from_user=chat_join_request.from_user,
+            thread_id=Nothing(),
+        )
+
+    async def send(self, text: str) -> Message:
+        result = await self.api.send_message(
+            chat_id=self.chat.id,
+            message_thread_id=self.thread_id.unwrap_or_none(),
+            text=text,
+        )
+        return result.unwrap()
+
+
+class ChatSource(ScalarNode, Chat):
+    @classmethod
+    def compose(cls, source: Source) -> Chat:
+        return source.chat
+
+
+class UserSource(ScalarNode, User):
+    @classmethod
+    def compose(cls, source: Source) -> User:
+        return source.from_user
+
+
+__all__ = ("ChatSource", "Source", "UserSource")

telegrinder/node/text.py

@@ -1,41 +1,41 @@
-import typing
-
-from telegrinder.node.base import ComposeError, FactoryNode, ScalarNode
-from telegrinder.node.message import MessageNode
-
-
-class Text(ScalarNode, str):
-    @classmethod
-    def compose(cls, message: MessageNode) -> str:
-        if not message.text:
-            raise ComposeError("Message has no text.")
-        return message.text.unwrap()
-
-
-class TextInteger(ScalarNode, int):
-    @classmethod
-    def compose(cls, text: Text) -> int:
-        if not text.isdigit():
-            raise ComposeError("Text is not digit.")
-        return int(text)
-
-
-if typing.TYPE_CHECKING:
-    from typing import Literal as TextLiteral
-
-else:
-
-    class TextLiteral(FactoryNode):
-        texts: tuple[str, ...]
-
-        def __class_getitem__(cls, texts, /):
-            return cls(texts=(texts,) if not isinstance(texts, tuple) else texts)
-
-        @classmethod
-        def compose(cls, text: Text) -> str:
-            if text in cls.texts:
-                return text
-            raise ComposeError("Text matching failed.")
-
-
-__all__ = ("Text", "TextInteger", "TextLiteral")
+import typing
+
+from telegrinder.node.base import ComposeError, FactoryNode, ScalarNode
+from telegrinder.node.message import MessageNode
+
+
+class Text(ScalarNode, str):
+    @classmethod
+    def compose(cls, message: MessageNode) -> str:
+        if not message.text:
+            raise ComposeError("Message has no text.")
+        return message.text.unwrap()
+
+
+class TextInteger(ScalarNode, int):
+    @classmethod
+    def compose(cls, text: Text) -> int:
+        if not text.isdigit():
+            raise ComposeError("Text is not digit.")
+        return int(text)
+
+
+if typing.TYPE_CHECKING:
+    from typing import Literal as TextLiteral
+
+else:
+
+    class TextLiteral(FactoryNode):
+        texts: tuple[str, ...]
+
+        def __class_getitem__(cls, texts, /):
+            return cls(texts=(texts,) if not isinstance(texts, tuple) else texts)
+
+        @classmethod
+        def compose(cls, text: Text) -> str:
+            if text in cls.texts:
+                return text
+            raise ComposeError("Text matching failed.")
+
+
+__all__ = ("Text", "TextInteger", "TextLiteral")

telegrinder/node/tools/__init__.py

@@ -1,3 +1,3 @@
-from .generator import generate_node
-
-__all__ = ("generate_node",)
+from .generator import generate_node
+
+__all__ = ("generate_node",)