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

telegrinder/bot/rules/integer.py

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

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

@@ -1,43 +1,43 @@
-import typing
-
-import vbml
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.text import Text
-from telegrinder.tools.global_context.telegrinder_ctx import TelegrinderContext
-
-from .abc import ABCRule
-
-PatternLike: typing.TypeAlias = str | vbml.Pattern
-global_ctx: typing.Final[TelegrinderContext] = TelegrinderContext()
-
-
-def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
-    for pattern in patterns:
-        match global_ctx.vbml_patcher.check(pattern, s):
-            case None | False:
-                continue
-            case {**response}:
-                ctx |= response
-        return True
-    return False
-
-
-class Markup(ABCRule):
-    """Markup Language. See the [vbml documentation](https://github.com/tesseradecade/vbml/blob/master/docs/index.md)."""
-
-    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
-        if not isinstance(patterns, list):
-            patterns = [patterns]
-        self.patterns = [
-            vbml.Pattern(pattern, flags=global_ctx.vbml_pattern_flags)
-            if isinstance(pattern, str)
-            else pattern
-            for pattern in patterns
-        ]
-
-    def check(self, text: Text, ctx: Context) -> bool:
-        return check_string(self.patterns, text, ctx)
-
-
-__all__ = ("Markup", "check_string")
+import typing
+
+import vbml
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.text import Text
+from telegrinder.tools.global_context.telegrinder_ctx import TelegrinderContext
+
+from .abc import ABCRule
+
+PatternLike: typing.TypeAlias = str | vbml.Pattern
+global_ctx: typing.Final[TelegrinderContext] = TelegrinderContext()
+
+
+def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
+    for pattern in patterns:
+        match global_ctx.vbml_patcher.check(pattern, s):
+            case None | False:
+                continue
+            case {**response}:
+                ctx |= response
+        return True
+    return False
+
+
+class Markup(ABCRule):
+    """Markup Language. See the [vbml documentation](https://github.com/tesseradecade/vbml/blob/master/docs/index.md)."""
+
+    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
+        if not isinstance(patterns, list):
+            patterns = [patterns]
+        self.patterns = [
+            vbml.Pattern(pattern, flags=global_ctx.vbml_pattern_flags)
+            if isinstance(pattern, str)
+            else pattern
+            for pattern in patterns
+        ]
+
+    def check(self, text: Text, ctx: Context) -> bool:
+        return check_string(self.patterns, text, ctx)
+
+
+__all__ = ("Markup", "check_string")

telegrinder/bot/rules/mention.py

@@ -1,14 +1,14 @@
-from telegrinder.types.enums import MessageEntityType
-
-from .message import Message, MessageRule
-from .text import HasText
-
-
-class HasMention(MessageRule, requires=[HasText()]):
-    def check(self, message: Message) -> bool:
-        if not message.entities.unwrap_or_none():
-            return False
-        return any(entity.type == MessageEntityType.MENTION for entity in message.entities.unwrap())
-
-
-__all__ = ("HasMention",)
+from telegrinder.types.enums import MessageEntityType
+
+from .message import Message, MessageRule
+from .text import HasText
+
+
+class HasMention(MessageRule, requires=[HasText()]):
+    def check(self, message: Message) -> 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.py

@@ -1,17 +1,17 @@
-import abc
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.types.objects import Message as MessageEvent
-
-from .abc import ABCRule, CheckResult, Message
-from .adapter import EventAdapter
-
-
-class MessageRule(ABCRule[Message], abc.ABC):
-    adapter: EventAdapter[Message] = EventAdapter(MessageEvent, Message)
-
-    @abc.abstractmethod
-    def check(self, message: Message, ctx: Context) -> CheckResult: ...
-
-
-__all__ = ("MessageRule",)
+import abc
+import typing
+
+from telegrinder.types.objects import Message as MessageEvent
+
+from .abc import ABCRule, CheckResult, Message
+from .adapter import EventAdapter
+
+
+class MessageRule(ABCRule[Message], abc.ABC):
+    adapter: EventAdapter[Message] = EventAdapter(MessageEvent, Message)
+
+    @abc.abstractmethod
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+
+
+__all__ = ("MessageRule",)

telegrinder/bot/rules/message_entities.py

@@ -1,35 +1,35 @@
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.types.enums import MessageEntityType
-from telegrinder.types.objects import MessageEntity
-
-from .message import Message, MessageRule
-
-Entity: typing.TypeAlias = str | MessageEntityType
-
-
-class HasEntities(MessageRule):
-    def check(self, message: Message) -> bool:
-        return bool(message.entities)
-
-
-class MessageEntities(MessageRule, requires=[HasEntities()]):
-    def __init__(self, entities: Entity | list[Entity], /) -> None:
-        self.entities = [entities] if not isinstance(entities, list) else entities
-
-    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")
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types.enums import MessageEntityType
+from telegrinder.types.objects import MessageEntity
+
+from .message import Message, MessageRule
+
+Entity: typing.TypeAlias = str | MessageEntityType
+
+
+class HasEntities(MessageRule):
+    def check(self, message: Message) -> bool:
+        return bool(message.entities)
+
+
+class MessageEntities(MessageRule, requires=[HasEntities()]):
+    def __init__(self, entities: Entity | list[Entity], /) -> None:
+        self.entities = [entities] if not isinstance(entities, list) else entities
+
+    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/node.py

@@ -1,27 +1,27 @@
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.base import Node
-
-from .abc import ABCRule
-from .adapter.node import NodeAdapter
-
-
-class NodeRule(ABCRule[tuple[Node, ...]]):
-    def __init__(self, *nodes: type[Node] | tuple[str, type[Node]]) -> None:
-        bindings = [binding if isinstance(binding, tuple) else (None, binding) for binding in nodes]
-        self.nodes = [binding[1] for binding in bindings]
-        self.node_keys = [binding[0] for binding in bindings]
-
-    @property
-    def adapter(self) -> NodeAdapter:
-        return NodeAdapter(*self.nodes)  # type: ignore
-
-    def check(self, resolved_nodes: tuple[Node, ...], ctx: Context) -> typing.Literal[True]:
-        for i, node in enumerate(resolved_nodes):
-            if key := self.node_keys[i]:
-                ctx[key] = node
-        return True
-
-
-__all__ = ("NodeRule",)
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.base import Node
+
+from .abc import ABCRule
+from .adapter.node import NodeAdapter
+
+
+class NodeRule(ABCRule[tuple[Node, ...]]):
+    def __init__(self, *nodes: type[Node] | tuple[str, type[Node]]) -> None:
+        bindings = [binding if isinstance(binding, tuple) else (None, binding) for binding in nodes]
+        self.nodes = [binding[1] for binding in bindings]
+        self.node_keys = [binding[0] for binding in bindings]
+
+    @property
+    def adapter(self) -> NodeAdapter:
+        return NodeAdapter(*self.nodes)  # type: ignore
+
+    def check(self, resolved_nodes: tuple[Node, ...], ctx: Context) -> typing.Literal[True]:
+        for i, node in enumerate(resolved_nodes):
+            if key := self.node_keys[i]:
+                ctx[key] = node
+        return True
+
+
+__all__ = ("NodeRule",)

telegrinder/bot/rules/regex.py

@@ -1,37 +1,37 @@
-import re
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.text import Text
-
-from .abc import ABCRule
-
-PatternLike: typing.TypeAlias = str | typing.Pattern[str]
-
-
-class Regex(ABCRule):
-    def __init__(self, regexp: PatternLike | list[PatternLike]) -> None:
-        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
-                )
-
-    def check(self, text: Text, ctx: Context) -> bool:
-        for regexp in self.regexp:
-            response = re.match(regexp, text)
-            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",)
+import re
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.node.text import Text
+
+from .abc import ABCRule
+
+PatternLike: typing.TypeAlias = str | typing.Pattern[str]
+
+
+class Regex(ABCRule):
+    def __init__(self, regexp: PatternLike | list[PatternLike]) -> None:
+        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
+                )
+
+    def check(self, text: Text, ctx: Context) -> bool:
+        for regexp in self.regexp:
+            response = re.match(regexp, text)
+            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",)