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

telegrinder/bot/rules/abc.py

@@ -1,213 +1,213 @@
-import inspect
-from abc import ABC, abstractmethod
-from functools import cached_property
-
-import typing_extensions as typing
-
-from telegrinder.bot.cute_types import MessageCute, UpdateCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.process import check_rule
-from telegrinder.bot.rules.adapter import ABCAdapter, RawUpdateAdapter
-from telegrinder.bot.rules.adapter.node import Event
-from telegrinder.node.base import Node, get_nodes, is_node
-from telegrinder.tools.i18n.abc import ABCTranslator
-from telegrinder.tools.magic import (
-    cache_translation,
-    get_annotations,
-    get_cached_translation,
-    get_default_args,
-)
-from telegrinder.types.objects import Update as UpdateObject
-
-if typing.TYPE_CHECKING:
-    from telegrinder.node.composer import NodeCollection
-
-AdaptTo = typing.TypeVar("AdaptTo", default=typing.Any, contravariant=True)
-
-CheckResult: typing.TypeAlias = bool | typing.Awaitable[bool]
-Message: typing.TypeAlias = MessageCute
-Update: typing.TypeAlias = UpdateCute
-
-
-def with_caching_translations(func: typing.Callable[..., typing.Any]):
-    """Should be used as decorator for .translate method. Caches rule translations."""
-
-    async def wrapper(self: "ABCRule", translator: ABCTranslator):
-        if translation := get_cached_translation(self, translator.locale):
-            return translation
-        translation = await func(self, translator)
-        cache_translation(self, translator.locale, translation)
-        return translation
-
-    return wrapper
-
-
-class ABCRule(ABC, typing.Generic[AdaptTo]):
-    adapter: ABCAdapter[UpdateObject, AdaptTo]
-    requires: list["ABCRule"] = []
-
-    if typing.TYPE_CHECKING:
-
-        @abstractmethod
-        def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult:
-            pass
-    else:
-        adapter = RawUpdateAdapter()
-
-        @abstractmethod
-        def check(self, *args, **kwargs):
-            pass
-
-    def __init_subclass__(cls, requires: list["ABCRule"] | None = None) -> None:
-        """Merges requirements from inherited classes and rule-specific requirements."""
-
-        requirements = []
-        for base in inspect.getmro(cls):
-            if issubclass(base, ABCRule) and base != cls:
-                requirements.extend(base.requires or ())  # type: ignore
-
-        requirements.extend(requires or ())
-        cls.requires = list(dict.fromkeys(requirements))
-
-    def __and__(self, other: "ABCRule") -> "AndRule":
-        """And Rule.
-
-        ```python
-        rule = HasText() & HasCaption()
-        rule #> AndRule(HasText(), HasCaption()) -> True if all rules in an AndRule are True, otherwise False.
-        ```
-        """
-
-        return AndRule(self, other)
-
-    def __or__(self, other: "ABCRule") -> "OrRule":
-        """Or Rule.
-
-        ```python
-        rule = HasText() | HasCaption()
-        rule #> OrRule(HasText(), HasCaption()) -> True if any rule in an OrRule are True, otherwise False.
-        ```
-        """
-
-        return OrRule(self, other)
-
-    def __invert__(self) -> "NotRule":
-        """Not Rule.
-
-        ```python
-        rule = ~HasText()
-        rule # NotRule(HasText()) -> True if rule returned False, otherwise False.
-        ```
-        """
-
-        return NotRule(self)
-
-    def __repr__(self) -> str:
-        return "<{}: adapter={!r}>".format(
-            self.__class__.__name__,
-            self.adapter,
-        )
-
-    @cached_property
-    def required_nodes(self) -> dict[str, type[Node]]:
-        return get_nodes(self.check)
-
-    def as_optional(self) -> "ABCRule":
-        return self | Always()
-
-    def should_fail(self) -> "ABCRule":
-        return self & Never()
-
-    async def bounding_check(
-        self,
-        adapted_value: AdaptTo,
-        ctx: Context,
-        node_col: "NodeCollection | None" = None,
-    ) -> bool:
-        bound_check_rule = self.check
-        kw = {}
-        node_col_values = node_col.values if node_col is not None else {}
-        temp_ctx = get_default_args(bound_check_rule) | ctx
-
-        for i, (k, v) in enumerate(get_annotations(bound_check_rule).items()):
-            if (isinstance(adapted_value, Event) and i == 0) or (  # First arg is Event
-                isinstance(v, type) and isinstance(adapted_value, v)
-            ):
-                kw[k] = adapted_value if not isinstance(adapted_value, Event) else adapted_value.obj
-            elif is_node(v):
-                assert k in node_col_values, "Node is undefined, error while bounding."
-                kw[k] = node_col_values[k]
-            elif k in temp_ctx:
-                kw[k] = temp_ctx[k]
-            elif v is Context:
-                kw[k] = ctx
-            else:
-                raise LookupError(
-                    f"Cannot bound {k!r} of type {v!r} to '{self.__class__.__qualname__}.check()', "
-                    "because it cannot be resolved."
-                )
-
-        result = bound_check_rule(**kw)  # type: ignore
-        if inspect.isawaitable(result):
-            result = await result
-        return result
-
-    async def translate(self, translator: ABCTranslator) -> typing.Self:
-        return self
-
-
-class AndRule(ABCRule):
-    def __init__(self, *rules: ABCRule) -> None:
-        self.rules = rules
-
-    async def check(self, event: Update, ctx: Context) -> bool:
-        ctx_copy = ctx.copy()
-        for rule in self.rules:
-            if not await check_rule(event.ctx_api, rule, event, ctx_copy):
-                return False
-        ctx |= ctx_copy
-        return True
-
-
-class OrRule(ABCRule):
-    def __init__(self, *rules: ABCRule) -> None:
-        self.rules = rules
-
-    async def check(self, event: Update, ctx: Context) -> bool:
-        for rule in self.rules:
-            ctx_copy = ctx.copy()
-            if await check_rule(event.ctx_api, rule, event, ctx_copy):
-                ctx |= ctx_copy
-                return True
-        return False
-
-
-class NotRule(ABCRule):
-    def __init__(self, rule: ABCRule) -> None:
-        self.rule = rule
-
-    async def check(self, event: Update, ctx: Context) -> bool:
-        ctx_copy = ctx.copy()
-        return not await check_rule(event.ctx_api, self.rule, event, ctx_copy)
-
-
-class Never(ABCRule):
-    async def check(self) -> typing.Literal[False]:
-        return False
-
-
-class Always(ABCRule):
-    async def check(self) -> typing.Literal[True]:
-        return True
-
-
-__all__ = (
-    "ABCRule",
-    "Always",
-    "AndRule",
-    "CheckResult",
-    "Never",
-    "NotRule",
-    "OrRule",
-    "with_caching_translations",
-)
+import inspect
+from abc import ABC, abstractmethod
+from functools import cached_property
+
+import typing_extensions as typing
+
+from telegrinder.bot.cute_types import MessageCute, UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.bot.rules.adapter import ABCAdapter, RawUpdateAdapter
+from telegrinder.bot.rules.adapter.node import Event
+from telegrinder.node.base import Node, get_nodes, is_node
+from telegrinder.tools.i18n.abc import ABCTranslator
+from telegrinder.tools.magic import (
+    cache_translation,
+    get_annotations,
+    get_cached_translation,
+    get_default_args,
+)
+from telegrinder.types.objects import Update as UpdateObject
+
+if typing.TYPE_CHECKING:
+    from telegrinder.node.composer import NodeCollection
+
+AdaptTo = typing.TypeVar("AdaptTo", default=typing.Any, contravariant=True)
+
+CheckResult: typing.TypeAlias = bool | typing.Awaitable[bool]
+Message: typing.TypeAlias = MessageCute
+Update: typing.TypeAlias = UpdateCute
+
+
+def with_caching_translations(func: typing.Callable[..., typing.Any]):
+    """Should be used as decorator for .translate method. Caches rule translations."""
+
+    async def wrapper(self: "ABCRule", translator: ABCTranslator):
+        if translation := get_cached_translation(self, translator.locale):
+            return translation
+        translation = await func(self, translator)
+        cache_translation(self, translator.locale, translation)
+        return translation
+
+    return wrapper
+
+
+class ABCRule(ABC, typing.Generic[AdaptTo]):
+    adapter: ABCAdapter[UpdateObject, AdaptTo]
+    requires: list["ABCRule"] = []
+
+    if typing.TYPE_CHECKING:
+
+        @abstractmethod
+        def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult:
+            pass
+    else:
+        adapter = RawUpdateAdapter()
+
+        @abstractmethod
+        def check(self, *args, **kwargs):
+            pass
+
+    def __init_subclass__(cls, requires: list["ABCRule"] | None = None) -> None:
+        """Merges requirements from inherited classes and rule-specific requirements."""
+
+        requirements = []
+        for base in inspect.getmro(cls):
+            if issubclass(base, ABCRule) and base != cls:
+                requirements.extend(base.requires or ())  # type: ignore
+
+        requirements.extend(requires or ())
+        cls.requires = list(dict.fromkeys(requirements))
+
+    def __and__(self, other: "ABCRule") -> "AndRule":
+        """And Rule.
+
+        ```python
+        rule = HasText() & HasCaption()
+        rule #> AndRule(HasText(), HasCaption()) -> True if all rules in an AndRule are True, otherwise False.
+        ```
+        """
+
+        return AndRule(self, other)
+
+    def __or__(self, other: "ABCRule") -> "OrRule":
+        """Or Rule.
+
+        ```python
+        rule = HasText() | HasCaption()
+        rule #> OrRule(HasText(), HasCaption()) -> True if any rule in an OrRule are True, otherwise False.
+        ```
+        """
+
+        return OrRule(self, other)
+
+    def __invert__(self) -> "NotRule":
+        """Not Rule.
+
+        ```python
+        rule = ~HasText()
+        rule # NotRule(HasText()) -> True if rule returned False, otherwise False.
+        ```
+        """
+
+        return NotRule(self)
+
+    def __repr__(self) -> str:
+        return "<{}: adapter={!r}>".format(
+            self.__class__.__name__,
+            self.adapter,
+        )
+
+    @cached_property
+    def required_nodes(self) -> dict[str, type[Node]]:
+        return get_nodes(self.check)
+
+    def as_optional(self) -> "ABCRule":
+        return self | Always()
+
+    def should_fail(self) -> "ABCRule":
+        return self & Never()
+
+    async def bounding_check(
+        self,
+        adapted_value: AdaptTo,
+        ctx: Context,
+        node_col: "NodeCollection | None" = None,
+    ) -> bool:
+        bound_check_rule = self.check
+        kw = {}
+        node_col_values = node_col.values if node_col is not None else {}
+        temp_ctx = get_default_args(bound_check_rule) | ctx
+
+        for i, (k, v) in enumerate(get_annotations(bound_check_rule).items()):
+            if (isinstance(adapted_value, Event) and i == 0) or (  # First arg is Event
+                isinstance(v, type) and isinstance(adapted_value, v)
+            ):
+                kw[k] = adapted_value if not isinstance(adapted_value, Event) else adapted_value.obj
+            elif is_node(v):
+                assert k in node_col_values, "Node is undefined, error while bounding."
+                kw[k] = node_col_values[k]
+            elif k in temp_ctx:
+                kw[k] = temp_ctx[k]
+            elif v is Context:
+                kw[k] = ctx
+            else:
+                raise LookupError(
+                    f"Cannot bound {k!r} of type {v!r} to '{self.__class__.__qualname__}.check()', "
+                    "because it cannot be resolved."
+                )
+
+        result = bound_check_rule(**kw)  # type: ignore
+        if inspect.isawaitable(result):
+            result = await result
+        return result
+
+    async def translate(self, translator: ABCTranslator) -> typing.Self:
+        return self
+
+
+class AndRule(ABCRule):
+    def __init__(self, *rules: ABCRule) -> None:
+        self.rules = rules
+
+    async def check(self, event: Update, ctx: Context) -> bool:
+        ctx_copy = ctx.copy()
+        for rule in self.rules:
+            if not await check_rule(event.ctx_api, rule, event, ctx_copy):
+                return False
+        ctx |= ctx_copy
+        return True
+
+
+class OrRule(ABCRule):
+    def __init__(self, *rules: ABCRule) -> None:
+        self.rules = rules
+
+    async def check(self, event: Update, ctx: Context) -> bool:
+        for rule in self.rules:
+            ctx_copy = ctx.copy()
+            if await check_rule(event.ctx_api, rule, event, ctx_copy):
+                ctx |= ctx_copy
+                return True
+        return False
+
+
+class NotRule(ABCRule):
+    def __init__(self, rule: ABCRule) -> None:
+        self.rule = rule
+
+    async def check(self, event: Update, ctx: Context) -> bool:
+        ctx_copy = ctx.copy()
+        return not await check_rule(event.ctx_api, self.rule, event, ctx_copy)
+
+
+class Never(ABCRule):
+    async def check(self) -> typing.Literal[False]:
+        return False
+
+
+class Always(ABCRule):
+    async def check(self) -> typing.Literal[True]:
+        return True
+
+
+__all__ = (
+    "ABCRule",
+    "Always",
+    "AndRule",
+    "CheckResult",
+    "Never",
+    "NotRule",
+    "OrRule",
+    "with_caching_translations",
+)

telegrinder/bot/rules/adapter/__init__.py

@@ -1,14 +1,17 @@
-from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
-from telegrinder.bot.rules.adapter.errors import AdapterError
-from telegrinder.bot.rules.adapter.event import EventAdapter
-from telegrinder.bot.rules.adapter.node import NodeAdapter
-from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
-
-__all__ = (
+from telegrinder.bot.rules.adapter.abc import ABCAdapter, AdaptResult, Event
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.bot.rules.adapter.event import EventAdapter
+from telegrinder.bot.rules.adapter.node import NodeAdapter
+from telegrinder.bot.rules.adapter.raw_event import RawEventAdapter
+from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
+
+__all__ = (
     "ABCAdapter",
+    "AdaptResult",
     "AdapterError",
     "Event",
     "EventAdapter",
     "NodeAdapter",
-    "RawUpdateAdapter",
-)
+    "RawEventAdapter",
+    "RawUpdateAdapter",
+)

telegrinder/bot/rules/adapter/abc.py

@@ -1,29 +1,31 @@
-import abc
-import dataclasses
-import typing
-
-from fntypes.result import Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.adapter.errors import AdapterError
-from telegrinder.model import Model
-
-From = typing.TypeVar("From", bound=Model)
-To = typing.TypeVar("To")
-
-
-class ABCAdapter(abc.ABC, typing.Generic[From, To]):
-    ADAPTED_VALUE_KEY: str | None = None
-
-    @abc.abstractmethod
-    async def adapt(self, api: API, update: From, context: Context) -> Result[To, AdapterError]:
-        pass
-
-
-@dataclasses.dataclass(slots=True)
-class Event(typing.Generic[To]):
-    obj: To
-
-
-__all__ = ("ABCAdapter", "Event")
+import abc
+import dataclasses
+import typing
+
+from fntypes.result import Result
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.model import Model
+
+From = typing.TypeVar("From", bound=Model)
+To = typing.TypeVar("To")
+
+AdaptResult: typing.TypeAlias = Result[To, AdapterError] | typing.Awaitable[Result[To, AdapterError]]
+
+
+class ABCAdapter(abc.ABC, typing.Generic[From, To]):
+    ADAPTED_VALUE_KEY: str | None = None
+
+    @abc.abstractmethod
+    def adapt(self, api: API, update: From, context: Context) -> AdaptResult[To]:
+        pass
+
+
+@dataclasses.dataclass(slots=True)
+class Event(typing.Generic[To]):
+    obj: To
+
+
+__all__ = ("ABCAdapter", "AdaptResult", "Event")

telegrinder/bot/rules/adapter/errors.py

@@ -1,5 +1,5 @@
-class AdapterError(RuntimeError):
-    pass
-
-
-__all__ = ("AdapterError",)
+class AdapterError(RuntimeError):
+    pass
+
+
+__all__ = ("AdapterError",)

telegrinder/bot/rules/adapter/event.py

@@ -1,67 +1,65 @@
-import typing
-
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.adapter.abc import ABCAdapter
-from telegrinder.bot.rules.adapter.errors import AdapterError
-from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Model, Update
-
-ToCute = typing.TypeVar("ToCute", bound=BaseCute)
-
-
-class EventAdapter(ABCAdapter[Update, ToCute]):
-    ADAPTED_VALUE_KEY: str = "_adapted_cute_event"
-
-    def __init__(self, event: UpdateType | type[Model], cute_model: type[ToCute]) -> None:
-        self.event = event
-        self.cute_model = cute_model
-
-    def __repr__(self) -> str:
-        if isinstance(self.event, str):
-            raw_update_type = Update.__annotations__.get(self.event, "Unknown")
-            raw_update_type = (
-                typing.get_args(raw_update_type)[0].__forward_arg__
-                if typing.get_args(raw_update_type)
-                else raw_update_type
-            )
-        else:
-            raw_update_type = self.event.__name__
-
-        return "<{}: adapt Update -> {} -> {}>".format(
-            self.__class__.__name__,
-            raw_update_type,
-            self.cute_model.__name__,
-        )
-
-    async def adapt(self, api: API, update: Update, context: Context) -> Result[ToCute, AdapterError]:
-        if self.ADAPTED_VALUE_KEY in context:
-            return Ok(context[self.ADAPTED_VALUE_KEY])
-
-        match await RawUpdateAdapter().adapt(api, update, context):
-            case Ok(update_cute):
-                incoming_update = None
-                if isinstance(self.event, UpdateType) and self.event == update_cute.update_type:
-                    incoming_update = update_cute.incoming_update
-                if not isinstance(self.event, UpdateType) and (event := update_cute.get_event(self.event)):
-                    incoming_update = update_cute.get_event(self.event).unwrap_or_none()
-
-                if incoming_update is not None:
-                    adapted = (
-                        typing.cast(ToCute, incoming_update)
-                        if isinstance(incoming_update, BaseCute)
-                        else self.cute_model.from_update(incoming_update, bound_api=api)
-                    )
-                    context[self.ADAPTED_VALUE_KEY] = adapted
-                    return Ok(adapted)
-
-                return Error(AdapterError(f"Update is not an {self.event!r}."))
-            case Error(_) as err:
-                return err
-
-
-__all__ = ("EventAdapter",)
+import typing
+
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.adapter.abc import ABCAdapter
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Model, Update
+
+ToCute = typing.TypeVar("ToCute", bound=BaseCute)
+
+
+class EventAdapter(ABCAdapter[Update, ToCute]):
+    ADAPTED_VALUE_KEY: str = "_adapted_cute_event"
+
+    def __init__(self, event: UpdateType | type[Model], cute_model: type[ToCute]) -> None:
+        self.event = event
+        self.cute_model = cute_model
+
+    def __repr__(self) -> str:
+        raw_update_type = (
+            f"Update -> {self.event.__name__}"
+            if isinstance(self.event, type)
+            else f"Update.{self.event.value}"
+        )
+        return "<{}: adapt {} -> {}>".format(
+            self.__class__.__name__,
+            raw_update_type,
+            self.cute_model.__name__,
+        )
+
+    def get_event(self, update: UpdateCute) -> Model | None:
+        if isinstance(self.event, UpdateType) and self.event == update.update_type:
+            return update.incoming_update
+
+        if not isinstance(self.event, UpdateType) and (event := update.get_event(self.event)):
+            return event.unwrap()
+
+        return None
+
+    def adapt(self, api: API, update: Update, context: Context) -> Result[ToCute, AdapterError]:
+        match RawUpdateAdapter().adapt(api, update, context):
+            case Ok(update_cute) if event := self.get_event(update_cute):
+                if self.ADAPTED_VALUE_KEY in context:
+                    return Ok(context[self.ADAPTED_VALUE_KEY])
+
+                adapted = (
+                    typing.cast(ToCute, event)
+                    if isinstance(event, BaseCute)
+                    else self.cute_model.from_update(event, bound_api=api)
+                )
+                context[self.ADAPTED_VALUE_KEY] = adapted
+                return Ok(adapted)
+            case Error(_) as err:
+                return err
+            case _:
+                return Error(AdapterError(f"Update is not an {self.event!r}."))
+
+
+__all__ = ("EventAdapter",)