telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev159__py3-none-any.whl

telegrinder/bot/rules/abc.py

@@ -1,102 +1,120 @@
-from abc import ABC, abstractmethod
-from telegrinder.bot.cute_types import MessageCute
-from telegrinder.types import Update
-import typing
-import collections
 import inspect
-import vbml
+import typing
+from abc import ABC, abstractmethod
 
-T = typing.TypeVar("T")
-patcher = vbml.Patcher()
+from telegrinder.bot.cute_types import BaseCute, MessageCute, UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.bot.rules.adapter import ABCAdapter, EventAdapter, RawUpdateAdapter
+from telegrinder.tools.i18n.base import ABCTranslator
+from telegrinder.tools.magic import cache_translation, get_cached_translation
+from telegrinder.types.objects import Update as UpdateObject
 
-Message = MessageCute
-EventScheme = collections.namedtuple("EventScheme", ["name", "dataclass"])
+T = typing.TypeVar("T", bound=BaseCute)
 
+Message: typing.TypeAlias = MessageCute
+Update: typing.TypeAlias = UpdateCute
 
-class ABCRule(ABC, typing.Generic[T]):
-    __event__: typing.Optional[EventScheme] = None
-    require: typing.List["ABCRule[T]"] = []
 
-    async def run_check(self, event: T, ctx: dict) -> bool:
-        ctx_copy = ctx.copy()
-        for required in self.require:
-            if not await required.run_check(event, ctx_copy):
-                return False
-        ctx.update(ctx_copy)
-        return await self.check(event, ctx)
+def with_caching_translations(func):
+    """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[T]):
+    adapter: ABCAdapter[UpdateObject, T] = RawUpdateAdapter()  # type: ignore
+    requires: list["ABCRule[T]"] = []
 
     @abstractmethod
-    async def check(self, event: T, ctx: dict) -> bool:
+    async def check(self, event: T, ctx: Context) -> bool:
         pass
 
-    def __init_subclass__(cls, require: typing.Optional[typing.List["ABCRule[T]"]] = None):
-        """Merges requirements from inherited classes and rule-specific requirements"""
+    def __init_subclass__(cls, requires: list["ABCRule[T]"] | 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.require or ())
+                requirements.extend(base.requires or ())  # type: ignore
 
-        requirements.extend(require or ())
-        cls.require = list(dict.fromkeys(requirements))
+        requirements.extend(requires or ())
+        cls.requires = list(dict.fromkeys(requirements))
 
-    def __and__(self, other: "ABCRule"):
+    def __and__(self, other: "ABCRule[T]"):
         return AndRule(self, other)
 
-    def __or__(self, other: "ABCRule"):
+    def __or__(self, other: "ABCRule[T]"):
         return OrRule(self, other)
 
+    def __neg__(self) -> "ABCRule[T]":
+        return NotRule(self)
+
     def __repr__(self) -> str:
-        return f"(rule {self.__class__.__name__})"
+        return "<rule: {!r}, adapter: {!r}>".format(
+            self.__class__.__name__,
+            self.adapter,
+        )
 
+    async def translate(self, translator: ABCTranslator) -> typing.Self:
+        return self
 
-class AndRule(ABCRule):
-    def __init__(self, *rules: ABCRule):
+
+class AndRule(ABCRule[T]):
+    def __init__(self, *rules: ABCRule[T]):
         self.rules = rules
 
-    async def check(self, event: Update, ctx: dict) -> bool:
+    async def check(self, event: Update, ctx: Context) -> bool:
         ctx_copy = ctx.copy()
         for rule in self.rules:
-            e = event
-            if rule.__event__:
-                event_dict = event.to_dict()
-                if rule.__event__.name not in event:
-                    return False
-                e = rule.__event__.dataclass(
-                    **event_dict[rule.__event__.name].to_dict()
-                )
-            if not await rule.run_check(e, ctx_copy):
+            if not await check_rule(event.ctx_api, rule, event, ctx_copy):
                 return False
-        ctx.clear()
-        ctx.update(ctx_copy)
+        ctx |= ctx_copy
         return True
 
 
-class OrRule(ABCRule):
-    def __init__(self, *rules: ABCRule):
+class OrRule(ABCRule[T]):
+    def __init__(self, *rules: ABCRule[T]):
         self.rules = rules
 
-    async def check(self, event: T, ctx: dict) -> bool:
-        ctx_copy = ctx.copy()
-        found = False
-
+    async def check(self, event: Update, ctx: Context) -> bool:
         for rule in self.rules:
-            e = event
-            if rule.__event__:
-                if rule.__event__.name not in event:
-                    continue
-                e = rule.__event__.dataclass(**event[rule.__event__.name])
-            if await rule.run_check(e, ctx_copy):
-                found = True
-                break
+            ctx_copy = ctx.copy()
+            if await check_rule(event.ctx_api, rule, event, ctx_copy):
+                ctx |= ctx_copy
+                return True
+        return False
 
-        ctx.clear()
-        ctx.update(ctx_copy)
-        return found
 
+class NotRule(ABCRule[T]):
+    def __init__(self, rule: ABCRule[T]):
+        self.rule = rule
 
-class ABCMessageRule(ABCRule, ABC, require=[]):
-    __event__ = EventScheme("message", Message)
+    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 MessageRule(ABCRule[Message], ABC, requires=[]):
+    adapter = EventAdapter("message", Message)
 
     @abstractmethod
-    async def check(self, message: Message, ctx: dict) -> bool:
+    async def check(self, message: Message, ctx: Context) -> bool:
         ...
+
+
+__all__ = (
+    "ABCRule",
+    "AndRule",
+    "MessageRule",
+    "NotRule",
+    "OrRule",
+    "with_caching_translations",
+)

telegrinder/bot/rules/adapter/__init__.py

@@ -0,0 +1,11 @@
+from .abc import ABCAdapter
+from .errors import AdapterError
+from .event import EventAdapter
+from .raw_update import RawUpdateAdapter
+
+__all__ = (
+    "ABCAdapter",
+    "AdapterError",
+    "EventAdapter",
+    "RawUpdateAdapter",
+)

telegrinder/bot/rules/adapter/abc.py

@@ -0,0 +1,21 @@
+import abc
+import typing
+
+from fntypes.result import Result
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.model import Model
+
+UpdateT = typing.TypeVar("UpdateT", bound=Model)
+CuteT = typing.TypeVar("CuteT", bound=BaseCute)
+
+
+class ABCAdapter(abc.ABC, typing.Generic[UpdateT, CuteT]):
+    @abc.abstractmethod
+    async def adapt(self, api: ABCAPI, update: UpdateT) -> Result[CuteT, AdapterError]:
+        pass
+
+
+__all__ = ("ABCAdapter",)

telegrinder/bot/rules/adapter/errors.py

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

telegrinder/bot/rules/adapter/event.py

@@ -0,0 +1,49 @@
+import typing
+
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types import BaseCute
+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.objects import Model, Update
+
+EventT = typing.TypeVar("EventT", bound=Model)
+CuteT = typing.TypeVar("CuteT", bound=BaseCute)
+
+
+class EventAdapter(ABCAdapter[Update, CuteT]):
+    def __init__(self, event_name: str, model: type[CuteT]) -> None:
+        self.event_name = event_name
+        self.model = model
+    
+    def __repr__(self) -> str:
+        raw_update_type = Update.__annotations__.get(self.event_name, "Unknown")
+        raw_update_type = (
+            typing.get_args(raw_update_type)[0].__forward_arg__
+            if typing.get_args(raw_update_type)
+            else raw_update_type
+        )
+        return "<{}: adapt {} -> {}>".format(
+            self.__class__.__name__,
+            raw_update_type,
+            self.model.__name__,
+        )
+
+    async def adapt(self, api: ABCAPI, update: Update) -> Result[CuteT, AdapterError]:
+        update_dct = update.to_dict()
+        if self.event_name not in update_dct:
+            return Error(
+                AdapterError(f"Update is not of event type {self.event_name!r}."),
+            )
+        if update_dct[self.event_name] is Nothing:
+            return Error(
+                AdapterError(f"Update is not an {self.event_name!r}."),
+            )
+        return Ok(
+            self.model.from_update(update_dct[self.event_name].unwrap(), bound_api=api),
+        )
+
+
+__all__ = ("EventAdapter",)

telegrinder/bot/rules/adapter/raw_update.py

@@ -0,0 +1,24 @@
+from fntypes.result import Ok, Result
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types.update import UpdateCute
+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]):
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
+
+    async def adapt(
+        self,
+        api: ABCAPI,
+        update: Update,
+    ) -> Result[UpdateCute, AdapterError]:
+        if not isinstance(update, UpdateCute):
+            return Ok(UpdateCute.from_update(update, api))
+        return Ok(update)
+
+
+__all__ = ("RawUpdateAdapter",)

telegrinder/bot/rules/callback_data.py

@@ -1,57 +1,178 @@
-from .abc import ABCRule, EventScheme
-from telegrinder.modules import json
-from telegrinder.types import Update
-from telegrinder.bot.cute_types import CallbackQueryCute
-from .markup import Markup, check_string
-import msgspec
-import vbml
+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 .abc import ABCRule
+from .markup import Markup, PatternLike, check_string
+
+if typing.TYPE_CHECKING:
+
+    T = typing.TypeVar("T")
+    Ref: typing.TypeAlias = typing.Annotated[T, ...]
+else:
+
+    class Ref:
+        def __class_getitem__(cls, code: str) -> typing.ForwardRef:
+            return typing.ForwardRef(code)
+
 
 CallbackQuery = CallbackQueryCute
-PatternLike = typing.Union[str, vbml.Pattern]
+Validator: typing.TypeAlias = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
+MapDict: typing.TypeAlias = dict[
+    str, typing.Any | type[typing.Any] | Validator | list[Ref["MapDict"]] | Ref["MapDict"]
+]
+CallbackMap: typing.TypeAlias = list[tuple[str, typing.Any | type | Validator | Ref["CallbackMap"]]]
+CallbackMapStrict: typing.TypeAlias = list[tuple[str, Validator | Ref["CallbackMapStrict"]]]
 
 
-class CallbackDataEq(ABCRule):
-    def __init__(self, value: str):
-        self.value = value
+class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
+    adapter = EventAdapter("callback_query", CallbackQuery)
 
-    async def check(self, event: Update, ctx: dict) -> bool:
-        return event.callback_query.data == self.value
+    @abc.abstractmethod
+    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+        pass
 
 
-class CallbackDataJsonEq(ABCRule):
-    def __init__(self, d: dict):
-        self.d = d
+class HasData(CallbackQueryRule):
+    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+        return bool(event.data or event.data.unwrap())
 
-    async def check(self, event: Update, ctx: dict) -> bool:
-        if not event.callback_query.data:
-            return False
-        try:
-            # todo: use msgspec
-            return json.loads(event.callback_query.data) == self.d
-        except:
-            return False
 
+class CallbackQueryDataRule(CallbackQueryRule, abc.ABC, requires=[HasData()]):
+    pass
 
-class CallbackDataJsonModel(ABCRule[CallbackQuery]):
-    __event__ = EventScheme("callback_query", CallbackQuery)
 
-    def __init__(self, model: typing.Type[msgspec.Struct]):
-        self.decoder = msgspec.json.Decoder(type=model)
+class CallbackDataMap(CallbackQueryDataRule):
+    def __init__(self, mapping: MapDict) -> None:
+        self.mapping = self.transform_to_callbacks(
+            self.transform_to_map(mapping),
+        )
 
-    async def check(self, event: CallbackQuery, ctx: dict) -> bool:
-        try:
-            ctx["data"] = self.decoder.decode(event.data.encode())
-            return True
-        except msgspec.DecodeError:
+    @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  # type: ignore
+        
+        return False
+        
+    @classmethod
+    async def match(cls, callback_data: dict, 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):
+        self.value = value
 
+    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+        return event.data.unwrap() == self.value
 
-class CallbackDataMarkup(ABCRule[CallbackQuery]):
-    __event__ = EventScheme("callback_query", CallbackQuery)
 
-    def __init__(self, patterns: typing.Union[PatternLike, typing.List[PatternLike]]):
+class CallbackDataJsonEq(CallbackQueryDataRule):
+    def __init__(self, d: dict[str, typing.Any]):
+        self.d = d
+
+    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+        return event.decode_callback_data().unwrap_or_none() == self.d
+
+
+class CallbackDataJsonModel(CallbackQueryDataRule):
+    def __init__(self, model: type[msgspec.Struct] | type[DataclassInstance]):
+        self.model = model
+        
+    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+        with suppress(BaseException):
+            ctx.data = decoder.decode(event.data.unwrap().encode(), type=self.model)
+            return True
+        return False
+
+
+class CallbackDataMarkup(CallbackQueryDataRule):
+    def __init__(self, patterns: PatternLike | list[PatternLike]):
         self.patterns = Markup(patterns).patterns
 
-    async def check(self, event: CallbackQuery, ctx: dict) -> bool:
-        return check_string(self.patterns, event.data, ctx)
+    async 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/command.py

@@ -0,0 +1,116 @@
+import dataclasses
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+
+from .abc import Message
+from .text import TextMessageRule
+
+Validator = typing.Callable[[str], typing.Any | None]
+
+
+def single_split(s: str, separator: str) -> tuple[str, str]:
+    left, *right = s.split(separator, 1)
+    return left, (right[0] if right else "")
+
+
+@dataclasses.dataclass(frozen=True)
+class Argument:
+    name: str
+    validators: list[Validator] = dataclasses.field(default_factory=lambda: [])
+    optional: bool = dataclasses.field(default=False, kw_only=True)
+
+    def check(self, data: str) -> typing.Any | None:
+        for validator in self.validators:
+            data = validator(data)  # type: ignore
+            if data is None:
+                return None
+        return data
+
+
+class Command(TextMessageRule):
+    def __init__(
+        self,
+        names: str | typing.Iterable[str],
+        *arguments: Argument,
+        prefixes: tuple[str, ...] = ("/",),
+        separator: str = " ",
+        lazy: bool = False,
+    ) -> None:
+        self.names = [names] if isinstance(names, str) else names
+        self.arguments = arguments
+        self.prefixes = prefixes
+        self.separator = separator
+        self.lazy = lazy
+
+    def remove_prefix(self, text: str) -> str | None:
+        for prefix in self.prefixes:
+            if text.startswith(prefix):
+                return text.removeprefix(prefix)
+        return None
+
+    def parse_argument(
+        self,
+        arguments: list[Argument],
+        data_s: str,
+        new_s: str,
+        s: str,
+    ) -> dict | None:
+        argument = arguments[0]
+        data = argument.check(data_s)
+        if data is None and not argument.optional:
+            return None
+
+        if data is None:
+            return self.parse_arguments(arguments[1:], s)
+
+        with_argument = self.parse_arguments(arguments[1:], new_s)
+        if with_argument is not None:
+            return {argument.name: data, **with_argument}
+
+        if not argument.optional:
+            return None
+
+        return self.parse_arguments(arguments[1:], s)
+
+    def parse_arguments(self, arguments: list[Argument], s: str) -> dict | None:
+        if not arguments:
+            return {} if not s else None
+
+        if self.lazy:
+            return self.parse_argument(arguments, *single_split(s, self.separator), s)
+
+        all_split = s.split(self.separator)
+        for i in range(1, len(all_split) + 1):
+            ctx = self.parse_argument(
+                arguments,
+                self.separator.join(all_split[:i]),
+                self.separator.join(all_split[i:]),
+                s,
+            )
+            if ctx is not None:
+                return ctx
+
+        return None
+
+    async def check(self, message: Message, ctx: Context) -> bool:
+        text = self.remove_prefix(message.text.unwrap())
+        if text is None:
+            return False
+
+        name, arguments = single_split(text, self.separator)
+        if name not in self.names:
+            return False
+
+        if not self.arguments:
+            return not arguments
+
+        result = self.parse_arguments(list(self.arguments), arguments)
+        if result is None:
+            return False
+
+        ctx.update(result)
+        return True
+
+
+__all__ = ("Argument", "Command", "single_split")

telegrinder/bot/rules/enum_text.py

@@ -0,0 +1,28 @@
+import enum
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+
+from .abc import Message
+from .text import TextMessageRule
+
+T = typing.TypeVar("T", bound=enum.Enum, covariant=True)
+
+
+class EnumTextRule(TextMessageRule, typing.Generic[T]):
+    def __init__(self, enum_t: type[T], *, lower_case: bool = True) -> None:
+        self.enum_t = enum_t
+        self.texts = list(map(lambda x: x.value.lower() if lower_case else x.value, self.enum_t))
+
+    def find(self, s: str) -> T:
+        for enumeration in self.enum_t:
+            if enumeration.value.lower() == s:
+                return enumeration
+        raise KeyError("Enumeration is undefined.")
+
+    async def check(self, message: Message, ctx: Context) -> bool:
+        text = message.text.unwrap().lower()
+        if text not in self.texts:
+            return False
+        ctx.enum_text = self.find(text)
+        return True