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

telegrinder/bot/rules/adapter/event.py

@@ -1,76 +1,76 @@
-import typing
-
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.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.msgspec_utils import Nothing
-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])
-
-        if isinstance(self.event, UpdateType):
-            if update.update_type != self.event:
-                return Error(
-                    AdapterError(f"Update is not of event type {self.event!r}."),
-                )
-
-            if isinstance(event := getattr(update, self.event.value, Nothing), type(Nothing)):
-                return Error(
-                    AdapterError(f"Update is not an {self.event!r}."),
-                )
-
-            event = event.unwrap()
-
-            if type(event) is self.cute_model:
-                adapted = event
-            else:
-                adapted = self.cute_model.from_update(event, bound_api=api)
-        else:
-            event = getattr(update, update.update_type.value).unwrap()
-            if not update.update_type or not issubclass(type(event), self.event):
-                return Error(AdapterError(f"Update is not an {self.event.__name__!r}."))
-
-            if type(event) is self.cute_model:
-                adapted = event
-            else:
-                adapted = self.cute_model.from_update(event, bound_api=api)
-
-        context[self.ADAPTED_VALUE_KEY] = adapted
-        return Ok(adapted)  # type: ignore
-
-
-__all__ = ("EventAdapter",)
+import typing
+
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.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.msgspec_utils import Nothing
+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])
+
+        if isinstance(self.event, UpdateType):
+            if update.update_type != self.event:
+                return Error(
+                    AdapterError(f"Update is not of event type {self.event!r}."),
+                )
+
+            if isinstance(event := getattr(update, self.event.value, Nothing), type(Nothing)):
+                return Error(
+                    AdapterError(f"Update is not an {self.event!r}."),
+                )
+
+            event = event.unwrap()
+
+            if type(event) is self.cute_model:
+                adapted = event
+            else:
+                adapted = self.cute_model.from_update(event, bound_api=api)
+        else:
+            event = getattr(update, update.update_type.value).unwrap()
+            if not update.update_type or not issubclass(type(event), self.event):
+                return Error(AdapterError(f"Update is not an {self.event.__name__!r}."))
+
+            if type(event) is self.cute_model:
+                adapted = event
+            else:
+                adapted = self.cute_model.from_update(event, bound_api=api)
+
+        context[self.ADAPTED_VALUE_KEY] = adapted
+        return Ok(adapted)  # type: ignore
+
+
+__all__ = ("EventAdapter",)

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 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 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_update.py

@@ -1,30 +1,30 @@
-from fntypes.result import Ok, Result
-
-from telegrinder.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 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",)

telegrinder/bot/rules/callback_data.py

@@ -1,171 +1,171 @@
-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, event: CallbackQuery, context: Context) -> CheckResult:
-        pass
-
-
-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, event: CallbackQuery, context: Context) -> CheckResult:
+        pass
+
+
+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",
+)