telegrinder 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

telegrinder/bot/rules/is_from.py

@@ -107,21 +107,40 @@ class IsSticker(MessageRule):
         return bool(message.sticker)
 
 
+class IsVideoNote(MessageRule):
+    async def check(self, message: Message) -> bool:
+        return bool(message.video_note)
+
+
+class IsDocument(MessageRule):
+    async def check(self, message: Message) -> bool:
+        return bool(message.document)
+
+
+class IsPhoto(MessageRule):
+    async def check(self, message: Message) -> bool:
+        return bool(message.photo)
+
+
 __all__ = (
     "IsBot",
     "IsChat",
     "IsChatId",
     "IsDice",
     "IsDiceEmoji",
+    "IsDocument",
     "IsForum",
     "IsForward",
     "IsForwardType",
     "IsGroup",
     "IsLanguageCode",
+    "IsPhoto",
     "IsPremium",
     "IsPrivate",
     "IsReply",
+    "IsSticker",
     "IsSuperGroup",
     "IsUser",
     "IsUserId",
+    "IsVideoNote",
 )

telegrinder/bot/rules/state.py

@@ -1,12 +1,15 @@
+import dataclasses
 import enum
 import typing
 
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.node import Source
+from telegrinder.node.source import Source
 
 if typing.TYPE_CHECKING:
-    from telegrinder.tools.state_storage import ABCStateStorage
+    from telegrinder.tools.state_storage.abc import ABCStateStorage
+
+Payload = typing.TypeVar("Payload")
 
 
 class StateMeta(enum.Enum):
@@ -14,10 +17,10 @@ class StateMeta(enum.Enum):
     ANY = enum.auto()
 
 
-class State(ABCRule):
-    def __init__(self, storage: "ABCStateStorage", key: str | StateMeta = StateMeta.ANY):
-        self.storage = storage
-        self.key = key
+@dataclasses.dataclass(frozen=True, slots=True, repr=False)
+class State(ABCRule, typing.Generic[Payload]):
+    storage: "ABCStateStorage[Payload]"
+    key: str | StateMeta | enum.Enum
 
     async def check(self, source: Source, ctx: Context) -> bool:
         state = await self.storage.get(source.from_user.id)

telegrinder/bot/scenario/checkbox.py

@@ -2,16 +2,16 @@ import dataclasses
 import secrets
 import typing
 
-from telegrinder.bot.cute_types import CallbackQueryCute
-from telegrinder.bot.dispatch.waiter_machine import WaiterMachine
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.dispatch.waiter_machine import StateViewHasher, WaiterMachine
 from telegrinder.bot.scenario.abc import ABCScenario
-from telegrinder.tools import InlineButton, InlineKeyboard
+from telegrinder.tools.keyboard import InlineButton, InlineKeyboard
 from telegrinder.tools.parse_mode import ParseMode
 from telegrinder.types.objects import InlineKeyboardMarkup
 
 if typing.TYPE_CHECKING:
     from telegrinder.api import API
-    from telegrinder.bot.dispatch.view.abc import BaseStateView
+    from telegrinder.bot.dispatch.view.base import BaseStateView
 
 
 @dataclasses.dataclass(slots=True)
@@ -124,7 +124,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         ).unwrap()
 
         while True:
-            q, _ = await self.waiter_machine.wait(view, (api, message.message_id))
+            q, _ = await self.waiter_machine.wait(StateViewHasher(view.__class__), message.message_id)
             should_continue = await self.handle(q)
             await q.answer(self.CALLBACK_ANSWER)
             if not should_continue:

telegrinder/bot/scenario/choice.py

@@ -1,11 +1,11 @@
 import typing
 
-from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 from telegrinder.bot.scenario.checkbox import Checkbox
 
 if typing.TYPE_CHECKING:
     from telegrinder.api import API
-    from telegrinder.bot.dispatch.view.abc import BaseStateView
+    from telegrinder.bot.dispatch.view.base import BaseStateView
 
 
 class Choice(Checkbox):

telegrinder/client/aiohttp.py

@@ -5,8 +5,8 @@ import aiohttp
 import certifi
 from aiohttp import ClientSession, TCPConnector
 
+import telegrinder.msgspec_json as json
 from telegrinder.client.abc import ABCClient
-from telegrinder.modules import JSONModule, json
 
 if typing.TYPE_CHECKING:
     from aiohttp import ClientResponse
@@ -16,12 +16,10 @@ class AiohttpClient(ABCClient):
     def __init__(
         self,
         session: ClientSession | None = None,
-        json_processing_module: JSONModule | None = None,
         timeout: aiohttp.ClientTimeout | None = None,
         **session_params: typing.Any,
     ) -> None:
         self.session = session
-        self.json_processing_module = json_processing_module or json
         self.session_params = session_params
         self.timeout = timeout or aiohttp.ClientTimeout(total=0)
 
@@ -43,7 +41,7 @@ class AiohttpClient(ABCClient):
         if not self.session:
             self.session = ClientSession(
                 connector=TCPConnector(ssl=ssl.create_default_context(cafile=certifi.where())),
-                json_serialize=self.json_processing_module.dumps,
+                json_serialize=json.dumps,
                 **self.session_params,
             )
         async with self.session.request(
@@ -65,8 +63,8 @@ class AiohttpClient(ABCClient):
     ) -> dict[str, typing.Any]:
         response = await self.request_raw(url, method, data, **kwargs)
         return await response.json(
-            encoding="utf-8",
-            loads=self.json_processing_module.loads,
+            encoding="UTF-8",
+            loads=json.loads,
             content_type=None,
         )
 
@@ -78,7 +76,7 @@ class AiohttpClient(ABCClient):
         **kwargs: typing.Any,
     ) -> str:
         response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
-        return await response.text(encoding="utf-8")
+        return await response.text(encoding="UTF-8")
 
     async def request_bytes(
         self,

telegrinder/model.py

@@ -16,17 +16,12 @@ if typing.TYPE_CHECKING:
 
 T = typing.TypeVar("T")
 
-
-def rename_field(name: str) -> str:
-    if name.endswith("_") and name.removesuffix("_") in keyword.kwlist:
-        return name.removesuffix("_")
-    return name if not keyword.iskeyword(name) else name + "_"
-
+UnionType: typing.TypeAlias = typing.Annotated[tuple[T, ...], ...]
 
 MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
     "omit_defaults": True,
     "dict": True,
-    "rename": rename_field,
+    "rename": {kw + "_": kw for kw in keyword.kwlist},
 }
 
 
@@ -40,15 +35,15 @@ def full_result(
 @typing.overload
 def full_result(
     result: Result[msgspec.Raw, "APIError"],
-    full_t: tuple[type[T], ...],
+    full_t: UnionType[T],
 ) -> Result[T, "APIError"]: ...
 
 
 def full_result(
     result: Result[msgspec.Raw, "APIError"],
-    full_t: type[T] | tuple[type[T], ...],
-) -> Result[T, "APIError"]:
-    return result.map(lambda v: decoder.decode(v, type=full_t))  # type: ignore
+    full_t: typing.Any,
+) -> Result[typing.Any, "APIError"]:
+    return result.map(lambda v: decoder.decode(v, type=full_t))
 
 
 def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:

telegrinder/modules.py

@@ -4,13 +4,6 @@ import typing
 from choicelib import choice_in_order
 
 
-@typing.runtime_checkable
-class JSONModule(typing.Protocol):
-    def loads(self, s: str | bytes) -> typing.Any: ...
-
-    def dumps(self, o: typing.Any) -> str: ...
-
-
 @typing.runtime_checkable
 class LoggerModule(typing.Protocol):
     def debug(self, __msg: object, *args: object, **kwargs: object) -> None: ...
@@ -25,25 +18,23 @@ class LoggerModule(typing.Protocol):
 
     def exception(self, __msg: object, *args: object, **kwargs: object) -> None: ...
 
-    def set_level(
-        self,
-        level: typing.Literal[
-            "DEBUG",
-            "INFO",
-            "WARNING",
-            "ERROR",
-            "CRITICAL",
-            "EXCEPTION",
-        ],
-    ) -> None: ...
+    if typing.TYPE_CHECKING:
+
+        def set_level(
+            self,
+            level: typing.Literal[
+                "DEBUG",
+                "INFO",
+                "WARNING",
+                "ERROR",
+                "CRITICAL",
+                "EXCEPTION",
+            ],
+            /,
+        ) -> None: ...
 
 
 logger: LoggerModule
-json: JSONModule = choice_in_order(
-    ["orjson", "ujson", "hyperjson"],
-    default="telegrinder.msgspec_json",
-    do_import=True,
-)
 logging_level = os.getenv("LOGGER_LEVEL", default="DEBUG").upper()
 logging_module = choice_in_order(["loguru"], default="logging")
 asyncio_module = choice_in_order(["uvloop"], default="asyncio")
@@ -227,7 +218,7 @@ if asyncio_module == "uvloop":
     asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())  # type: ignore
 
 
-def _set_logger_level(level):
+def _set_logger_level(level, /):
     level = level.upper()
     if logging_module == "logging":
         import logging
@@ -243,4 +234,4 @@ def _set_logger_level(level):
 setattr(logger, "set_level", staticmethod(_set_logger_level))  # type: ignore
 
 
-__all__ = ("json", "logger")
+__all__ = ("LoggerModule", "logger")

telegrinder/msgspec_json.py

@@ -1,6 +1,6 @@
 import typing
 
-from .msgspec_utils import decoder, encoder
+from telegrinder.msgspec_utils import decoder, encoder
 
 
 def loads(s: str | bytes) -> typing.Any:

telegrinder/msgspec_utils.py

@@ -1,5 +1,6 @@
 import dataclasses
 import typing
+from contextlib import contextmanager
 
 import fntypes.option
 import fntypes.result
@@ -29,7 +30,6 @@ else:
         def __instancecheck__(cls, __instance: typing.Any) -> bool:
             return isinstance(__instance, fntypes.option.Some | fntypes.option.Nothing)
 
-
     class Option(typing.Generic[Value], metaclass=OptionMeta):
         pass
 
@@ -63,9 +63,10 @@ def is_common_type(type_: typing.Any) -> typing.TypeGuard[type[typing.Any]]:
 def type_check(obj: typing.Any, t: typing.Any) -> bool:
     return (
         isinstance(obj, t)
-        if isinstance(t, type)
-        and issubclass(t, msgspec.Struct)
-        else type(obj) in t if isinstance(t, tuple) else type(obj) is t
+        if isinstance(t, type) and issubclass(t, msgspec.Struct)
+        else type(obj) in t
+        if isinstance(t, tuple)
+        else type(obj) is t
     )
 
 
@@ -201,6 +202,31 @@ class Decoder:
             self.dec_hooks,
         )
 
+    @typing.overload
+    def __call__(self, type: type[T]) -> typing.ContextManager[msgspec.json.Decoder[T]]: ...
+
+    @typing.overload
+    def __call__(self, type: typing.Any) -> typing.ContextManager[msgspec.json.Decoder[typing.Any]]: ...
+
+    @typing.overload
+    def __call__(
+        self, type: type[T], *, strict: bool = True
+    ) -> typing.ContextManager[msgspec.json.Decoder[T]]: ...
+
+    @typing.overload
+    def __call__(
+        self, type: typing.Any, *, strict: bool = True
+    ) -> typing.ContextManager[msgspec.json.Decoder[typing.Any]]: ...
+
+    @contextmanager
+    def __call__(self, type=object, *, strict=True):
+        """Context manager returns the `msgspec.json.Decoder` object with the `dec_hook`."""
+
+        dec_obj = msgspec.json.Decoder(
+            type=typing.Any if type is object else type, strict=strict, dec_hook=self.dec_hook
+        )
+        yield dec_obj
+
     def add_dec_hook(self, t: T):  # type: ignore
         def decorator(func: DecHook[T]) -> DecHook[T]:
             return self.dec_hooks.setdefault(get_origin(t), func)  # type: ignore
@@ -241,6 +267,9 @@ class Decoder:
     @typing.overload
     def decode(self, buf: str | bytes, *, type: type[T]) -> T: ...
 
+    @typing.overload
+    def decode(self, buf: str | bytes, *, type: typing.Any) -> typing.Any: ...
+
     @typing.overload
     def decode(
         self,
@@ -250,6 +279,15 @@ class Decoder:
         strict: bool = True,
     ) -> T: ...
 
+    @typing.overload
+    def decode(
+        self,
+        buf: str | bytes,
+        *,
+        type: typing.Any,
+        strict: bool = True,
+    ) -> typing.Any: ...
+
     def decode(self, buf, *, type=object, strict=True):
         return msgspec.json.decode(
             buf,
@@ -287,6 +325,19 @@ class Encoder:
             self.enc_hooks,
         )
 
+    @contextmanager
+    def __call__(
+        self,
+        *,
+        decimal_format: typing.Literal["string", "number"] = "string",
+        uuid_format: typing.Literal["canonical", "hex"] = "canonical",
+        order: typing.Literal[None, "deterministic", "sorted"] = None,
+    ) -> typing.Generator[msgspec.json.Encoder, typing.Any, None]:
+        """Context manager returns the `msgspec.json.Encoder` object with the `enc_hook`."""
+
+        enc_obj = msgspec.json.Encoder(enc_hook=self.enc_hook)
+        yield enc_obj
+
     def add_dec_hook(self, t: type[T]):
         def decorator(func: EncHook[T]) -> EncHook[T]:
             encode_hook = self.enc_hooks.setdefault(get_origin(t), func)
@@ -344,8 +395,8 @@ __all__ = (
     "datetime",
     "decoder",
     "encoder",
-    "msgspec_convert",
     "get_class_annotations",
     "get_type_hints",
+    "msgspec_convert",
     "msgspec_to_builtins",
 )

telegrinder/node/base.py

@@ -12,8 +12,8 @@ from telegrinder.tools.magic import (
 ComposeResult: typing.TypeAlias = typing.Awaitable[typing.Any] | typing.AsyncGenerator[typing.Any, None]
 
 
-def is_node(maybe_node: type[typing.Any]) -> typing.TypeGuard[type["Node"]]:
-    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)

telegrinder/node/composer.py

@@ -4,7 +4,7 @@ import typing
 from fntypes import Error, Ok, Result
 from fntypes.error import UnwrapError
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.update import Update, UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
@@ -41,7 +41,7 @@ async def compose_node(
 async def compose_nodes(
     nodes: dict[str, type[Node]],
     ctx: Context,
-    data: dict[type, typing.Any] | None = None,
+    data: dict[type[typing.Any], typing.Any] | None = None,
 ) -> Result["NodeCollection", ComposeError]:
     logger.debug("Composing nodes: {!r}...", nodes)
 
@@ -67,11 +67,7 @@ async def compose_nodes(
                 local_nodes[node_t] = getattr(node_t, GLOBAL_VALUE_KEY)
                 continue
 
-            subnodes = {
-                k: session.value
-                for k, session in
-                (local_nodes | event_nodes).items()
-            }
+            subnodes = {k: session.value for k, session in (local_nodes | event_nodes).items()}
 
             try:
                 local_nodes[node_t] = await compose_node(node_t, subnodes | data)
@@ -175,11 +171,11 @@ class Composition:
             case Ok(col):
                 return col
             case Error(err):
-                logger.debug(f"Composition failed with error: {err}")
+                logger.debug(f"Composition failed with error: {err!r}")
                 return None
 
     async def __call__(self, **kwargs: typing.Any) -> typing.Any:
-        return await self.func(**magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))  # type: ignore
+        return await self.func(**magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))
 
 
 __all__ = ("Composition", "NodeCollection", "NodeSession", "compose_node", "compose_nodes")

telegrinder/node/container.py

@@ -12,7 +12,12 @@ class ContainerNode(Node):
 
     @classmethod
     def get_subnodes(cls) -> dict[str, type[Node]]:
-        return {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
+        subnodes = getattr(cls, "subnodes", None)
+        if subnodes is None:
+            subnodes_dct = {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
+            setattr(cls, "subnodes", subnodes_dct)
+            return subnodes_dct
+        return subnodes
 
     @classmethod
     def link_nodes(cls, linked_nodes: list[type[Node]]) -> type["ContainerNode"]:

telegrinder/node/event.py

@@ -65,7 +65,9 @@ if typing.TYPE_CHECKING:
     EventNode: typing.TypeAlias = typing.Annotated["Dataclass", ...]
 
 else:
+
     class EventNode(_EventNode):
         pass
 
+
 __all__ = ("EventNode",)

telegrinder/node/polymorphic.py

@@ -13,21 +13,21 @@ 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 polimorphic node {cls.__name__}")
+        logger.debug(f"Composing polimorphic 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 {}", impl.__name__)
-            composition = Composition(impl, True)
+        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__)
+                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__)
+                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
@@ -40,7 +40,7 @@ class Polymorphic(Node):
                 node_ctx[(cls, i)] = NodeSession(cls, result, {})
 
             await node_collection.close_all(with_value=result)
-            logger.debug("Impl {!r} succeeded with value {}", impl.__name__, result)
+            logger.debug("Impl {!r} succeeded with value: {}", impl_.__name__, result)
             return result
 
         raise ComposeError("No implementation found.")

telegrinder/node/rule.py

@@ -11,7 +11,7 @@ if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
 
 
-class RuleChain(dict[str, typing.Any]):
+class RuleChain(dict[str, typing.Any], Node):
     dataclass = dict
     rules: tuple["ABCRule", ...] = ()
 
@@ -28,7 +28,6 @@ class RuleChain(dict[str, typing.Any]):
     def __class_getitem__(cls, items: "ABCRule | tuple[ABCRule, ...]", /) -> typing.Self:
         if not isinstance(items, tuple):
             items = (items,)
-        assert all(isinstance(rule, "ABCRule") for rule in items), "All items must be instances of 'ABCRule'."
         return cls(*items)
 
     @staticmethod
@@ -37,6 +36,7 @@ class RuleChain(dict[str, typing.Any]):
 
     @classmethod
     async def compose(cls, update: UpdateNode) -> typing.Any:
+        # Hack to avoid circular import
         globalns = globals()
         if "check_rule" not in globalns:
             globalns.update(
@@ -54,7 +54,9 @@ class RuleChain(dict[str, typing.Any]):
                 raise ComposeError(f"Rule {rule!r} failed!")
 
         try:
-            return cls.dataclass(**ctx)  # type: ignore
+            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}")
 
@@ -63,7 +65,7 @@ class RuleChain(dict[str, typing.Any]):
         return cls
 
     @classmethod
-    def get_subnodes(cls) -> dict:
+    def get_subnodes(cls) -> dict[typing.Literal["update"], type[UpdateNode]]:
         return {"update": UpdateNode}
 
     @classmethod

telegrinder/node/scope.py

@@ -34,11 +34,11 @@ def global_node(node: T) -> T:
 
 
 __all__ = (
+    "GLOBAL",
     "NodeScope",
-    "PER_EVENT",
     "PER_CALL",
+    "PER_EVENT",
+    "global_node",
     "per_call",
     "per_event",
-    "global_node",
-    "GLOBAL",
 )

telegrinder/node/source.py

@@ -39,7 +39,9 @@ class Source(Polymorphic, DataNode):
         )
 
     @impl
-    async def compose_chat_join_request(cls, chat_join_request: EventNode[ChatJoinRequestCute]) -> typing.Self:
+    async 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,
@@ -68,4 +70,4 @@ class UserSource(ScalarNode, User):
         return source.from_user
 
 
-__all__ = ("Source", "ChatSource", "UserSource")
+__all__ = ("ChatSource", "Source", "UserSource")

telegrinder/node/tools/generator.py

@@ -20,13 +20,13 @@ def error_on_none(value: T | None) -> T:
 
 
 def generate_node(
-    subnodes: tuple[type["Node"], ...],
-    func: typing.Callable[..., T],
+    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(**kw: typing.Any) -> typing.Any:
+) -> type[Node]:
+    async def compose(cls, **kw) -> typing.Any:
         args = await ContainerNode.compose(**kw)
-        result = func(*args)
+        result = func(*args)  # type: ignore
         if inspect.isawaitable(result):
             result = await result
         for cast in casts:
@@ -34,7 +34,8 @@ def generate_node(
         return result
 
     container = ContainerNode.link_nodes(list(subnodes))
-    return type("_ContainerNode", (container,), {"compose": compose})
+    compose.__annotations__ = container.get_subnodes()
+    return type("_ContainerNode", (container,), {"compose": classmethod(compose)})
 
 
 __all__ = ("generate_node",)

telegrinder/rules.py

@@ -26,7 +26,6 @@ __all__ = (
     "InlineQueryMarkup",
     "InlineQueryRule",
     "InlineQueryText",
-    "IsInteger",
     "IntegerInRange",
     "InviteLinkByCreator",
     "InviteLinkName",
@@ -39,6 +38,7 @@ __all__ = (
     "IsForward",
     "IsForwardType",
     "IsGroup",
+    "IsInteger",
     "IsLanguageCode",
     "IsPremium",
     "IsPrivate",
@@ -50,11 +50,11 @@ __all__ = (
     "Markup",
     "MessageEntities",
     "MessageRule",
+    "NodeRule",
     "NotRule",
     "OrRule",
     "Regex",
     "RuleEnum",
     "StartCommand",
     "Text",
-    "NodeRule",
 )