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

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

telegrinder/bot/scenario/__init__.py

@@ -1,3 +1,5 @@
 from .abc import ABCScenario
 from .checkbox import Checkbox
 from .choice import SingleChoice
+
+__all__ = ("ABCScenario", "Checkbox", "SingleChoice")

telegrinder/bot/scenario/abc.py

@@ -1,12 +1,19 @@
-from abc import ABC, abstractmethod
 import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.bot.cute_types.base import BaseCute
 
 if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch import Dispatch
-    from telegrinder.api import API
+    from telegrinder.api import ABCAPI
+    from telegrinder.bot.dispatch.view.abc import ABCStateView
 
+EventT = typing.TypeVar("EventT", bound=BaseCute)
 
-class ABCScenario(ABC):
+
+class ABCScenario(ABC, typing.Generic[EventT]):
     @abstractmethod
-    def wait(self, api: "API", dispatch: "Dispatch") -> typing.Any:
+    def wait(self, api: "ABCAPI", view: "ABCStateView[EventT]") -> typing.Any:
         pass
+
+
+__all__ = ("ABCScenario",)

telegrinder/bot/scenario/checkbox.py

@@ -1,22 +1,25 @@
-from .abc import ABCScenario
-from dataclasses import dataclass
-from telegrinder.tools import InlineKeyboard, InlineButton
-from telegrinder.types.objects import InlineKeyboardMarkup
-from telegrinder.bot.cute_types import CallbackQueryCute
-import typing
+import dataclasses
 import random
 import string
+import typing
+
+from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.dispatch.waiter_machine import WaiterMachine
+from telegrinder.tools import InlineButton, InlineKeyboard
+from telegrinder.tools.parse_mode import ParseMode
+from telegrinder.types.objects import InlineKeyboardMarkup
+
+from .abc import ABCScenario
 
 if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch import Dispatch
     from telegrinder.api import API
+    from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
-@dataclass
+@dataclasses.dataclass
 class Choice:
     name: str
     is_picked: bool
-
     default_text: str
     picked_text: str
     code: str
@@ -26,13 +29,14 @@ def random_code(length: int) -> str:
     return "".join(random.choices(string.ascii_letters + string.digits, k=length))
 
 
-class Checkbox(ABCScenario):
-    INVALID_CODE: str = "Invalid code"
-    CALLBACK_ANSWER: str = "Done"
-    PARSE_MODE: str = "MarkdownV2"
+class Checkbox(ABCScenario[CallbackQueryCute]):
+    INVALID_CODE: typing.ClassVar[str] = "Invalid code"
+    CALLBACK_ANSWER: typing.ClassVar[str] = "Done"
+    PARSE_MODE: typing.ClassVar[str] = ParseMode.MARKDOWNV2
 
     def __init__(
         self,
+        waiter_machine: WaiterMachine,
         chat_id: int,
         msg: str,
         ready_text: str = "Ready",
@@ -40,13 +44,14 @@ class Checkbox(ABCScenario):
     ):
         self.chat_id = chat_id
         self.msg = msg
-        self.choices: typing.List[Choice] = []
+        self.choices: list[Choice] = []
         self.ready = ready_text
         self.max_in_row = max_in_row
         self.random_code = random_code(16)
+        self.waiter_machine = waiter_machine
 
     def get_markup(self) -> InlineKeyboardMarkup:
-        kb = InlineKeyboard(resize_keyboard=True)
+        kb = InlineKeyboard()
         choices = self.choices.copy()
         while choices:
             while len(kb.keyboard[-1]) < self.max_in_row and choices:
@@ -60,20 +65,24 @@ class Checkbox(ABCScenario):
                     )
                 )
             kb.row()
+        
         kb.add(InlineButton(self.ready, callback_data=self.random_code + "/ready"))
         return kb.get_markup()
 
     def add_option(
-        self, name: str, default_text: str, picked_text: str, is_picked: bool = False
-    ) -> "Checkbox":
+        self,
+        name: str,
+        default_text: str,
+        picked_text: str,
+        is_picked: bool = False,
+    ) -> typing.Self:
         self.choices.append(
-            Choice(name, is_picked, default_text, picked_text, random_code(16))
+            Choice(name, is_picked, default_text, picked_text, random_code(16)),
         )
         return self
 
     async def handle(self, cb: CallbackQueryCute) -> bool:
-        code = cb.data.replace(self.random_code + "/", "", 1)
-
+        code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
         if code == "ready":
             return False
 
@@ -81,9 +90,7 @@ class Checkbox(ABCScenario):
             if choice.code == code:
                 # Toggle choice
                 self.choices[i].is_picked = not self.choices[i].is_picked
-                await cb.ctx_api.edit_message_text(
-                    cb.message.chat.id,
-                    cb.message.message_id,
+                await cb.edit_text(
                     text=self.msg,
                     parse_mode=self.PARSE_MODE,
                     reply_markup=self.get_markup(),
@@ -93,21 +100,32 @@ class Checkbox(ABCScenario):
         return True
 
     async def wait(
-        self, api: "API", dispatch: "Dispatch"
-    ) -> typing.Tuple[typing.Dict[str, bool], int]:
+        self,
+        api: "API",
+        view: "BaseStateView[CallbackQueryCute]",
+    ) -> tuple[dict[str, bool], int]:
         assert len(self.choices) > 1
         message = (
             await api.send_message(
-                self.chat_id, text=self.msg, parse_mode=self.PARSE_MODE, reply_markup=self.get_markup()
+                self.chat_id,
+                text=self.msg,
+                parse_mode=self.PARSE_MODE,
+                reply_markup=self.get_markup(),
             )
         ).unwrap()
+        
         while True:
             q: CallbackQueryCute
-            q, _ = await dispatch.callback_query.wait_for_answer(message.message_id)
+            q, _ = await self.waiter_machine.wait(view, (api, message.message_id))
             should_continue = await self.handle(q)
             await q.answer(self.CALLBACK_ANSWER)
             if not should_continue:
                 break
-        return {
-            choice.name: choice.is_picked for choice in self.choices
-        }, message.message_id
+        
+        return (
+            {choice.name: choice.is_picked for choice in self.choices},
+            message.message_id,
+        )
+
+
+__all__ = ("Checkbox", "Choice", "random_code")

telegrinder/bot/scenario/choice.py

@@ -1,16 +1,17 @@
-from .checkbox import Checkbox
-from telegrinder.bot.cute_types import CallbackQueryCute
 import typing
 
+from telegrinder.bot.cute_types import CallbackQueryCute
+
+from .checkbox import Checkbox
+
 if typing.TYPE_CHECKING:
     from telegrinder.api import API
-    from telegrinder.bot.dispatch import Dispatch
+    from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
 class SingleChoice(Checkbox):
     async def handle(self, cb: CallbackQueryCute) -> bool:
-        code = cb.data.replace(self.random_code + "/", "", 1)
-
+        code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
         if code == "ready":
             return False
 
@@ -21,8 +22,8 @@ class SingleChoice(Checkbox):
             if choice.code == code:
                 self.choices[i].is_picked = True
                 await cb.ctx_api.edit_message_text(
-                    cb.message.chat.id,
-                    cb.message.message_id,
+                    chat_id=cb.message.unwrap().v.chat.id,
+                    message_id=cb.message.unwrap().v.message_id,
                     text=self.msg,
                     parse_mode=self.PARSE_MODE,
                     reply_markup=self.get_markup(),
@@ -31,9 +32,14 @@ class SingleChoice(Checkbox):
         return True
 
     async def wait(
-        self, api: "API", dispatch: "Dispatch"
-    ) -> typing.Tuple[str, int]:
+        self,
+        api: "API",
+        cb_view: "BaseStateView[CallbackQueryCute]",
+    ) -> tuple[str, int]:
         if len([choice for choice in self.choices if choice.is_picked]) != 1:
             raise ValueError("Exactly one choice must be picked")
-        choices, m_id = await super().wait(api, dispatch)
+        choices, m_id = await super().wait(api, cb_view)
         return list(choices.keys())[list(choices.values()).index(True)], m_id
+
+
+__all__ = ("SingleChoice",)

telegrinder/client/__init__.py

@@ -1,2 +1,4 @@
 from .abc import ABCClient, ClientData
 from .aiohttp import AiohttpClient
+
+__all__ = ("ABCClient", "AiohttpClient", "ClientData")

telegrinder/client/abc.py

@@ -1,5 +1,5 @@
-from abc import ABC, abstractmethod
 import typing
+from abc import ABC, abstractmethod
 
 ClientData = typing.Any
 
@@ -11,41 +11,25 @@ class ABCClient(ABC):
 
     @abstractmethod
     async def request_text(
-        self,
-        url: str,
-        method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        self, url: str, method: str = "GET", data: dict | None = None, **kwargs
     ) -> str:
         pass
 
     @abstractmethod
     async def request_json(
-        self,
-        url: str,
-        method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        self, url: str, method: str = "GET", data: dict | None = None, **kwargs
     ) -> dict:
         pass
 
     @abstractmethod
     async def request_content(
-        self,
-        url: str,
-        method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        self, url: str, method: str = "GET", data: dict | None = None, **kwargs
     ) -> bytes:
         pass
 
     @abstractmethod
     async def request_bytes(
-        self,
-        url: str,
-        method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        self, url: str, method: str = "GET", data: dict | None = None, **kwargs
     ) -> bytes:
         pass
 
@@ -63,3 +47,6 @@ class ABCClient(ABC):
 
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         await self.close()
+
+
+__all__ = ("ABCClient", "ClientData")