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

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",
+)

telegrinder/bot/rules/markup.py

@@ -1,28 +1,28 @@
-from .abc import Message, patcher
-from .text import ABCTextMessageRule
-import typing
 import vbml
 
-PatternLike = typing.Union[str, vbml.Pattern]
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.tools.global_context import TelegrinderCtx
 
+from .abc import Message
+from .text import TextMessageRule
 
-def check_string(
-    patterns: typing.Union[PatternLike, typing.List[PatternLike]], s: str, ctx: dict
-) -> bool:
-    if s is None:
-        return False
+PatternLike = str | vbml.Pattern
+global_ctx = TelegrinderCtx()
+
+
+def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
     for pattern in patterns:
-        response = patcher.check(pattern, s)
-        if response in (False, None):
-            continue
-        elif isinstance(response, dict):
-            ctx.update(response)
+        match global_ctx.vbml_patcher.check(pattern, s):
+            case None | False:
+                continue
+            case {**response}:
+                ctx |= response
         return True
     return False
 
 
-class Markup(ABCTextMessageRule):
-    def __init__(self, patterns: typing.Union[PatternLike, typing.List[PatternLike]]):
+class Markup(TextMessageRule):
+    def __init__(self, patterns: PatternLike | list[PatternLike]):
         if not isinstance(patterns, list):
             patterns = [patterns]
         self.patterns = [
@@ -30,5 +30,8 @@ class Markup(ABCTextMessageRule):
             for pattern in patterns
         ]
 
-    async def check(self, message: Message, ctx: dict) -> bool:
-        return check_string(self.patterns, message.text, ctx)
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return check_string(self.patterns, message.text.unwrap(), ctx)
+
+
+__all__ = ("Markup", "check_string")

telegrinder/bot/rules/mention.py

@@ -0,0 +1,17 @@
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types.enums import MessageEntityType
+
+from .text import Message, TextMessageRule
+
+
+class HasMention(TextMessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        if not message.entities.unwrap_or_none():
+            return False
+        return any(
+            entity.type == MessageEntityType.MENTION
+            for entity in message.entities.unwrap()
+        )
+
+
+__all__ = ("HasMention",)

telegrinder/bot/rules/message_entities.py

@@ -0,0 +1,33 @@
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types.enums import MessageEntityType
+from telegrinder.types.objects import MessageEntity
+
+from .abc import Message, MessageRule
+
+Entity = str | MessageEntityType
+
+
+class HasEntities(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return bool(message.entities)
+
+
+class MessageEntities(MessageRule, requires=[HasEntities()]):
+    def __init__(self, entities: Entity | list[Entity]):
+        self.entities = [entities] if not isinstance(entities, list) else entities
+
+    async def check(self, message: Message, ctx: Context) -> bool:
+        message_entities: list[MessageEntity] = []
+        for entity in message.entities.unwrap():
+            for entity_type in self.entities:
+                if entity_type == entity.type:
+                    message_entities.append(entity)
+
+        if not message_entities:
+            return False
+
+        ctx.message_entities = message_entities
+        return True
+
+
+__all__ = ("HasEntities", "MessageEntities")

telegrinder/bot/rules/regex.py

@@ -1,30 +1,38 @@
 import re
 import typing
 
-from .abc import Message
-from .text import ABCTextMessageRule
+from telegrinder.bot.dispatch.context import Context
 
-PatternLike = typing.Union[str, typing.Pattern]
+from .abc import Message
+from .text import TextMessageRule
 
+PatternLike = str | typing.Pattern[str]
 
-class Regex(ABCTextMessageRule):
-    def __init__(self, regexp: typing.Union[PatternLike, typing.List[PatternLike]]):
-        if isinstance(regexp, re.Pattern):
-            regexp = [regexp]
-        elif isinstance(regexp, str):
-            regexp = [re.compile(regexp)]
-        else:
-            regexp = [
-                re.compile(regexp) if isinstance(regexp, str) else regexp
-                for regexp in regexp
-            ]
 
-        self.regexp = regexp
+class Regex(TextMessageRule):
+    def __init__(self, regexp: PatternLike | list[PatternLike]):
+        self.regexp: list[re.Pattern[str]] = []
+        match regexp:
+            case re.Pattern() as pattern:
+                self.regexp.append(pattern)
+            case str(regex):
+                self.regexp.append(re.compile(regex))
+            case _:
+                self.regexp.extend(
+                    re.compile(regexp) if isinstance(regexp, str) else regexp
+                    for regexp in regexp
+                )
 
-    async def check(self, message: Message, ctx: dict) -> bool:
+    async def check(self, message: Message, ctx: Context) -> bool:
         for regexp in self.regexp:
-            match = re.match(regexp, message.text)
-            if match:
-                ctx.update({"match": match.groups()})
+            response = re.match(regexp, message.text.unwrap())
+            if response is not None:
+                if matches := response.groupdict():
+                    ctx |= matches
+                else:
+                    ctx |= {"matches": response.groups() or (response.group(),)}
                 return True
         return False
+
+
+__all__ = ("Regex",)

telegrinder/bot/rules/rule_enum.py

@@ -0,0 +1,74 @@
+import dataclasses
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+
+from .abc import ABCRule, T, Update, check_rule
+from .func import FuncRule
+
+
+@dataclasses.dataclass
+class RuleEnumState:
+    name: str
+    rule: ABCRule
+    cls: type["RuleEnum"]
+
+    def __eq__(self, other: typing.Self) -> bool:
+        return self.cls == other.cls and self.name == other.name
+
+
+class RuleEnum(ABCRule[T]):
+    __enum__: list[RuleEnumState]
+
+    def __init_subclass__(cls, *args, **kwargs):
+        new_attributes = (
+            set(cls.__dict__) - set(RuleEnum.__dict__) - {"__enum__", "__init__"}
+        )
+        enum_lst: list[RuleEnumState] = []
+
+        self = cls.__new__(cls)
+        self.__init__()
+
+        for attribute_name in new_attributes:
+            rules = getattr(cls, attribute_name)
+            attribute = RuleEnumState(attribute_name, rules, cls)
+
+            setattr(
+                self,
+                attribute.name,
+                self & FuncRule(lambda _, ctx: self.must_be_state(ctx, attribute)),
+            )
+            enum_lst.append(attribute)
+
+        setattr(cls, "__enum__", enum_lst)
+
+    @classmethod
+    def save_state(cls, ctx: Context, enum: RuleEnumState) -> None:
+        ctx.update({cls.__class__.__name__ + "_state": enum})
+
+    @classmethod
+    def check_state(cls, ctx: Context) -> RuleEnumState | None:
+        return ctx.get(cls.__class__.__name__ + "_state")
+
+    @classmethod
+    def must_be_state(cls, ctx: Context, state: RuleEnumState) -> bool:
+        real_state = cls.check_state(ctx)
+        if not real_state:
+            return False
+        return real_state == state
+
+    async def check(self, event: Update, ctx: Context) -> bool:
+        if self.check_state(ctx):
+            return True
+
+        for enum in self.__enum__:
+            ctx_copy = ctx.copy()
+            if await check_rule(event.ctx_api, enum.rule, event, ctx_copy):
+                ctx.update(ctx_copy)
+                self.save_state(ctx, enum)
+                return True
+
+        return False
+
+
+__all__ = ("RuleEnum", "RuleEnumState")

telegrinder/bot/rules/start.py

@@ -1,30 +1,42 @@
-from .abc import ABCMessageRule
-from .markup import Markup, Message
 import typing
 
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types.enums import MessageEntityType
+
+from .abc import MessageRule
+from .is_from import IsPrivate
+from .markup import Markup, Message
+from .message_entities import MessageEntities
+
 
 class StartCommand(
-    ABCMessageRule,
-    require=[Markup(["/start <param>", "/start"])]
+    MessageRule, requires=[
+        IsPrivate() & MessageEntities(MessageEntityType.BOT_COMMAND)
+        & Markup(["/start <param>", "/start"]),
+    ]
 ):
     def __init__(
-        self, 
-        validator: typing.Callable[str, typing.Any | None] | None = None,
+        self,
+        validator: typing.Callable[[str], typing.Any | None] | None = None,
+        *,
         param_required: bool = False,
+        alias: str | None = None,
     ) -> None:
         self.param_required = param_required
         self.validator = validator
+        self.alias = alias
 
-    async def check(self, message: Message, ctx: dict) -> bool:
-        param: str | None = ctx.get("param")
+    async def check(self, _: Message, ctx: Context) -> bool:
+        param: str | None = ctx.pop("param", None)
         validated_param = (
-            self.validator(param) 
-            if self.validator and param is not None 
-            else param
+            self.validator(param) if self.validator and param is not None else param
         )
 
         if self.param_required and validated_param is None:
             return False
-        
-        ctx["param"] = validated_param
+
+        ctx.set(self.alias or "param", validated_param)
         return True
+
+
+__all__ = ("StartCommand",)

telegrinder/bot/rules/text.py

@@ -1,26 +1,35 @@
-from .abc import ABC, ABCMessageRule, Message
-import typing
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.tools.i18n.base import ABCTranslator
 
+from .abc import ABC, Message, MessageRule, with_caching_translations
 
-class HasText(ABCMessageRule):
-    async def check(self, message: Message, ctx: dict) -> bool:
+
+class HasText(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
         return bool(message.text)
 
 
-class ABCTextMessageRule(ABCMessageRule, ABC, require=[HasText()]):
+class TextMessageRule(MessageRule, ABC, requires=[HasText()]):
     pass
 
 
-class Text(ABCTextMessageRule):
-    def __init__(
-        self, texts: typing.Union[str, typing.List[str]], ignore_case: bool = False
-    ):
+class Text(TextMessageRule):
+    def __init__(self, texts: str | list[str], ignore_case: bool = False):
         if not isinstance(texts, list):
             texts = [texts]
-        self.texts = texts
+        self.texts = texts if not ignore_case else list(map(str.lower, texts))
         self.ignore_case = ignore_case
 
-    async def check(self, message: Message, ctx: dict) -> bool:
-        if self.ignore_case:
-            return message.text.lower() in list(map(str.lower, self.texts))
-        return message.text in self.texts
+    async def check(self, message: Message, ctx: Context) -> bool:
+        text = message.text.unwrap()
+        return (text if not self.ignore_case else text.lower()) in self.texts
+
+    @with_caching_translations
+    async def translate(self, translator: ABCTranslator) -> "Text":
+        return Text(
+            texts=[translator.get(text) for text in self.texts],
+            ignore_case=self.ignore_case,
+        )
+
+
+__all__ = ("HasText", "Text", "TextMessageRule")