telegrinder 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

telegrinder/bot/rules/is_from.py

@@ -1,10 +1,11 @@
 import typing
 
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.node.source import ChatSource, UserSource
 from telegrinder.types.enums import ChatType, DiceEmoji
 
-from .abc import ABCRule, Message
-from .message import MessageRule
+Message: typing.TypeAlias = MessageCute
 
 
 class IsBot(ABCRule):
@@ -71,12 +72,12 @@ class IsChat(ABCRule):
         return chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
 
 
-class IsDice(MessageRule):
+class IsDice(ABCRule):
     def check(self, message: Message) -> bool:
         return bool(message.dice)
 
 
-class IsDiceEmoji(MessageRule, requires=[IsDice()]):
+class IsDiceEmoji(ABCRule, requires=[IsDice()]):
     def __init__(self, dice_emoji: DiceEmoji, /) -> None:
         self.dice_emoji = dice_emoji
 
@@ -84,12 +85,12 @@ class IsDiceEmoji(MessageRule, requires=[IsDice()]):
         return message.dice.unwrap().emoji == self.dice_emoji
 
 
-class IsForward(MessageRule):
+class IsForward(ABCRule):
     def check(self, message: Message) -> bool:
         return bool(message.forward_origin)
 
 
-class IsForwardType(MessageRule, requires=[IsForward()]):
+class IsForwardType(ABCRule, requires=[IsForward()]):
     def __init__(self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /) -> None:
         self.fwd_type = fwd_type
 
@@ -97,27 +98,27 @@ class IsForwardType(MessageRule, requires=[IsForward()]):
         return message.forward_origin.unwrap().v.type == self.fwd_type
 
 
-class IsReply(MessageRule):
+class IsReply(ABCRule):
     def check(self, message: Message) -> bool:
         return bool(message.reply_to_message)
 
 
-class IsSticker(MessageRule):
+class IsSticker(ABCRule):
     def check(self, message: Message) -> bool:
         return bool(message.sticker)
 
 
-class IsVideoNote(MessageRule):
+class IsVideoNote(ABCRule):
     def check(self, message: Message) -> bool:
         return bool(message.video_note)
 
 
-class IsDocument(MessageRule):
+class IsDocument(ABCRule):
     def check(self, message: Message) -> bool:
         return bool(message.document)
 
 
-class IsPhoto(MessageRule):
+class IsPhoto(ABCRule):
     def check(self, message: Message) -> bool:
         return bool(message.photo)
 

telegrinder/bot/rules/logic.py

@@ -1,18 +1,24 @@
 import typing
 
-from .abc import ABCRule, Context, UpdateCute, check_rule
+from telegrinder.api.api import API
+from telegrinder.bot.rules.abc import ABCRule, Context, check_rule
+from telegrinder.types.objects import Update
 
 
 class If(ABCRule):
     def __init__(self, condition: ABCRule) -> None:
         self.conditions = [condition]
 
-    async def check(self, update: UpdateCute, ctx: Context) -> bool:
+    async def check(self, update: Update, api: API, ctx: Context) -> bool:
         for condition in self.conditions[:-1]:
-            if not await check_rule(update.api, condition, update, ctx):
+            if not await check_rule(api, condition, update, ctx):
                 return True
-        return await check_rule(update.api, self.conditions[-1], update, ctx)
 
-    def then(self, condition: ABCRule) -> typing.Self:
+        return await check_rule(api, self.conditions[-1], update, ctx)
+
+    def then(self, condition: ABCRule, /) -> typing.Self:
         self.conditions.append(condition)
         return self
+
+
+__all__ = ("If",)

telegrinder/bot/rules/markup.py

@@ -1,41 +1,49 @@
+import re
 import typing
 
 import vbml
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.either import Either
+from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.node.text import Caption, Text
-from telegrinder.tools.global_context.telegrinder_ctx import TelegrinderContext
-
-from .abc import ABCRule
+from telegrinder.tools.global_context.builtin_context import TelegrinderContext
 
 type PatternLike = str | vbml.Pattern
-global_ctx: typing.Final[TelegrinderContext] = TelegrinderContext()
+
+TELEGRINDER_CONTEXT: 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
+        match TELEGRINDER_CONTEXT.vbml_patcher.check(pattern, s):
             case {**response}:
                 ctx |= response
+            case None | False:
+                continue
+
         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]
+    def __init__(
+        self,
+        patterns: PatternLike | list[PatternLike],
+        /,
+        *,
+        flags: re.RegexFlag | None = None,
+    ) -> None:
         self.patterns = [
-            vbml.Pattern(pattern, flags=global_ctx.vbml_pattern_flags) if isinstance(pattern, str) else pattern
-            for pattern in patterns
+            vbml.Pattern(text=pattern, flags=flags or TELEGRINDER_CONTEXT.vbml_pattern_flags)
+            if isinstance(pattern, str)
+            else pattern
+            for pattern in ([patterns] if not isinstance(patterns, list) else patterns)
         ]
 
-    def check(self, text: Either[Text, Caption], ctx: Context) -> bool:
+    def check(self, text: Text | Caption, ctx: Context) -> bool:
         return check_string(self.patterns, text, ctx)
 
 

telegrinder/bot/rules/mention.py

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

telegrinder/bot/rules/message_entities.py

@@ -1,18 +1,22 @@
+import typing
+
+from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.types.enums import MessageEntityType
 from telegrinder.types.objects import MessageEntity
 
-from .message import Message, MessageRule
-
 type Entity = str | MessageEntityType
 
+Message: typing.TypeAlias = MessageCute
+
 
-class HasEntities(MessageRule):
+class HasEntities(ABCRule):
     def check(self, message: Message) -> bool:
         return bool(message.entities)
 
 
-class MessageEntities(MessageRule, requires=[HasEntities()]):
+class MessageEntities(ABCRule, requires=[HasEntities()]):
     def __init__(self, entities: Entity | list[Entity], /) -> None:
         self.entities = [entities] if not isinstance(entities, list) else entities
 

telegrinder/bot/rules/node.py

@@ -1,10 +1,11 @@
-import typing
+from fntypes.result import Ok
 
+from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.base import IsNode, NodeType, is_node
-from telegrinder.tools.adapter.node import NodeAdapter
-
-from .abc import ABCRule
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.base import IsNode, is_node
+from telegrinder.node.composer import compose_nodes
+from telegrinder.types.objects import Update
 
 
 class NodeRule(ABCRule):
@@ -19,14 +20,24 @@ class NodeRule(ABCRule):
             self.nodes.append(node_t)
             self.node_keys.append(node_key)
 
-    @property
-    def adapter(self) -> NodeAdapter:
-        return NodeAdapter(*self.nodes)
+    async def check(self, update: Update, api: API, context: Context) -> bool:
+        result = await compose_nodes(
+            nodes={f"node_{i}": node for i, node in enumerate(self.nodes)},
+            ctx=context,
+            data={Update: update, API: api},
+        )
+
+        match result:
+            case Ok(collection):
+                resolved_nodes = collection.sessions
+            case _:
+                return False
+
+        for i, (node_key, node_value) in enumerate(resolved_nodes.items()):
+            if (key := self.node_keys[i]) and node_key == key:
+                context[key] = node_value
 
-    def check(self, resolved_nodes: tuple[NodeType, ...], ctx: Context) -> typing.Literal[True]:
-        for i, node in enumerate(resolved_nodes):
-            if key := self.node_keys[i]:
-                ctx[key] = node
+        await collection.close_all()
         return True
 
 

telegrinder/bot/rules/payload.py

@@ -7,11 +7,11 @@ import msgspec
 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.msgspec_json import loads
+from telegrinder.msgspec_utils.json import loads
 from telegrinder.node.base import Node
 from telegrinder.node.payload import Payload, PayloadData
-from telegrinder.tools.callback_data_serilization.abc import ABCDataSerializer, ModelType
-from telegrinder.tools.callback_data_serilization.json_ser import JSONSerializer
+from telegrinder.tools.callback_data_serialization.abc import ABCDataSerializer, ModelType
+from telegrinder.tools.callback_data_serialization.json_ser import JSONSerializer
 
 
 class PayloadRule[Data](ABCRule):
@@ -35,10 +35,11 @@ class PayloadRule[Data](ABCRule):
         return True
 
 
-class PayloadModelRule[Model: ModelType](PayloadRule[Model]):
+class PayloadModelRule[Model: ModelType](PayloadRule):
     def __init__(
         self,
         model_t: type[Model],
+        /,
         *,
         serializer: type[ABCDataSerializer[Model]] | None = None,
         alias: str | None = None,

telegrinder/bot/rules/payment_invoice.py

@@ -1,29 +1,14 @@
-import abc
-import typing
-
 from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
-from telegrinder.bot.rules.abc import ABCRule, CheckResult
-from telegrinder.tools.adapter.event import EventAdapter
-from telegrinder.types.enums import Currency, UpdateType
-
-PreCheckoutQuery: typing.TypeAlias = PreCheckoutQueryCute
-
-
-class PaymentInvoiceRule(
-    ABCRule[PreCheckoutQuery],
-    abc.ABC,
-    adapter=EventAdapter(UpdateType.PRE_CHECKOUT_QUERY, PreCheckoutQuery),
-):
-    @abc.abstractmethod
-    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.enums import Currency
 
 
-class PaymentInvoiceCurrency(PaymentInvoiceRule):
-    def __init__(self, currency: str | Currency, /) -> None:
+class PaymentInvoiceCurrency(ABCRule):
+    def __init__(self, currency: Currency, /) -> None:
         self.currency = currency
 
-    def check(self, query: PreCheckoutQuery) -> bool:
+    def check(self, query: PreCheckoutQueryCute) -> bool:
         return self.currency == query.currency
 
 
-__all__ = ("PaymentInvoiceCurrency", "PaymentInvoiceRule")
+__all__ = ("PaymentInvoiceCurrency",)

telegrinder/bot/rules/regex.py

@@ -2,11 +2,9 @@ import re
 import typing
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.either import Either
+from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.node.text import Caption, Text
 
-from .abc import ABCRule
-
 type PatternLike = str | typing.Pattern[str]
 
 
@@ -21,7 +19,7 @@ class Regex(ABCRule):
             case _:
                 self.regexp.extend(re.compile(regexp) if isinstance(regexp, str) else regexp for regexp in regexp)
 
-    def check(self, text: Either[Text, Caption], ctx: Context) -> bool:
+    def check(self, text: Text | Caption, ctx: Context) -> bool:
         for regexp in self.regexp:
             response = re.match(regexp, text)
             if response is not None:

telegrinder/bot/rules/rule_enum.py

@@ -1,10 +1,11 @@
 import dataclasses
 import typing
 
+from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
-
-from .abc import ABCRule, Update, check_rule
-from .func import FuncRule
+from telegrinder.bot.rules.abc import ABCRule, check_rule
+from telegrinder.bot.rules.func import FuncRule
+from telegrinder.types.objects import Update
 
 
 @dataclasses.dataclass(slots=True)
@@ -42,11 +43,11 @@ class RuleEnum(ABCRule):
 
     @classmethod
     def save_state(cls, ctx: Context, enum: RuleEnumState) -> None:
-        ctx.update({cls.__class__.__name__ + "_state": enum})
+        ctx.update({cls.__name__ + "_state": enum})
 
     @classmethod
     def check_state(cls, ctx: Context) -> RuleEnumState | None:
-        return ctx.get(cls.__class__.__name__ + "_state")
+        return ctx.get(cls.__name__ + "_state")
 
     @classmethod
     def must_be_state(cls, ctx: Context, state: RuleEnumState) -> bool:
@@ -55,13 +56,13 @@ class RuleEnum(ABCRule):
             return False
         return real_state == state
 
-    async def check(self, event: Update, ctx: Context) -> bool:
+    async def check(self, event: Update, api: API, 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):
+            if await check_rule(api, enum.rule, event, ctx_copy):
                 ctx.update(ctx_copy)
                 self.save_state(ctx, enum)
                 return True

telegrinder/bot/rules/start.py

@@ -1,16 +1,15 @@
 import typing
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.is_from import IsPrivate
+from telegrinder.bot.rules.markup import Markup
+from telegrinder.bot.rules.message_entities import MessageEntities
 from telegrinder.types.enums import MessageEntityType
 
-from .is_from import IsPrivate
-from .markup import Markup
-from .message import MessageRule
-from .message_entities import MessageEntities
-
 
 class StartCommand(
-    MessageRule,
+    ABCRule,
     requires=[
         IsPrivate(),
         MessageEntities(MessageEntityType.BOT_COMMAND),

telegrinder/bot/rules/state.py

@@ -28,7 +28,7 @@ class State[Payload](ABCRule):
         if self.key != StateMeta.ANY and self.key != state.unwrap().key:
             return False
 
-        ctx["state"] = state.unwrap()
+        ctx.state = state.unwrap()
         return True
 
 

telegrinder/bot/rules/text.py

@@ -1,10 +1,6 @@
-import typing
-
 from telegrinder import node
-from telegrinder.tools.i18n.abc import ABCTranslator
-
-from .abc import ABCRule, with_caching_translations
-from .node import NodeRule
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.node import NodeRule
 
 
 class HasText(NodeRule):
@@ -21,18 +17,11 @@ class Text(ABCRule):
     def __init__(self, texts: str | list[str], /, *, ignore_case: bool = False) -> None:
         if not isinstance(texts, list):
             texts = [texts]
-        self.texts = texts if not ignore_case else list(map(str.lower, texts))
+        self.texts = set(texts) if not ignore_case else set(map(str.lower, texts))
         self.ignore_case = ignore_case
 
-    def check(self, text: node.either.Either[node.text.Text, node.text.Caption]) -> bool:
+    def check(self, text: node.text.Text | node.text.Caption) -> bool:
         return (text if not self.ignore_case else text.lower()) in self.texts
 
-    @with_caching_translations
-    async def translate(self, translator: ABCTranslator) -> typing.Self:
-        return self.__class__(
-            [translator.get(text) for text in self.texts],
-            ignore_case=self.ignore_case,
-        )
-
 
 __all__ = ("HasCaption", "HasText", "Text")

telegrinder/bot/rules/update.py

@@ -1,14 +1,13 @@
-from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.types.enums import UpdateType
-
-from .abc import ABCRule
+from telegrinder.types.objects import Update
 
 
 class IsUpdateType(ABCRule):
     def __init__(self, update_type: UpdateType, /) -> None:
         self.update_type = update_type
 
-    def check(self, event: UpdateCute) -> bool:
+    def check(self, event: Update) -> bool:
         return event.update_type == self.update_type
 
 

telegrinder/bot/scenario/abc.py

@@ -1,16 +1,17 @@
+from __future__ import annotations
+
 import typing
 from abc import ABC, abstractmethod
 
-from telegrinder.bot.cute_types.base import BaseCute
-
 if typing.TYPE_CHECKING:
-    from telegrinder.api import API
-    from telegrinder.bot.dispatch.view.abc import ABCStateView
+    from telegrinder.api.api import API
+    from telegrinder.bot.cute_types.base import BaseCute
+    from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
 
 
 class ABCScenario[Event: BaseCute](ABC):
     @abstractmethod
-    def wait(self, api: "API", view: "ABCStateView[Event]") -> typing.Any:
+    def wait(self, hasher: Hasher, api: API) -> typing.Any:
         pass
 
 

telegrinder/bot/scenario/checkbox.py

@@ -29,7 +29,7 @@ class Choice[Key: typing.Hashable]:
     code: str
 
 
-class _Checkbox(ABCScenario[CallbackQueryCute]):
+class _Checkbox[T](ABCScenario[CallbackQueryCute]):
     INVALID_CODE = "Invalid code"
     CALLBACK_ANSWER = "Done"
     PARSE_MODE = ParseMode.HTML

telegrinder/bot/scenario/choice.py

@@ -1,48 +1,39 @@
 import typing
 
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
 from telegrinder.bot.scenario.checkbox import Checkbox, ChoiceAction
 
-if typing.TYPE_CHECKING:
-    from telegrinder.api.api import API
-
-    class Choice[Key: typing.Hashable](Checkbox[Key]):
-        async def wait(
-            self,
-            hasher: Hasher[CallbackQueryCute, int],
-            api: API,
-        ) -> tuple[Key, int]: ...
-
-else:
-
-    class Choice(Checkbox):
-        async def handle(self, cb):
-            code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
-            if code == ChoiceAction.READY:
-                return False
-
-            for choice in self.choices:
-                choice.is_picked = False
-
-            for i, choice in enumerate(self.choices):
-                if choice.code == code:
-                    self.choices[i].is_picked = True
-                    await cb.ctx_api.edit_message_text(
-                        text=self.message,
-                        chat_id=cb.message.unwrap().v.chat.id,
-                        message_id=cb.message.unwrap().v.message_id,
-                        parse_mode=self.PARSE_MODE,
-                        reply_markup=self.get_markup(),
-                    )
-
-            return True
-
-        async def wait(self, hasher, api):
-            if len(tuple(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(hasher, api)
-            return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
+
+class Choice[Key: typing.Hashable](Checkbox[Key]):
+    async def handle(self, cb: CallbackQueryCute) -> bool:
+        code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
+        if code == ChoiceAction.READY:
+            return False
+
+        for choice in self.choices:
+            choice.is_picked = False
+
+        for i, choice in enumerate(self.choices):
+            if choice.code == code:
+                self.choices[i].is_picked = True
+                await cb.ctx_api.edit_message_text(
+                    text=self.message,
+                    chat_id=cb.message.unwrap().v.chat.id,
+                    message_id=cb.message.unwrap().v.message_id,
+                    parse_mode=self.PARSE_MODE,
+                    reply_markup=self.get_markup(),
+                )
+
+        return True
+
+    async def wait(self, hasher: Hasher[CallbackQueryCute, int], api: API) -> tuple[Key, int]:
+        if len(tuple(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(hasher, api)
+        return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
 
 
 __all__ = ("Choice",)

telegrinder/client/__init__.py

@@ -1,12 +1,10 @@
-from .abc import ABCClient
-from .aiohttp import AiohttpClient
-from .form_data import MultipartFormProto, encode_form_data
-from .sonic import AiosonicClient
+from telegrinder.client.abc import ABCClient
+from telegrinder.client.aiohttp import AiohttpClient
+from telegrinder.client.form_data import MultipartFormProto, encode_form_data
 
 __all__ = (
     "ABCClient",
     "AiohttpClient",
-    "AiosonicClient",
     "MultipartFormProto",
     "encode_form_data",
 )