telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/bot/rules/chat_member_updated.py

@@ -0,0 +1,145 @@
+import dataclasses
+import enum
+import typing
+
+from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.objects import (
+    ChatMemberAdministrator,
+    ChatMemberBanned,
+    ChatMemberLeft,
+    ChatMemberMember,
+    ChatMemberOwner,
+    ChatMemberRestricted,
+)
+
+type _MemberStatus = MemberStatusFlag | MemberStatusUpdating
+type ChatMember = typing.Union[
+    ChatMemberAdministrator,
+    ChatMemberBanned,
+    ChatMemberLeft,
+    ChatMemberMember,
+    ChatMemberOwner,
+    ChatMemberRestricted,
+]
+type ChatMemberUpdated = ChatMemberUpdatedCute
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class MemberStatusUpdating:
+    old: MemberStatusFlag
+    new: MemberStatusFlag
+
+    def __invert__(self) -> typing.Self:
+        return dataclasses.replace(self, old=self.new, new=self.old)
+
+
+class MemberStatusFlag(enum.IntFlag):
+    CREATOR = enum.auto()
+    ADMINISTRATOR = enum.auto()
+    MEMBER = enum.auto()
+    LEFT = enum.auto()
+    KICKED = enum.auto()
+    RESTRICTED = enum.auto()
+    RESTRICTED_NOT_MEMBER = enum.auto()
+
+    RESTRICTED_MEMBER = MEMBER | RESTRICTED
+
+    IS_MEMBER = CREATOR | ADMINISTRATOR | MEMBER | RESTRICTED
+    IS_NOT_MEMBER = LEFT | KICKED | RESTRICTED_NOT_MEMBER
+
+    IS_ADMIN = CREATOR | ADMINISTRATOR
+    IS_NOT_ADMIN = RESTRICTED_MEMBER | IS_NOT_MEMBER
+
+    def __rshift__(self, other: object, /) -> MemberStatusUpdating:
+        if not isinstance(other, type(self)):
+            return NotImplemented
+        return MemberStatusUpdating(old=self, new=other)
+
+    def __lshift__(self, other: object, /) -> MemberStatusUpdating:
+        if not isinstance(other, type(self)):
+            return NotImplemented
+        return MemberStatusUpdating(old=other, new=self)
+
+
+class MemberStatus:
+    CREATOR = MemberStatusFlag.CREATOR
+    ADMINISTRATOR = MemberStatusFlag.ADMINISTRATOR
+    MEMBER = MemberStatusFlag.MEMBER
+    LEFT = MemberStatusFlag.LEFT
+    KICKED = MemberStatusFlag.KICKED
+    RESTRICTED = MemberStatusFlag.RESTRICTED_MEMBER | MemberStatusFlag.RESTRICTED_NOT_MEMBER
+
+    RESTRICTED_MEMBER = MemberStatusFlag.RESTRICTED_MEMBER
+    RESTRICTED_NOT_MEMBER = MemberStatusFlag.RESTRICTED_NOT_MEMBER
+
+    IS_MEMBER = MemberStatusFlag.IS_MEMBER
+    IS_NOT_MEMBER = ~IS_MEMBER
+
+    IS_ADMIN = MemberStatusFlag.IS_ADMIN
+    IS_NOT_ADMIN = ~IS_ADMIN
+
+    JOIN = IS_NOT_MEMBER >> IS_MEMBER
+    LEAVE = ~JOIN
+    PROMOTED = (RESTRICTED_MEMBER | IS_NOT_MEMBER) >> ADMINISTRATOR
+
+
+class ChatMemberUpdatedRule(ABCRule):
+    def __init__(self, status: _MemberStatus, /) -> None:
+        self.status = status
+
+    def check_status(
+        self,
+        member: ChatMember,
+        status: MemberStatusFlag,
+        checking_status: MemberStatusFlag,
+    ) -> bool:
+        if (
+            MemberStatusFlag.RESTRICTED_MEMBER in checking_status
+            or MemberStatusFlag.RESTRICTED_NOT_MEMBER in checking_status
+        ) and status == MemberStatusFlag.RESTRICTED:
+            return (
+                True
+                if MemberStatus.RESTRICTED in checking_status
+                else (getattr(member, "is_member", None) is (MemberStatusFlag.RESTRICTED_MEMBER in checking_status))
+            )
+
+        return status == checking_status or status in checking_status
+
+    def check(self, event: ChatMemberUpdated) -> bool:
+        checking_new_status, checking_old_status = (
+            (
+                self.status.new,
+                self.status.old,
+            )
+            if isinstance(self.status, MemberStatusUpdating)
+            else (self.status, None)
+        )
+        new_member, old_member = event.new_chat_member.v, event.old_chat_member.v
+        new_member_status, old_member_status = (
+            MEMBER_STATUS_MAP[new_member.status],
+            MEMBER_STATUS_MAP[old_member.status],
+        )
+        return (
+            all(
+                (
+                    self.check_status(old_member, old_member_status, checking_old_status),
+                    self.check_status(new_member, new_member_status, checking_new_status),
+                ),
+            )
+            if checking_old_status is not None
+            else self.check_status(new_member, new_member_status, checking_new_status)
+        )
+
+
+MEMBER_STATUS_MAP: typing.Final = {
+    "creator": MemberStatusFlag.CREATOR,
+    "administrator": MemberStatusFlag.ADMINISTRATOR,
+    "member": MemberStatusFlag.MEMBER,
+    "left": MemberStatusFlag.LEFT,
+    "kicked": MemberStatusFlag.KICKED,
+    "restricted": MemberStatusFlag.RESTRICTED,
+}
+
+
+__all__ = ("ChatMemberUpdatedRule", "MemberStatus")

telegrinder/bot/rules/command.py

@@ -0,0 +1,137 @@
+import dataclasses
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.nodes.command import CommandInfo, single_split
+from telegrinder.node.nodes.me import Me
+from telegrinder.node.nodes.source import ChatSource
+from telegrinder.types.enums import ChatType
+
+type Validator = typing.Callable[[str], typing.Any | None] | typing.Callable[[typing.Any], typing.Any | None]
+
+
+@dataclasses.dataclass(frozen=True, slots=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:
+        if not data:
+            return None
+
+        result = data
+        for validator in self.validators:
+            result = validator(result)
+            if result is None:
+                return None
+
+        return result
+
+
+class Command(ABCRule):
+    names: typing.Iterable[str]
+
+    def __init__(
+        self,
+        names: str | typing.Iterable[str],
+        *arguments: Argument,
+        prefixes: tuple[str, ...] = ("/",),
+        separator: str = " ",
+        lazy: bool = False,
+        validate_mention: bool = True,
+        mention_needed_in_chat: bool = False,
+        ignore_case: bool = False,
+    ) -> None:
+        names = [names] if isinstance(names, str) else names
+        self.names = [n.lower() for n in names] if ignore_case else names
+        self.arguments = arguments
+        self.prefixes = prefixes
+        self.separator = separator
+        self.lazy = lazy
+        self.validate_mention = validate_mention
+        self.ignore_case = ignore_case
+
+        # if true then we'll check for mention when message is from a group
+        self.mention_needed_in_chat = mention_needed_in_chat
+
+    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[str, typing.Any] | 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[str, typing.Any] | 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
+
+    def check(self, command: CommandInfo, me: Me, chat: ChatSource, ctx: Context) -> bool:
+        name = self.remove_prefix(command.name)
+        if name is None:
+            return False
+
+        target_name = name.lower() if self.ignore_case else name
+
+        if target_name not in self.names:
+            return False
+
+        if not command.mention and self.mention_needed_in_chat and chat.type is not ChatType.PRIVATE:
+            return False
+
+        if command.mention and self.validate_mention:  # noqa
+            if command.mention.unwrap().lower() != me.username.unwrap().lower():
+                return False
+
+        if not self.arguments:
+            return not command.arguments
+
+        result = self.parse_arguments(list(self.arguments), command.arguments)
+        if result is None:
+            return False
+
+        ctx |= result
+        return True
+
+
+__all__ = ("Argument", "Command", "single_split")

telegrinder/bot/rules/enum_text.py

@@ -0,0 +1,29 @@
+import enum
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.nodes.text import Text
+
+
+class EnumTextRule[T: enum.Enum](ABCRule):
+    def __init__(self, enum_t: type[T], *, lower_case: bool = True) -> None:
+        self.lower_case = lower_case
+        self.enum_t = enum_t
+        self.enumerations_map = {
+            (enumeration.value.lower() if lower_case else enumeration.value): enumeration for enumeration in self.enum_t
+        }
+
+    def find(self, s: str) -> T | None:
+        s = s.lower() if self.lower_case else s
+        return self.enumerations_map.get(s)
+
+    def check(self, text: Text, ctx: Context) -> bool:
+        match self.find(text):
+            case enum.Enum() as enumeration:
+                ctx.enum_text = enumeration
+                return True
+            case _:
+                return False
+
+
+__all__ = ("EnumTextRule",)

telegrinder/bot/rules/func.py

@@ -0,0 +1,21 @@
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.tools.aio import maybe_awaitable
+from telegrinder.types.objects import Update
+
+
+class FuncRule(ABCRule):
+    def __init__(
+        self,
+        func: typing.Callable[[Update, Context], typing.Awaitable[bool] | bool],
+        /,
+    ) -> None:
+        self.func = func
+
+    async def check(self, update: Update, ctx: Context) -> bool:
+        return await maybe_awaitable(self.func(update, ctx))
+
+
+__all__ = ("FuncRule",)

telegrinder/bot/rules/fuzzy.py

@@ -0,0 +1,21 @@
+import difflib
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.nodes.text import Text
+
+
+class FuzzyText(ABCRule):
+    def __init__(self, texts: str | list[str], /, *, min_ratio: float = 0.7) -> None:
+        self.texts = (texts,) if isinstance(texts, str) else tuple(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/inline.py

@@ -0,0 +1,45 @@
+from telegrinder.bot.cute_types.inline_query import InlineQueryCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.markup import Markup, PatternLike, check_string
+from telegrinder.types.enums import ChatType
+
+type InlineQuery = InlineQueryCute
+
+
+class HasLocation(ABCRule):
+    def check(self, query: InlineQuery) -> bool:
+        return bool(query.location)
+
+
+class InlineQueryChatType(ABCRule):
+    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(ABCRule):
+    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(ABCRule):
+    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",
+    "InlineQueryText",
+)

telegrinder/bot/rules/integer.py

@@ -0,0 +1,19 @@
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.node import NodeRule
+from telegrinder.node.nodes.text import TextInteger
+
+
+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")

telegrinder/bot/rules/is_from.py

@@ -0,0 +1,213 @@
+import typing
+
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.rules.abc import ABCRule, Always
+from telegrinder.node.nodes.source import ChatSource, UserSource
+from telegrinder.types.enums import ChatType, DiceEmoji
+
+type Message = MessageCute
+type ForwardType = typing.Literal["user", "hidden_user", "chat", "channel"]
+
+TELEGRAM_ID: typing.Final = 777000
+
+
+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 IsTelegram(Always, requires=[IsUserId(TELEGRAM_ID)]):
+    pass
+
+
+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(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.dice)
+
+
+class IsDiceEmoji(ABCRule, 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(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.forward_origin)
+
+
+class IsForwardType(ABCRule, requires=[IsForward()]):
+    def __init__(self, fwd_type: ForwardType, /) -> None:
+        self.fwd_type = fwd_type
+
+    def check(self, message: Message) -> bool:
+        return message.forward_origin.unwrap().v.type == self.fwd_type
+
+
+class IsReply(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.reply_to_message)
+
+
+class IsSticker(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.sticker)
+
+
+class IsVideoNote(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.video_note)
+
+
+class IsDocument(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.document)
+
+
+class IsPhoto(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.photo)
+
+
+class IsContact(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.contact)
+
+
+class IsLocation(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.location)
+
+
+class IsChecklist(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.checklist)
+
+
+class IsGame(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.game)
+
+
+class IsPoll(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.poll)
+
+
+class IsVenue(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.venue)
+
+
+class IsNewChatMembers(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.new_chat_members)
+
+
+class IsLeftChatMember(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.left_chat_member)
+
+
+class IsNewChatTitle(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.new_chat_title)
+
+
+class IsNewChatPhoto(ABCRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.new_chat_photo)
+
+
+__all__ = (
+    "IsBot",
+    "IsChat",
+    "IsChatId",
+    "IsChecklist",
+    "IsDice",
+    "IsDiceEmoji",
+    "IsDocument",
+    "IsForum",
+    "IsForward",
+    "IsForwardType",
+    "IsGame",
+    "IsGroup",
+    "IsLanguageCode",
+    "IsLeftChatMember",
+    "IsNewChatMembers",
+    "IsNewChatPhoto",
+    "IsNewChatTitle",
+    "IsPhoto",
+    "IsPoll",
+    "IsPremium",
+    "IsPrivate",
+    "IsReply",
+    "IsSticker",
+    "IsSuperGroup",
+    "IsTelegram",
+    "IsUser",
+    "IsUserId",
+    "IsVenue",
+    "IsVideoNote",
+)

telegrinder/bot/rules/logic.py

@@ -0,0 +1,22 @@
+import typing
+
+from telegrinder.bot.rules.abc import ABCRule, Context, check_rule
+
+
+class If(ABCRule):
+    def __init__(self, condition: ABCRule) -> None:
+        self.conditions = [condition]
+
+    async def check(self, context: Context) -> bool:
+        for condition in self.conditions[:-1]:
+            if not await check_rule(condition, context):
+                return True
+
+        return await check_rule(self.conditions[-1], context)
+
+    def then(self, condition: ABCRule, /) -> typing.Self:
+        self.conditions.append(condition)
+        return self
+
+
+__all__ = ("If",)