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

telegrinder/node/polymorphic.py

@@ -1,52 +1,48 @@
-import inspect
-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 = composition.func(cls, **node_collection.values)
-            if inspect.isawaitable(result):
-                result = await result
-
-            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,21 +1,21 @@
-from telegrinder.node.base import ComposeError, 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)
-
-
-__all__ = ("Text", "TextInteger")
+from telegrinder.node.base import ComposeError, 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)
+
+
+__all__ = ("Text", "TextInteger")

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

telegrinder/node/tools/generator.py

@@ -1,40 +1,40 @@
-import inspect
-import typing
-
-from telegrinder.node.base import ComposeError, Node
-from telegrinder.node.container import ContainerNode
-
-T = typing.TypeVar("T")
-
-
-def cast_false_to_none(value: T) -> T | None:
-    if value is False:
-        return None
-    return value
-
-
-def error_on_none(value: T | None) -> T:
-    if value is None:
-        raise ComposeError
-    return value
-
-
-def generate_node(
-    subnodes: tuple[type[Node], ...],
-    func: typing.Callable[..., typing.Any],
-    casts: tuple[typing.Callable[[typing.Any], typing.Any], ...] = (cast_false_to_none, error_on_none),
-) -> type[Node]:
-    async def compose(cls, **kw) -> typing.Any:
-        result = func(*ContainerNode.compose(**kw))  # type: ignore
-        if inspect.isawaitable(result):
-            result = await result
-        for cast in casts:
-            result = cast(result)
-        return result
-
-    container = ContainerNode.link_nodes(list(subnodes))
-    compose.__annotations__ = container.get_subnodes()
-    return type("_ContainerNode", (container,), {"compose": classmethod(compose)})
-
-
-__all__ = ("generate_node",)
+import inspect
+import typing
+
+from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.container import ContainerNode
+
+T = typing.TypeVar("T")
+
+
+def cast_false_to_none(value: T) -> T | None:
+    if value is False:
+        return None
+    return value
+
+
+def error_on_none(value: T | None) -> T:
+    if value is None:
+        raise ComposeError
+    return value
+
+
+def generate_node(
+    subnodes: tuple[type[Node], ...],
+    func: typing.Callable[..., typing.Any],
+    casts: tuple[typing.Callable[[typing.Any], typing.Any], ...] = (cast_false_to_none, error_on_none),
+) -> type[Node]:
+    async def compose(cls, **kw) -> typing.Any:
+        result = func(*ContainerNode.compose(**kw))  # type: ignore
+        if inspect.isawaitable(result):
+            result = await result
+        for cast in casts:
+            result = cast(result)
+        return result
+
+    container = ContainerNode.link_nodes(list(subnodes))
+    compose.__annotations__ = container.get_subnodes()
+    return type("_ContainerNode", (container,), {"compose": classmethod(compose)})
+
+
+__all__ = ("generate_node",)

telegrinder/node/update.py

@@ -1,15 +1,15 @@
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types import UpdateCute
-from telegrinder.node.base import ScalarNode
-from telegrinder.types.objects import Update
-
-
-class UpdateNode(ScalarNode, UpdateCute):
-    @classmethod
-    def compose(cls, update: Update, api: API) -> UpdateCute:
-        if isinstance(update, UpdateCute):
-            return update
-        return UpdateCute.from_update(update, api)
-
-
-__all__ = ("UpdateNode",)
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types import UpdateCute
+from telegrinder.node.base import ScalarNode
+from telegrinder.types.objects import Update
+
+
+class UpdateNode(ScalarNode, UpdateCute):
+    @classmethod
+    def compose(cls, update: Update, api: API) -> UpdateCute:
+        if isinstance(update, UpdateCute):
+            return update
+        return UpdateCute.from_update(update, api)
+
+
+__all__ = ("UpdateNode",)