telegrinder 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/bot/rules/enum_text.py

@@ -1,36 +1,33 @@
-import enum
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.text import Text
-
-from .abc import ABCRule
-
-T = typing.TypeVar("T", bound=enum.Enum)
-
-
-class EnumTextRule(ABCRule, 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.")
-
-    def check(self, text: Text, ctx: Context) -> bool:
-        text = text.lower()  # type: ignore
-        if text not in self.texts:
-            return False
-        ctx.enum_text = self.find(text)
-        return True
-
-
-__all__ = ("EnumTextRule",)
+import enum
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.text import Text
+
+from .abc import ABCRule
+
+
+class EnumTextRule[T: enum.Enum](ABCRule):
+    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.")
+
+    def check(self, text: Text, ctx: Context) -> bool:
+        text = text.lower()  # type: ignore
+        if text not in self.texts:
+            return False
+        ctx.enum_text = self.find(text)
+        return True
+
+
+__all__ = ("EnumTextRule",)

telegrinder/bot/rules/func.py

@@ -1,26 +1,28 @@
-import inspect
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.types.objects import Update
-
-from .abc import ABCAdapter, ABCRule, AdaptTo, RawUpdateAdapter
-
-
-class FuncRule(ABCRule, typing.Generic[AdaptTo]):
-    def __init__(
-        self,
-        func: typing.Callable[[AdaptTo, Context], typing.Awaitable[bool] | bool],
-        adapter: ABCAdapter[Update, AdaptTo] | None = None,
-    ) -> None:
-        self.func = func
-        self.adapter = adapter or RawUpdateAdapter()  # type: ignore
-
-    async def check(self, event: AdaptTo, ctx: Context) -> bool:
-        result = self.func(event, ctx)
-        if inspect.isawaitable(result):
-            return await result
-        return result  # type: ignore
-
-
-__all__ = ("FuncRule",)
+import inspect
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.raw_update import RawUpdateAdapter
+from telegrinder.types.objects import Update
+
+from .abc import ABCRule, AdaptTo
+
+
+class FuncRule(ABCRule, typing.Generic[AdaptTo]):
+    def __init__(
+        self,
+        func: typing.Callable[[AdaptTo, Context], typing.Awaitable[bool] | bool],
+        adapter: ABCAdapter[Update, AdaptTo] | None = None,
+    ) -> None:
+        self.func = func
+        self.adapter = adapter or RawUpdateAdapter()  # type: ignore
+
+    async def check(self, event: AdaptTo, ctx: Context) -> bool:
+        result = self.func(event, ctx)
+        if inspect.isawaitable(result):
+            result = await result
+        return result
+
+
+__all__ = ("FuncRule",)

telegrinder/bot/rules/fuzzy.py

@@ -1,24 +1,24 @@
-import difflib
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.text import Text
-
-from .abc import ABCRule
-
-
-class FuzzyText(ABCRule):
-    def __init__(self, texts: str | list[str], min_ratio: float = 0.7) -> None:
-        if isinstance(texts, str):
-            texts = [texts]
-        self.texts = texts
-        self.min_ratio = min_ratio
-
-    def check(self, message_text: Text, ctx: Context) -> bool:
-        match = max(difflib.SequenceMatcher(a=message_text, b=text).ratio() for text in self.texts)
-        if match < self.min_ratio:
-            return False
-        ctx.fuzzy_ratio = match
-        return True
-
-
-__all__ = ("FuzzyText",)
+import difflib
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.text import Text
+
+from .abc import ABCRule
+
+
+class FuzzyText(ABCRule):
+    def __init__(self, texts: str | list[str], /, min_ratio: float = 0.7) -> None:
+        if isinstance(texts, str):
+            texts = [texts]
+        self.texts = texts
+        self.min_ratio = min_ratio
+
+    def check(self, message_text: Text, ctx: Context) -> bool:
+        match = max(difflib.SequenceMatcher(a=message_text, b=text).ratio() for text in self.texts)
+        if match < self.min_ratio:
+            return False
+        ctx.fuzzy_ratio = match
+        return True
+
+
+__all__ = ("FuzzyText",)

telegrinder/bot/rules/id.py

@@ -0,0 +1,24 @@
+import typing
+
+from telegrinder.types.objects import Update
+
+from .abc import ABCRule
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.adapter.abc import ABCAdapter
+
+
+class IdRule[Identifier](ABCRule[Identifier]):
+    def __init__(
+        self,
+        adapter: "ABCAdapter[Update, Identifier]",
+        tracked_identifiers: set[Identifier] | None = None,
+    ):
+        self.tracked_identifiers = tracked_identifiers or set()
+        self.adapter = adapter
+
+    async def check(self, event: Identifier) -> bool:
+        return event in self.tracked_identifiers
+
+
+__all__ = ("IdRule",)

telegrinder/bot/rules/inline.py

@@ -1,60 +1,62 @@
-import abc
-import typing
-
-from telegrinder.bot.cute_types import InlineQueryCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.abc import ABCRule, CheckResult
-from telegrinder.bot.rules.adapter import EventAdapter
-from telegrinder.types.enums import ChatType, UpdateType
-
-from .markup import Markup, PatternLike, check_string
-
-InlineQuery: typing.TypeAlias = InlineQueryCute
-
-
-class InlineQueryRule(ABCRule[InlineQuery], abc.ABC):
-    adapter: EventAdapter[InlineQuery] = EventAdapter(UpdateType.INLINE_QUERY, InlineQuery)
-
-    @abc.abstractmethod
-    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
-
-
-class HasLocation(InlineQueryRule):
-    def check(self, query: InlineQuery) -> bool:
-        return bool(query.location)
-
-
-class InlineQueryChatType(InlineQueryRule):
-    def __init__(self, chat_type: ChatType, /) -> None:
-        self.chat_type = chat_type
-
-    def check(self, query: InlineQuery) -> 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
-
-    def check(self, query: InlineQuery) -> 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
-
-    def check(self, query: InlineQuery, ctx: Context) -> bool:
-        return check_string(self.patterns, query.query, ctx)
-
-
-__all__ = (
+import abc
+import typing
+
+from telegrinder.bot.cute_types import InlineQueryCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule, CheckResult
+from telegrinder.tools.adapter.event import EventAdapter
+from telegrinder.types.enums import ChatType, UpdateType
+
+from .markup import Markup, PatternLike, check_string
+
+InlineQuery: typing.TypeAlias = InlineQueryCute
+
+
+class InlineQueryRule(
+    ABCRule[InlineQuery],
+    abc.ABC,
+    adapter=EventAdapter(UpdateType.INLINE_QUERY, InlineQuery),
+):
+    @abc.abstractmethod
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+
+
+class HasLocation(InlineQueryRule):
+    def check(self, query: InlineQuery) -> bool:
+        return bool(query.location)
+
+
+class InlineQueryChatType(InlineQueryRule):
+    def __init__(self, chat_type: ChatType, /) -> None:
+        self.chat_type = chat_type
+
+    def check(self, query: InlineQuery) -> 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
+
+    def check(self, query: InlineQuery) -> 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
+
+    def check(self, query: InlineQuery, ctx: Context) -> bool:
+        return check_string(self.patterns, query.query, ctx)
+
+
+__all__ = (
     "HasLocation",
     "InlineQueryChatType",
     "InlineQueryMarkup",
     "InlineQueryRule",
-    "InlineQueryText",
-)
+    "InlineQueryText",
+)

telegrinder/bot/rules/integer.py

@@ -1,20 +1,21 @@
-from telegrinder.node.text import TextInteger
-
-from .abc import ABCRule
-from .node import NodeRule
-
-
-class IsInteger(NodeRule):
-    def __init__(self) -> None:
-        super().__init__(TextInteger)
-
-
-class IntegerInRange(ABCRule):
-    def __init__(self, rng: range) -> None:
-        self.rng = rng
-
-    def check(self, integer: TextInteger) -> bool:
-        return integer in self.rng
-
-
-__all__ = ("IntegerInRange", "IsInteger")
+from telegrinder.node.base import as_node
+from telegrinder.node.text import TextInteger
+
+from .abc import ABCRule
+from .node import NodeRule
+
+
+class IsInteger(NodeRule):
+    def __init__(self) -> None:
+        super().__init__(as_node(TextInteger))
+
+
+class IntegerInRange(ABCRule):
+    def __init__(self, rng: range) -> None:
+        self.rng = rng
+
+    def check(self, integer: TextInteger) -> bool:
+        return integer in self.rng
+
+
+__all__ = ("IntegerInRange", "IsInteger")

telegrinder/bot/rules/is_from.py

@@ -1,128 +1,128 @@
-import typing
-
-from telegrinder.node.source import ChatSource, UserSource
-from telegrinder.types.enums import ChatType, DiceEmoji
-
-from .abc import ABCRule, Message
-from .message import MessageRule
-
-
-class IsBot(ABCRule):
-    def check(self, user: UserSource) -> bool:
-        return user.is_bot
-
-
-class IsUser(ABCRule):
-    def check(self, user: UserSource) -> bool:
-        return not user.is_bot
-
-
-class IsPremium(ABCRule):
-    def check(self, user: UserSource) -> bool:
-        return user.is_premium.unwrap_or(False)
-
-
-class IsLanguageCode(ABCRule):
-    def __init__(self, lang_codes: str | list[str], /) -> None:
-        self.lang_codes = [lang_codes] if isinstance(lang_codes, str) else lang_codes
-
-    def check(self, user: UserSource) -> bool:
-        return user.language_code.unwrap_or_none() in self.lang_codes
-
-
-class IsUserId(ABCRule):
-    def __init__(self, user_ids: int | list[int], /) -> None:
-        self.user_ids = [user_ids] if isinstance(user_ids, int) else user_ids
-
-    def check(self, user: UserSource) -> bool:
-        return user.id in self.user_ids
-
-
-class IsForum(ABCRule):
-    def check(self, chat: ChatSource) -> bool:
-        return chat.is_forum.unwrap_or(False)
-
-
-class IsChatId(ABCRule):
-    def __init__(self, chat_ids: int | list[int], /) -> None:
-        self.chat_ids = [chat_ids] if isinstance(chat_ids, int) else chat_ids
-
-    def check(self, chat: ChatSource) -> bool:
-        return chat.id in self.chat_ids
-
-
-class IsPrivate(ABCRule):
-    def check(self, chat: ChatSource) -> bool:
-        return chat.type == ChatType.PRIVATE
-
-
-class IsGroup(ABCRule):
-    def check(self, chat: ChatSource) -> bool:
-        return chat.type == ChatType.GROUP
-
-
-class IsSuperGroup(ABCRule):
-    def check(self, chat: ChatSource) -> bool:
-        return chat.type == ChatType.SUPERGROUP
-
-
-class IsChat(ABCRule):
-    def check(self, chat: ChatSource) -> bool:
-        return chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
-
-
-class IsDice(MessageRule):
-    def check(self, message: Message) -> bool:
-        return bool(message.dice)
-
-
-class IsDiceEmoji(MessageRule, requires=[IsDice()]):
-    def __init__(self, dice_emoji: DiceEmoji, /) -> None:
-        self.dice_emoji = dice_emoji
-
-    def check(self, message: Message) -> bool:
-        return message.dice.unwrap().emoji == self.dice_emoji
-
-
-class IsForward(MessageRule):
-    def check(self, message: Message) -> bool:
-        return bool(message.forward_origin)
-
-
-class IsForwardType(MessageRule, requires=[IsForward()]):
-    def __init__(self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /) -> None:
-        self.fwd_type = fwd_type
-
-    def check(self, message: Message) -> bool:
-        return message.forward_origin.unwrap().v.type == self.fwd_type
-
-
-class IsReply(MessageRule):
-    def check(self, message: Message) -> bool:
-        return bool(message.reply_to_message)
-
-
-class IsSticker(MessageRule):
-    def check(self, message: Message) -> bool:
-        return bool(message.sticker)
-
-
-class IsVideoNote(MessageRule):
-    def check(self, message: Message) -> bool:
-        return bool(message.video_note)
-
-
-class IsDocument(MessageRule):
-    def check(self, message: Message) -> bool:
-        return bool(message.document)
-
-
-class IsPhoto(MessageRule):
-    def check(self, message: Message) -> bool:
-        return bool(message.photo)
-
-
-__all__ = (
+import typing
+
+from telegrinder.node.source import ChatSource, UserSource
+from telegrinder.types.enums import ChatType, DiceEmoji
+
+from .abc import ABCRule, Message
+from .message import MessageRule
+
+
+class IsBot(ABCRule):
+    def check(self, user: UserSource) -> bool:
+        return user.is_bot
+
+
+class IsUser(ABCRule):
+    def check(self, user: UserSource) -> bool:
+        return not user.is_bot
+
+
+class IsPremium(ABCRule):
+    def check(self, user: UserSource) -> bool:
+        return user.is_premium.unwrap_or(False)
+
+
+class IsLanguageCode(ABCRule):
+    def __init__(self, lang_codes: str | list[str], /) -> None:
+        self.lang_codes = [lang_codes] if isinstance(lang_codes, str) else lang_codes
+
+    def check(self, user: UserSource) -> bool:
+        return user.language_code.unwrap_or_none() in self.lang_codes
+
+
+class IsUserId(ABCRule):
+    def __init__(self, user_ids: int | list[int], /) -> None:
+        self.user_ids = [user_ids] if isinstance(user_ids, int) else user_ids
+
+    def check(self, user: UserSource) -> bool:
+        return user.id in self.user_ids
+
+
+class IsForum(ABCRule):
+    def check(self, chat: ChatSource) -> bool:
+        return chat.is_forum.unwrap_or(False)
+
+
+class IsChatId(ABCRule):
+    def __init__(self, chat_ids: int | list[int], /) -> None:
+        self.chat_ids = [chat_ids] if isinstance(chat_ids, int) else chat_ids
+
+    def check(self, chat: ChatSource) -> bool:
+        return chat.id in self.chat_ids
+
+
+class IsPrivate(ABCRule):
+    def check(self, chat: ChatSource) -> bool:
+        return chat.type == ChatType.PRIVATE
+
+
+class IsGroup(ABCRule):
+    def check(self, chat: ChatSource) -> bool:
+        return chat.type == ChatType.GROUP
+
+
+class IsSuperGroup(ABCRule):
+    def check(self, chat: ChatSource) -> bool:
+        return chat.type == ChatType.SUPERGROUP
+
+
+class IsChat(ABCRule):
+    def check(self, chat: ChatSource) -> bool:
+        return chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
+
+
+class IsDice(MessageRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.dice)
+
+
+class IsDiceEmoji(MessageRule, requires=[IsDice()]):
+    def __init__(self, dice_emoji: DiceEmoji, /) -> None:
+        self.dice_emoji = dice_emoji
+
+    def check(self, message: Message) -> bool:
+        return message.dice.unwrap().emoji == self.dice_emoji
+
+
+class IsForward(MessageRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.forward_origin)
+
+
+class IsForwardType(MessageRule, requires=[IsForward()]):
+    def __init__(self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /) -> None:
+        self.fwd_type = fwd_type
+
+    def check(self, message: Message) -> bool:
+        return message.forward_origin.unwrap().v.type == self.fwd_type
+
+
+class IsReply(MessageRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.reply_to_message)
+
+
+class IsSticker(MessageRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.sticker)
+
+
+class IsVideoNote(MessageRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.video_note)
+
+
+class IsDocument(MessageRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.document)
+
+
+class IsPhoto(MessageRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.photo)
+
+
+__all__ = (
     "IsBot",
     "IsChat",
     "IsChatId",
@@ -142,5 +142,5 @@ __all__ = (
     "IsSuperGroup",
     "IsUser",
     "IsUserId",
-    "IsVideoNote",
-)
+    "IsVideoNote",
+)

telegrinder/bot/rules/logic.py

@@ -0,0 +1,18 @@
+import typing
+
+from .abc import ABCRule, Context, UpdateCute, check_rule
+
+
+class If(ABCRule):
+    def __init__(self, condition: ABCRule) -> None:
+        self.conditions = [condition]
+
+    async def check(self, update: UpdateCute, ctx: Context) -> bool:
+        for condition in self.conditions[:-1]:
+            if not await check_rule(update.api, condition, update, ctx):
+                return True
+        return await check_rule(update.api, self.conditions[-1], update, ctx)
+
+    def then(self, condition: ABCRule) -> typing.Self:
+        self.conditions.append(condition)
+        return self