telegrinder 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

telegrinder/bot/rules/chat_join.py

@@ -1,48 +1,48 @@
-import abc
-import typing
-
-from telegrinder.bot.cute_types import ChatJoinRequestCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.adapter import EventAdapter
-from telegrinder.types.enums import UpdateType
-
-from .abc import ABCRule, CheckResult
-
-ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
-
-
-class ChatJoinRequestRule(ABCRule[ChatJoinRequest], requires=[]):
-    adapter: EventAdapter[ChatJoinRequest] = EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest)
-
-    @abc.abstractmethod
-    def check(self, event: ChatJoinRequest, context: Context) -> CheckResult:
-        pass
-
-
-class HasInviteLink(ChatJoinRequestRule):
-    def check(self, event: ChatJoinRequest) -> bool:
-        return bool(event.invite_link)
-
-
-class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
-    def __init__(self, name: str, /) -> None:
-        self.name = name
-
-    def check(self, event: ChatJoinRequest) -> bool:
-        return event.invite_link.unwrap().name.unwrap_or_none() == self.name
-
-
-class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
-    def __init__(self, creator_id: int, /) -> None:
-        self.creator_id = creator_id
-
-    def check(self, event: ChatJoinRequest) -> bool:
-        return event.invite_link.unwrap().creator.id == self.creator_id
-
-
-__all__ = (
-    "ChatJoinRequestRule",
-    "HasInviteLink",
-    "InviteLinkByCreator",
-    "InviteLinkName",
-)
+import abc
+import typing
+
+from telegrinder.bot.cute_types import ChatJoinRequestCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.adapter import EventAdapter
+from telegrinder.types.enums import UpdateType
+
+from .abc import ABCRule, CheckResult
+
+ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
+
+
+class ChatJoinRequestRule(ABCRule[ChatJoinRequest], requires=[]):
+    adapter: EventAdapter[ChatJoinRequest] = EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest)
+
+    @abc.abstractmethod
+    def check(self, event: ChatJoinRequest, context: Context) -> CheckResult:
+        pass
+
+
+class HasInviteLink(ChatJoinRequestRule):
+    def check(self, event: ChatJoinRequest) -> bool:
+        return bool(event.invite_link)
+
+
+class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
+    def __init__(self, name: str, /) -> None:
+        self.name = name
+
+    def check(self, event: ChatJoinRequest) -> bool:
+        return event.invite_link.unwrap().name.unwrap_or_none() == self.name
+
+
+class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
+    def __init__(self, creator_id: int, /) -> None:
+        self.creator_id = creator_id
+
+    def check(self, event: ChatJoinRequest) -> bool:
+        return event.invite_link.unwrap().creator.id == self.creator_id
+
+
+__all__ = (
+    "ChatJoinRequestRule",
+    "HasInviteLink",
+    "InviteLinkByCreator",
+    "InviteLinkName",
+)

telegrinder/bot/rules/command.py

@@ -1,126 +1,126 @@
-import dataclasses
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.command import CommandInfo, single_split
-from telegrinder.node.me import Me
-from telegrinder.node.source import Source
-from telegrinder.types.enums import ChatType
-
-from .abc import ABCRule
-
-Validator: typing.TypeAlias = typing.Callable[[str], 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:
-        for validator in self.validators:
-            data = validator(data)  # type: ignore
-            if data is None:
-                return None
-        return data
-
-
-class Command(ABCRule):
-    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,
-    ) -> None:
-        self.names = [names] if isinstance(names, str) else names
-        self.arguments = arguments
-        self.prefixes = prefixes
-        self.separator = separator
-        self.lazy = lazy
-        self.validate_mention = validate_mention
-
-        # 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 | 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, src: Source, ctx: Context) -> bool:
-        name = self.remove_prefix(command.name)
-        if name is None:
-            return False
-
-        if name not in self.names:
-            return False
-
-        if not command.mention and self.mention_needed_in_chat and src.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.update(result)
-        return True
-
-
-__all__ = ("Argument", "Command", "single_split")
+import dataclasses
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.command import CommandInfo, single_split
+from telegrinder.node.me import Me
+from telegrinder.node.source import Source
+from telegrinder.types.enums import ChatType
+
+from .abc import ABCRule
+
+Validator: typing.TypeAlias = typing.Callable[[str], 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:
+        for validator in self.validators:
+            data = validator(data)  # type: ignore
+            if data is None:
+                return None
+        return data
+
+
+class Command(ABCRule):
+    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,
+    ) -> None:
+        self.names = [names] if isinstance(names, str) else names
+        self.arguments = arguments
+        self.prefixes = prefixes
+        self.separator = separator
+        self.lazy = lazy
+        self.validate_mention = validate_mention
+
+        # 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 | 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, src: Source, ctx: Context) -> bool:
+        name = self.remove_prefix(command.name)
+        if name is None:
+            return False
+
+        if name not in self.names:
+            return False
+
+        if not command.mention and self.mention_needed_in_chat and src.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.update(result)
+        return True
+
+
+__all__ = ("Argument", "Command", "single_split")

telegrinder/bot/rules/enum_text.py

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

telegrinder/bot/rules/func.py

@@ -1,26 +1,26 @@
-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.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",)

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/inline.py

@@ -1,60 +1,60 @@
-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, query: InlineQuery, ctx: Context) -> 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",
-)
+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, query: InlineQuery, ctx: Context) -> 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",
+)