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

telegrinder/bot/rules/adapter/node.py

@@ -1,48 +1,48 @@
-import typing_extensions as typing
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
-from telegrinder.bot.rules.adapter.errors import AdapterError
-from telegrinder.msgspec_utils import repr_type
-from telegrinder.node.composer import NodeSession, compose_nodes
-from telegrinder.types.objects import Update
-
-if typing.TYPE_CHECKING:
-    from telegrinder.node.base import Node
-
-Ts = typing.TypeVarTuple("Ts", default=typing.Unpack[tuple[type["Node"], ...]])
-
-
-class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
-    def __init__(self, *nodes: *Ts) -> None:
-        self.nodes = nodes
-
-    def __repr__(self) -> str:
-        return "<{}: adapt Update -> ({})>".format(
-            self.__class__.__name__,
-            ", ".join(repr_type(node) for node in self.nodes),
-        )
-
-    async def adapt(
-        self,
-        api: API,
-        update: Update,
-        context: Context,
-    ) -> Result[Event[tuple[*Ts]], AdapterError]:
-        result = await compose_nodes(
-            nodes={str(i): typing.cast(type["Node"], node) for i, node in enumerate(self.nodes)},
-            ctx=context,
-            data={Update: update, API: api},
-        )
-
-        match result:
-            case Ok(collection):
-                sessions: list[NodeSession] = list(collection.sessions.values())
-                return Ok(Event(tuple(sessions)))  # type: ignore
-            case Error(err):
-                return Error(AdapterError(f"Couldn't compose nodes, error: {err}."))
-
-
-__all__ = ("NodeAdapter",)
+import typing_extensions as typing
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.msgspec_utils import repr_type
+from telegrinder.node.composer import NodeSession, compose_nodes
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from telegrinder.node.base import Node
+
+Ts = typing.TypeVarTuple("Ts", default=typing.Unpack[tuple[type["Node"], ...]])
+
+
+class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
+    def __init__(self, *nodes: *Ts) -> None:
+        self.nodes = nodes
+
+    def __repr__(self) -> str:
+        return "<{}: adapt Update -> ({})>".format(
+            self.__class__.__name__,
+            ", ".join(repr_type(node) for node in self.nodes),
+        )
+
+    async def adapt(
+        self,
+        api: API,
+        update: Update,
+        context: Context,
+    ) -> Result[Event[tuple[*Ts]], AdapterError]:
+        result = await compose_nodes(
+            nodes={str(i): typing.cast(type["Node"], node) for i, node in enumerate(self.nodes)},
+            ctx=context,
+            data={Update: update, API: api},
+        )
+
+        match result:
+            case Ok(collection):
+                sessions: list[NodeSession] = list(collection.sessions.values())
+                return Ok(Event(tuple(sessions)))  # type: ignore
+            case Error(err):
+                return Error(AdapterError(f"Couldn't compose nodes, error: {err}."))
+
+
+__all__ = ("NodeAdapter",)

telegrinder/bot/rules/adapter/raw_event.py

@@ -0,0 +1,27 @@
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.api import API
+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.model import Model
+from telegrinder.types.objects import Update
+
+
+class RawEventAdapter(ABCAdapter[Update, Model]):
+    def __init__(self, event_model: type[Model], /) -> None:
+        self.event_model = event_model
+
+    def __repr__(self) -> str:
+        return "<{}: adapt Update -> {}>".format(
+            self.__class__.__name__,
+            self.event_model.__name__,
+        )
+
+    def adapt(self, api: API, update: Update, context: Context) -> Result[Model, AdapterError]:
+        if isinstance(update.incoming_update, self.event_model):
+            return Ok(update.incoming_update)
+        return Error(AdapterError(f"Update is not an {self.event_model.__name__!r}."))
+
+
+__all__ = ("RawEventAdapter",)

telegrinder/bot/rules/adapter/raw_update.py

@@ -1,30 +1,30 @@
-from fntypes.result import Ok, Result
-
-from telegrinder.api.api import API
-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.types.objects import Update
-
-
-class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
-    ADAPTED_VALUE_KEY: str = "_adapted_update_cute"
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
-
-    async def adapt(
-        self,
-        api: API,
-        update: Update,
-        context: Context,
-    ) -> Result[UpdateCute, AdapterError]:
-        if self.ADAPTED_VALUE_KEY not in context:
-            context[self.ADAPTED_VALUE_KEY] = (
-                UpdateCute.from_update(update, api) if not isinstance(update, UpdateCute) else update
-            )
-        return Ok(context[self.ADAPTED_VALUE_KEY])
-
-
-__all__ = ("RawUpdateAdapter",)
+from fntypes.result import Ok, Result
+
+from telegrinder.api.api import API
+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.types.objects import Update
+
+
+class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
+    ADAPTED_VALUE_KEY: str = "_adapted_update_cute"
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
+
+    def adapt(
+        self,
+        api: API,
+        update: Update,
+        context: Context,
+    ) -> Result[UpdateCute, AdapterError]:
+        if self.ADAPTED_VALUE_KEY not in context:
+            context[self.ADAPTED_VALUE_KEY] = (
+                UpdateCute.from_update(update, api) if not isinstance(update, UpdateCute) else update
+            )
+        return Ok(context[self.ADAPTED_VALUE_KEY])
+
+
+__all__ = ("RawUpdateAdapter",)

telegrinder/bot/rules/callback_data.py

@@ -1,170 +1,170 @@
-import abc
-import inspect
-import typing
-from contextlib import suppress
-
-import msgspec
-
-from telegrinder.bot.cute_types import CallbackQueryCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.adapter import EventAdapter
-from telegrinder.model import decoder
-from telegrinder.tools.buttons import DataclassInstance
-from telegrinder.types.enums import UpdateType
-
-from .abc import ABCRule, CheckResult
-from .markup import Markup, PatternLike, check_string
-
-CallbackQuery: typing.TypeAlias = CallbackQueryCute
-Validator: typing.TypeAlias = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
-MapDict: typing.TypeAlias = dict[str, "typing.Any | type[typing.Any] | Validator | list[MapDict] | MapDict"]
-CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type[typing.Any] | Validator | CallbackMap"]]
-CallbackMapStrict: typing.TypeAlias = list[tuple[str, "Validator | CallbackMapStrict"]]
-
-
-class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
-    adapter: EventAdapter[CallbackQuery] = EventAdapter(UpdateType.CALLBACK_QUERY, CallbackQuery)
-
-    @abc.abstractmethod
-    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
-
-
-class HasData(CallbackQueryRule):
-    def check(self, event: CallbackQuery) -> bool:
-        return bool(event.data.unwrap_or_none())
-
-
-class CallbackQueryDataRule(CallbackQueryRule, abc.ABC, requires=[HasData()]):
-    pass
-
-
-class CallbackDataMap(CallbackQueryDataRule):
-    def __init__(self, mapping: MapDict, /) -> None:
-        self.mapping = self.transform_to_callbacks(
-            self.transform_to_map(mapping),
-        )
-
-    @classmethod
-    def transform_to_map(cls, mapping: MapDict) -> CallbackMap:
-        """Transforms MapDict to CallbackMap."""
-
-        callback_map = []
-
-        for k, v in mapping.items():
-            if isinstance(v, dict):
-                v = cls.transform_to_map(v)
-            callback_map.append((k, v))
-
-        return callback_map
-
-    @classmethod
-    def transform_to_callbacks(cls, callback_map: CallbackMap) -> CallbackMapStrict:
-        """Transforms `CallbackMap` to `CallbackMapStrict`."""
-
-        callback_map_result = []
-
-        for key, value in callback_map:
-            if isinstance(value, type):
-                validator = (lambda tp: lambda v: isinstance(v, tp))(value)
-            elif isinstance(value, list):
-                validator = cls.transform_to_callbacks(value)
-            elif not callable(value):
-                validator = (lambda val: lambda v: val == v)(value)
-            else:
-                validator = value
-            callback_map_result.append((key, validator))
-
-        return callback_map_result
-
-    @staticmethod
-    async def run_validator(value: typing.Any, validator: Validator) -> bool:
-        """Run async or sync validator."""
-
-        with suppress(BaseException):
-            result = validator(value)
-            if inspect.isawaitable(result):
-                result = await result
-            return result
-
-        return False
-
-    @classmethod
-    async def match(cls, callback_data: dict[str, typing.Any], callback_map: CallbackMapStrict) -> bool:
-        """Matches callback_data with callback_map recursively."""
-
-        for key, validator in callback_map:
-            if key not in callback_data:
-                return False
-
-            if isinstance(validator, list):
-                if not (
-                    isinstance(callback_data[key], dict) and await cls.match(callback_data[key], validator)
-                ):
-                    return False
-
-            elif not await cls.run_validator(callback_data[key], validator):
-                return False
-
-        return True
-
-    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
-        callback_data = event.decode_callback_data().unwrap_or_none()
-        if callback_data is None:
-            return False
-        if await self.match(callback_data, self.mapping):
-            ctx.update(callback_data)
-            return True
-        return False
-
-
-class CallbackDataEq(CallbackQueryDataRule):
-    def __init__(self, value: str, /) -> None:
-        self.value = value
-
-    def check(self, event: CallbackQuery) -> bool:
-        return event.data.unwrap() == self.value
-
-
-class CallbackDataJsonEq(CallbackQueryDataRule):
-    def __init__(self, d: dict[str, typing.Any], /) -> None:
-        self.d = d
-
-    def check(self, event: CallbackQuery) -> bool:
-        return event.decode_callback_data().unwrap_or_none() == self.d
-
-
-class CallbackDataJsonModel(CallbackQueryDataRule):
-    def __init__(
-        self,
-        model: type[msgspec.Struct] | type[DataclassInstance],
-        *,
-        alias: str | None = None,
-    ) -> None:
-        self.model = model
-        self.alias = alias or "data"
-
-    def check(self, event: CallbackQuery, ctx: Context) -> bool:
-        with suppress(BaseException):
-            ctx.set(self.alias, decoder.decode(event.data.unwrap().encode(), type=self.model))
-            return True
-        return False
-
-
-class CallbackDataMarkup(CallbackQueryDataRule):
-    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
-        self.patterns = Markup(patterns).patterns
-
-    def check(self, event: CallbackQuery, ctx: Context) -> bool:
-        return check_string(self.patterns, event.data.unwrap(), ctx)
-
-
-__all__ = (
-    "CallbackDataEq",
-    "CallbackDataJsonEq",
-    "CallbackDataJsonModel",
-    "CallbackDataMap",
-    "CallbackDataMarkup",
-    "CallbackQueryDataRule",
-    "CallbackQueryRule",
-    "HasData",
-)
+import abc
+import inspect
+import typing
+from contextlib import suppress
+
+import msgspec
+
+from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.adapter import EventAdapter
+from telegrinder.model import decoder
+from telegrinder.tools.buttons import DataclassInstance
+from telegrinder.types.enums import UpdateType
+
+from .abc import ABCRule, CheckResult
+from .markup import Markup, PatternLike, check_string
+
+CallbackQuery: typing.TypeAlias = CallbackQueryCute
+Validator: typing.TypeAlias = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
+MapDict: typing.TypeAlias = dict[str, "typing.Any | type[typing.Any] | Validator | list[MapDict] | MapDict"]
+CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type[typing.Any] | Validator | CallbackMap"]]
+CallbackMapStrict: typing.TypeAlias = list[tuple[str, "Validator | CallbackMapStrict"]]
+
+
+class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
+    adapter: EventAdapter[CallbackQuery] = EventAdapter(UpdateType.CALLBACK_QUERY, CallbackQuery)
+
+    @abc.abstractmethod
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+
+
+class HasData(CallbackQueryRule):
+    def check(self, event: CallbackQuery) -> bool:
+        return bool(event.data.unwrap_or_none())
+
+
+class CallbackQueryDataRule(CallbackQueryRule, abc.ABC, requires=[HasData()]):
+    pass
+
+
+class CallbackDataMap(CallbackQueryDataRule):
+    def __init__(self, mapping: MapDict, /) -> None:
+        self.mapping = self.transform_to_callbacks(
+            self.transform_to_map(mapping),
+        )
+
+    @classmethod
+    def transform_to_map(cls, mapping: MapDict) -> CallbackMap:
+        """Transforms MapDict to CallbackMap."""
+
+        callback_map = []
+
+        for k, v in mapping.items():
+            if isinstance(v, dict):
+                v = cls.transform_to_map(v)
+            callback_map.append((k, v))
+
+        return callback_map
+
+    @classmethod
+    def transform_to_callbacks(cls, callback_map: CallbackMap) -> CallbackMapStrict:
+        """Transforms `CallbackMap` to `CallbackMapStrict`."""
+
+        callback_map_result = []
+
+        for key, value in callback_map:
+            if isinstance(value, type):
+                validator = (lambda tp: lambda v: isinstance(v, tp))(value)
+            elif isinstance(value, list):
+                validator = cls.transform_to_callbacks(value)
+            elif not callable(value):
+                validator = (lambda val: lambda v: val == v)(value)
+            else:
+                validator = value
+            callback_map_result.append((key, validator))
+
+        return callback_map_result
+
+    @staticmethod
+    async def run_validator(value: typing.Any, validator: Validator) -> bool:
+        """Run async or sync validator."""
+
+        with suppress(BaseException):
+            result = validator(value)
+            if inspect.isawaitable(result):
+                result = await result
+            return result
+
+        return False
+
+    @classmethod
+    async def match(cls, callback_data: dict[str, typing.Any], callback_map: CallbackMapStrict) -> bool:
+        """Matches callback_data with callback_map recursively."""
+
+        for key, validator in callback_map:
+            if key not in callback_data:
+                return False
+
+            if isinstance(validator, list):
+                if not (
+                    isinstance(callback_data[key], dict) and await cls.match(callback_data[key], validator)
+                ):
+                    return False
+
+            elif not await cls.run_validator(callback_data[key], validator):
+                return False
+
+        return True
+
+    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+        callback_data = event.decode_callback_data().unwrap_or_none()
+        if callback_data is None:
+            return False
+        if await self.match(callback_data, self.mapping):
+            ctx.update(callback_data)
+            return True
+        return False
+
+
+class CallbackDataEq(CallbackQueryDataRule):
+    def __init__(self, value: str, /) -> None:
+        self.value = value
+
+    def check(self, event: CallbackQuery) -> bool:
+        return event.data.unwrap() == self.value
+
+
+class CallbackDataJsonEq(CallbackQueryDataRule):
+    def __init__(self, d: dict[str, typing.Any], /) -> None:
+        self.d = d
+
+    def check(self, event: CallbackQuery) -> bool:
+        return event.decode_callback_data().unwrap_or_none() == self.d
+
+
+class CallbackDataJsonModel(CallbackQueryDataRule):
+    def __init__(
+        self,
+        model: type[msgspec.Struct] | type[DataclassInstance],
+        *,
+        alias: str | None = None,
+    ) -> None:
+        self.model = model
+        self.alias = alias or "data"
+
+    def check(self, event: CallbackQuery, ctx: Context) -> bool:
+        with suppress(BaseException):
+            ctx.set(self.alias, decoder.decode(event.data.unwrap().encode(), type=self.model))
+            return True
+        return False
+
+
+class CallbackDataMarkup(CallbackQueryDataRule):
+    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
+        self.patterns = Markup(patterns).patterns
+
+    def check(self, event: CallbackQuery, ctx: Context) -> bool:
+        return check_string(self.patterns, event.data.unwrap(), ctx)
+
+
+__all__ = (
+    "CallbackDataEq",
+    "CallbackDataJsonEq",
+    "CallbackDataJsonModel",
+    "CallbackDataMap",
+    "CallbackDataMarkup",
+    "CallbackQueryDataRule",
+    "CallbackQueryRule",
+    "HasData",
+)

telegrinder/bot/rules/chat_join.py

@@ -1,46 +1,46 @@
-import abc
-import typing
-
-from telegrinder.bot.cute_types import ChatJoinRequestCute
-from telegrinder.bot.rules.adapter import EventAdapter
-from telegrinder.types.enums import UpdateType
-
-from .abc import ABCRule, CheckResult
-
-ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
-
-
-class ChatJoinRequestRule(ABCRule[ChatJoinRequest], requires=[]):
-    adapter: EventAdapter[ChatJoinRequest] = EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest)
-
-    @abc.abstractmethod
-    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
-
-
-class HasInviteLink(ChatJoinRequestRule):
-    def check(self, event: ChatJoinRequest) -> bool:
-        return bool(event.invite_link)
-
-
-class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
-    def __init__(self, name: str, /) -> None:
-        self.name = name
-
-    def check(self, event: ChatJoinRequest) -> bool:
-        return event.invite_link.unwrap().name.unwrap_or_none() == self.name
-
-
-class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
-    def __init__(self, creator_id: int, /) -> None:
-        self.creator_id = creator_id
-
-    def check(self, event: ChatJoinRequest) -> bool:
-        return event.invite_link.unwrap().creator.id == self.creator_id
-
-
-__all__ = (
-    "ChatJoinRequestRule",
-    "HasInviteLink",
-    "InviteLinkByCreator",
-    "InviteLinkName",
-)
+import abc
+import typing
+
+from telegrinder.bot.cute_types import ChatJoinRequestCute
+from telegrinder.bot.rules.adapter import EventAdapter
+from telegrinder.types.enums import UpdateType
+
+from .abc import ABCRule, CheckResult
+
+ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
+
+
+class ChatJoinRequestRule(ABCRule[ChatJoinRequest], requires=[]):
+    adapter: EventAdapter[ChatJoinRequest] = EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest)
+
+    @abc.abstractmethod
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+
+
+class HasInviteLink(ChatJoinRequestRule):
+    def check(self, event: ChatJoinRequest) -> bool:
+        return bool(event.invite_link)
+
+
+class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
+    def __init__(self, name: str, /) -> None:
+        self.name = name
+
+    def check(self, event: ChatJoinRequest) -> bool:
+        return event.invite_link.unwrap().name.unwrap_or_none() == self.name
+
+
+class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
+    def __init__(self, creator_id: int, /) -> None:
+        self.creator_id = creator_id
+
+    def check(self, event: ChatJoinRequest) -> bool:
+        return event.invite_link.unwrap().creator.id == self.creator_id
+
+
+__all__ = (
+    "ChatJoinRequestRule",
+    "HasInviteLink",
+    "InviteLinkByCreator",
+    "InviteLinkName",
+)