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

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

telegrinder/bot/rules/func.py

@@ -1,26 +1,26 @@
-from .abc import ABCRule, EventScheme, T
-from telegrinder.types import Update
+import inspect
 import typing
 
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types import Update
+
+from .abc import ABCAdapter, ABCRule, RawUpdateAdapter, T
+
 
 class FuncRule(ABCRule, typing.Generic[T]):
     def __init__(
         self,
-        func: typing.Callable[[T, dict], bool],
-        event_scheme: typing.Optional[
-            typing.Union[EventScheme, typing.Tuple[str, typing.Type[T]]]
-        ] = None,
+        func: typing.Callable[[T, Context], typing.Awaitable[bool] | bool],
+        adapter: ABCAdapter[Update, T] | None = None,
     ):
         self.func = func
-        if isinstance(event_scheme, tuple):
-            event_scheme = EventScheme(*event_scheme)
-        self.event_scheme = event_scheme
+        self.adapter = adapter or RawUpdateAdapter()
+
+    async def check(self, event: T, ctx: Context) -> bool:
+        result = self.func(event, ctx)
+        if inspect.isawaitable(result):
+            return await result
+        return result  # type: ignore
+
 
-    async def check(self, event: Update, ctx: dict) -> bool:
-        if self.event_scheme:
-            if self.event_scheme.name not in event:
-                return False
-            event = self.event_scheme.dataclass(
-                **getattr(event, self.event_scheme.name).to_dict()
-            )
-        return self.func(event, ctx)
+__all__ = ("FuncRule",)

telegrinder/bot/rules/fuzzy.py

@@ -1,24 +1,27 @@
-from .abc import Message
-from .text import ABCTextMessageRule
 import difflib
-import typing
+
+from telegrinder.bot.dispatch.context import Context
+
+from .abc import Message
+from .text import TextMessageRule
 
 
-class FuzzyText(ABCTextMessageRule):
-    def __init__(
-        self, texts: typing.Union[str, typing.List[str]], min_ratio: float = 0.7
-    ):
+class FuzzyText(TextMessageRule):
+    def __init__(self, texts: str | list[str], min_ratio: float = 0.7):
         if isinstance(texts, str):
             texts = [texts]
         self.texts = texts
         self.min_ratio = min_ratio
 
-    async def check(self, message: Message, ctx: dict) -> bool:
+    async def check(self, message: Message, ctx: Context) -> bool:
         match = max(
-            difflib.SequenceMatcher(a=message.text, b=text).ratio()
+            difflib.SequenceMatcher(a=message.text.unwrap(), b=text).ratio()
             for text in self.texts
         )
         if match < self.min_ratio:
             return False
-        ctx["fuzzy_ratio"] = match
+        ctx.fuzzy_ratio = match
         return True
+
+
+__all__ = ("FuzzyText",)

telegrinder/bot/rules/inline.py

@@ -0,0 +1,61 @@
+import abc
+
+from telegrinder.bot.cute_types import InlineQueryCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.adapter import EventAdapter
+from telegrinder.types.enums import ChatType
+
+from .markup import Markup, PatternLike, check_string
+
+InlineQuery = InlineQueryCute
+
+
+class InlineQueryRule(ABCRule[InlineQuery], abc.ABC):
+    adapter = EventAdapter("inline_query", InlineQuery)
+
+    @abc.abstractmethod
+    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+        pass
+
+
+class HasLocation(InlineQueryRule):
+    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+        return bool(query.location)
+
+
+class InlineQueryChatType(InlineQueryRule):
+    def __init__(self, chat_type: ChatType, /) -> None:
+        self.chat_type = chat_type
+
+    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+        return query.chat_type.map(lambda x: x == self.chat_type).unwrap_or(False)
+
+
+class InlineQueryText(InlineQueryRule):
+    def __init__(self, texts: str | list[str], *, lower_case: bool = False) -> None:
+        self.texts = [
+            text.lower() if lower_case else text
+            for text in ([texts] if isinstance(texts, str) else texts)
+        ]
+        self.lower_case = lower_case
+
+    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+        return (query.query.lower() if self.lower_case else query.query) in self.texts
+
+
+class InlineQueryMarkup(InlineQueryRule):
+    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
+        self.patterns = Markup(patterns).patterns
+    
+    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+        return check_string(self.patterns, query.query, ctx)
+
+
+__all__ = (
+    "HasLocation",
+    "InlineQueryRule",
+    "InlineQueryText",
+    "InlineQueryMarkup",
+    "InlineQueryChatType",
+)

telegrinder/bot/rules/integer.py

@@ -1,14 +1,19 @@
-from .text import ABCTextMessageRule, Message
+from telegrinder.bot.dispatch.context import Context
 
+from .text import Message, TextMessageRule
 
-class Integer(ABCTextMessageRule):
-    async def check(self, message: Message, ctx: dict) -> bool:
-        return message.text.isdigit()
 
+class Integer(TextMessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.text.unwrap().isdigit()
 
-class IntegerInRange(ABCTextMessageRule, require=[Integer()]):
+
+class IntegerInRange(TextMessageRule, requires=[Integer()]):
     def __init__(self, rng: range):
         self.rng = rng
 
-    async def check(self, message: Message, ctx: dict) -> bool:
-        return int(message.text) in self.rng
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return int(message.text.unwrap()) in self.rng
+
+
+__all__ = ("Integer", "IntegerInRange")

telegrinder/bot/rules/is_from.py

@@ -1,11 +1,152 @@
-from .abc import ABCMessageRule, Message
+import typing
 
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.msgspec_utils import Option
+from telegrinder.types.enums import ChatType, DiceEmoji
+from telegrinder.types.objects import User
 
-class IsPrivate(ABCMessageRule):
-    async def check(self, message: Message, ctx: dict) -> bool:
-        return message.chat.id > 0
+from .abc import ABCRule, Message, MessageRule
 
+T = typing.TypeVar("T", bound=BaseCute)
 
-class IsChat(ABCMessageRule):
-    async def check(self, message: Message, ctx: dict) -> bool:
-        return message.chat.id < 0
+
+@typing.runtime_checkable
+class HasFromProto(typing.Protocol):
+    from_: User | Option[User]
+
+
+class HasFrom(ABCRule[T]):
+    async def check(self, event: T, ctx: Context) -> bool:
+        return isinstance(event, HasFromProto) and bool(event.from_)
+
+
+class HasDice(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return bool(message.dice)
+
+
+class IsReply(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return bool(message.reply_to_message)
+
+
+class IsSticker(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return bool(message.sticker)
+
+
+class IsBot(MessageRule, requires=[HasFrom()]):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.from_user.is_bot
+
+
+class IsUser(MessageRule, requires=[HasFrom()]):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return not message.from_user.is_bot
+
+
+class IsPremium(MessageRule, requires=[HasFrom()]):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.from_user.is_premium.unwrap_or(False)
+
+
+class IsLanguageCode(MessageRule, requires=[HasFrom()]):
+    def __init__(self, lang_codes: str | list[str], /) -> None:
+        self.lang_codes = [lang_codes] if isinstance(lang_codes, str) else lang_codes
+
+    async def check(self, message: Message, ctx: Context) -> bool:
+        if not message.from_user.language_code:
+            return False
+        return message.from_user.language_code.unwrap_or_none() in self.lang_codes
+
+
+class IsForum(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.chat.is_forum.unwrap_or(False)
+
+
+class IsUserId(MessageRule, requires=[HasFrom()]):
+    def __init__(self, user_ids: int | list[int], /) -> None:
+        self.user_ids = [user_ids] if isinstance(user_ids, int) else user_ids
+
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.from_user.id in self.user_ids
+
+
+class IsChatId(MessageRule):
+    def __init__(self, chat_ids: int | list[int], /) -> None:
+        self.chat_ids = [chat_ids] if isinstance(chat_ids, int) else chat_ids
+
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.chat.id in self.chat_ids
+
+
+class IsPrivate(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.chat.type == ChatType.PRIVATE
+
+
+class IsGroup(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.chat.type == ChatType.GROUP
+
+
+class IsSuperGroup(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.chat.type == ChatType.SUPERGROUP
+
+
+class IsChat(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
+
+
+class IsDice(MessageRule, requires=[HasDice()]):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.dice.unwrap().emoji == DiceEmoji.DICE
+
+
+class IsDartDice(MessageRule, requires=[HasDice()]):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.dice.unwrap().emoji == DiceEmoji.DART
+
+
+class IsBasketballDice(MessageRule, requires=[HasDice()]):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.dice.unwrap().emoji == DiceEmoji.BASKETBALL
+
+
+class IsFootballDice(MessageRule, requires=[HasDice()]):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.dice.unwrap().emoji == DiceEmoji.FOOTBALL
+
+
+class IsSlotMachineDice(MessageRule, requires=[HasDice()]):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.dice.unwrap().emoji == DiceEmoji.SLOT_MACHINE
+
+
+class IsBowlingDice(MessageRule, requires=[HasDice()]):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.dice.unwrap().emoji == DiceEmoji.BOWLING
+
+
+__all__ = (
+    "IsBasketballDice",
+    "IsBot",
+    "IsBowlingDice",
+    "IsChat",
+    "IsChatId",
+    "IsDartDice",
+    "IsDice",
+    "IsForum",
+    "IsGroup",
+    "IsLanguageCode",
+    "IsPremium",
+    "IsPrivate",
+    "IsReply",
+    "IsSuperGroup",
+    "IsUser",
+    "IsUserId",
+)