telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/bot/rules/markup.py

@@ -3,12 +3,13 @@ import typing
 import vbml
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.text import Text
+from telegrinder.node.either import Either
+from telegrinder.node.text import Caption, Text
 from telegrinder.tools.global_context.telegrinder_ctx import TelegrinderContext
 
 from .abc import ABCRule
 
-PatternLike: typing.TypeAlias = str | vbml.Pattern
+type PatternLike = str | vbml.Pattern
 global_ctx: typing.Final[TelegrinderContext] = TelegrinderContext()
 
 
@@ -30,13 +31,11 @@ class Markup(ABCRule):
         if not isinstance(patterns, list):
             patterns = [patterns]
         self.patterns = [
-            vbml.Pattern(pattern, flags=global_ctx.vbml_pattern_flags)
-            if isinstance(pattern, str)
-            else pattern
+            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:
+    def check(self, text: Either[Text, Caption], ctx: Context) -> bool:
         return check_string(self.patterns, text, ctx)
 
 

telegrinder/bot/rules/message.py

@@ -1,15 +1,13 @@
 import abc
 import typing
 
+from telegrinder.tools.adapter.event import EventAdapter
 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)
-
+class MessageRule(ABCRule[Message], abc.ABC, adapter=EventAdapter(MessageEvent, Message)):
     @abc.abstractmethod
     def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
 

telegrinder/bot/rules/message_entities.py

@@ -1,12 +1,10 @@
-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
+type Entity = str | MessageEntityType
 
 
 class HasEntities(MessageRule):

telegrinder/bot/rules/node.py

@@ -1,23 +1,29 @@
 import typing
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.base import Node
+from telegrinder.node.base import IsNode, NodeType, is_node
+from telegrinder.tools.adapter.node import NodeAdapter
 
 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]
+class NodeRule(ABCRule):
+    def __init__(self, *nodes: IsNode | tuple[str, IsNode]) -> None:
+        self.nodes: list[IsNode] = []
+        self.node_keys: list[str | None] = []
+
+        for binding in nodes:
+            node_key, node_t = binding if isinstance(binding, tuple) else (None, binding)
+            if not is_node(node_t):
+                continue
+            self.nodes.append(node_t)
+            self.node_keys.append(node_key)
 
     @property
     def adapter(self) -> NodeAdapter:
-        return NodeAdapter(*self.nodes)  # type: ignore
+        return NodeAdapter(*self.nodes)
 
-    def check(self, resolved_nodes: tuple[Node, ...], ctx: Context) -> typing.Literal[True]:
+    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

telegrinder/bot/rules/payload.py

@@ -0,0 +1,81 @@
+import typing
+from contextlib import suppress
+from functools import cached_property
+
+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.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
+
+
+class PayloadRule[Data](ABCRule):
+    def __init__(
+        self,
+        data_type: type[Data],
+        serializer: type[ABCDataSerializer[Data]],
+        *,
+        alias: str | None = None,
+    ) -> None:
+        self.data_type = data_type
+        self.serializer = serializer
+        self.alias = alias or "data"
+
+    @cached_property
+    def required_nodes(self) -> dict[str, type[Node]]:
+        return {"payload": PayloadData[self.data_type, self.serializer]}  # type: ignore
+
+    def check(self, payload: PayloadData[Data], context: Context) -> typing.Literal[True]:
+        context.set(self.alias, payload)
+        return True
+
+
+class PayloadModelRule[Model: ModelType](PayloadRule[Model]):
+    def __init__(
+        self,
+        model_t: type[Model],
+        *,
+        serializer: type[ABCDataSerializer[Model]] | None = None,
+        alias: str | None = None,
+    ) -> None:
+        super().__init__(model_t, serializer or JSONSerializer, alias=alias or "model")
+
+
+class PayloadEqRule(ABCRule):
+    def __init__(self, payloads: str | list[str], /) -> None:
+        self.payloads = [payloads] if isinstance(payloads, str) else payloads
+
+    def check(self, payload: Payload) -> bool:
+        return any(p == payload for p in self.payloads)
+
+
+class PayloadMarkupRule(ABCRule):
+    def __init__(self, pattern: PatternLike | list[PatternLike], /) -> None:
+        self.patterns = Markup(pattern).patterns
+
+    def check(self, payload: Payload, context: Context) -> bool:
+        return check_string(self.patterns, payload, context)
+
+
+class PayloadJsonEqRule(ABCRule):
+    def __init__(self, payload: dict[str, typing.Any], /) -> None:
+        self.payload = payload
+
+    def check(self, payload: Payload) -> bool:
+        with suppress(msgspec.DecodeError, msgspec.ValidationError):
+            return self.payload == loads(payload)
+        return False
+
+
+__all__ = (
+    "PayloadEqRule",
+    "PayloadJsonEqRule",
+    "PayloadMarkupRule",
+    "PayloadModelRule",
+    "PayloadRule",
+)

telegrinder/bot/rules/payment_invoice.py

@@ -0,0 +1,29 @@
+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: ...
+
+
+class PaymentInvoiceCurrency(PaymentInvoiceRule):
+    def __init__(self, currency: str | Currency, /) -> None:
+        self.currency = currency
+
+    def check(self, query: PreCheckoutQuery) -> bool:
+        return self.currency == query.currency
+
+
+__all__ = ("PaymentInvoiceCurrency", "PaymentInvoiceRule")

telegrinder/bot/rules/regex.py

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

telegrinder/bot/rules/state.py

@@ -9,8 +9,6 @@ from telegrinder.node.source import Source
 if typing.TYPE_CHECKING:
     from telegrinder.tools.state_storage.abc import ABCStateStorage
 
-Payload = typing.TypeVar("Payload")
-
 
 class StateMeta(enum.Enum):
     NO_STATE = enum.auto()
@@ -18,7 +16,7 @@ class StateMeta(enum.Enum):
 
 
 @dataclasses.dataclass(frozen=True, slots=True, repr=False)
-class State(ABCRule, typing.Generic[Payload]):
+class State[Payload](ABCRule):
     storage: "ABCStateStorage[Payload]"
     key: str | StateMeta | enum.Enum
 

telegrinder/bot/rules/text.py

@@ -9,25 +9,30 @@ from .node import NodeRule
 
 class HasText(NodeRule):
     def __init__(self) -> None:
-        super().__init__(node.text.Text)
+        super().__init__(node.as_node(node.text.Text))
+
+
+class HasCaption(NodeRule):
+    def __init__(self) -> None:
+        super().__init__(node.as_node(node.text.Caption))
 
 
 class Text(ABCRule):
-    def __init__(self, texts: str | list[str], *, ignore_case: bool = False) -> None:
+    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.ignore_case = ignore_case
 
-    def check(self, text: node.text.Text) -> bool:
+    def check(self, text: node.either.Either[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__(
-            texts=[translator.get(text) for text in self.texts],
+            [translator.get(text) for text in self.texts],
             ignore_case=self.ignore_case,
         )
 
 
-__all__ = ("HasText", "Text")
+__all__ = ("HasCaption", "HasText", "Text")

telegrinder/bot/scenario/abc.py

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

telegrinder/bot/scenario/checkbox.py

@@ -13,18 +13,15 @@ from telegrinder.types.objects import InlineKeyboardMarkup
 
 if typing.TYPE_CHECKING:
     from telegrinder.api.api import API
-    from telegrinder.bot.dispatch.view.base import BaseStateView
 
-Key = typing.TypeVar("Key", bound=typing.Hashable)
 
-
-class ChoiceCode(enum.StrEnum):
+class ChoiceAction(enum.StrEnum):
     READY = "ready"
     CANCEL = "cancel"
 
 
 @dataclasses.dataclass(slots=True)
-class Choice(typing.Generic[Key]):
+class Choice[Key: typing.Hashable]:
     key: Key
     is_picked: bool
     default_text: str
@@ -85,14 +82,14 @@ class _Checkbox(ABCScenario[CallbackQueryCute]):
                 )
             kb.row()
 
-        kb.add(InlineButton(self.ready, callback_data=self.random_code + "/" + ChoiceCode.READY))
+        kb.add(InlineButton(self.ready, callback_data=self.random_code + "/" + ChoiceAction.READY))
         if self.cancel_text is not None:
             kb.row()
-            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/" + ChoiceCode.CANCEL))
+            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/" + ChoiceAction.CANCEL))
 
         return kb.get_markup()
 
-    def add_option(
+    def add_option[Key: typing.Hashable](
         self,
         key: Key,
         default_text: str,
@@ -109,9 +106,9 @@ class _Checkbox(ABCScenario[CallbackQueryCute]):
         code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
 
         match code:
-            case ChoiceCode.READY:
+            case ChoiceAction.READY:
                 return False
-            case ChoiceCode.CANCEL:
+            case ChoiceAction.CANCEL:
                 self.choices = []
                 return False
 
@@ -132,7 +129,6 @@ class _Checkbox(ABCScenario[CallbackQueryCute]):
         self,
         hasher: Hasher[CallbackQueryCute, int],
         api: "API",
-        view: "BaseStateView[CallbackQueryCute]",
     ) -> tuple[dict[typing.Hashable, bool], int]:
         assert len(self.choices) > 0
         message = (
@@ -145,7 +141,10 @@ class _Checkbox(ABCScenario[CallbackQueryCute]):
         ).unwrap()
 
         while True:
-            q, _ = await self.waiter_machine.wait(hasher, message.message_id)
+            q, _ = await self.waiter_machine.wait(
+                hasher,
+                data=message.message_id,
+            )
             should_continue = await self.handle(q)
             await q.answer(self.CALLBACK_ANSWER)
             if not should_continue:
@@ -159,14 +158,13 @@ class _Checkbox(ABCScenario[CallbackQueryCute]):
 
 if typing.TYPE_CHECKING:
 
-    class Checkbox(_Checkbox, typing.Generic[Key]):
+    class Checkbox[Key: typing.Hashable](_Checkbox):
         choices: list[Choice[Key]]
 
         async def wait(
             self,
             hasher: Hasher[CallbackQueryCute, int],
             api: "API",
-            view: "BaseStateView[CallbackQueryCute]",
         ) -> tuple[dict[Key, bool], int]: ...
 
 else:

telegrinder/bot/scenario/choice.py

@@ -2,27 +2,24 @@ import typing
 
 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, ChoiceCode
+from telegrinder.bot.scenario.checkbox import Checkbox, ChoiceAction
 
 if typing.TYPE_CHECKING:
     from telegrinder.api.api import API
     from telegrinder.bot.dispatch.view.base import BaseStateView
-    from telegrinder.bot.scenario.checkbox import Key
 
-    class Choice(Checkbox[Key], typing.Generic[Key]):
+    class Choice[Key: typing.Hashable](Checkbox[Key]):
         async def wait(
             self,
             hasher: Hasher[CallbackQueryCute, int],
             api: API,
-            view: BaseStateView[CallbackQueryCute],
         ) -> tuple[Key, int]: ...
 
 else:
-
     class Choice(Checkbox):
         async def handle(self, cb):
             code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
-            if code == ChoiceCode.READY:
+            if code == ChoiceAction.READY:
                 return False
 
             for choice in self.choices:
@@ -41,10 +38,10 @@ else:
 
             return True
 
-        async def wait(self, hasher, api, view):
+        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, view)
+                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
 
 

telegrinder/client/__init__.py

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

telegrinder/client/abc.py

@@ -1,10 +1,18 @@
+import io
 import typing
 from abc import ABC, abstractmethod
 
+from telegrinder.client.form_data import MultipartFormProto, encode_form_data
+
+type Data = dict[str, typing.Any] | MultipartFormProto
+
+
+class ABCClient[MultipartForm: MultipartFormProto](ABC):
+    CONNECTION_TIMEOUT_ERRORS: tuple[type[BaseException], ...] = ()
+    CLIENT_CONNECTION_ERRORS: tuple[type[BaseException], ...] = ()
 
-class ABCClient(ABC):
     @abstractmethod
-    def __init__(self, *args: typing.Any, **kwargs: typing.Any):
+    def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
         pass
 
     @abstractmethod
@@ -12,7 +20,7 @@ class ABCClient(ABC):
         self,
         url: str,
         method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
+        data: Data | None = None,
         **kwargs: typing.Any,
     ) -> str:
         pass
@@ -22,7 +30,7 @@ class ABCClient(ABC):
         self,
         url: str,
         method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
+        data: Data | None = None,
         **kwargs: typing.Any,
     ) -> dict[str, typing.Any]:
         pass
@@ -32,7 +40,7 @@ class ABCClient(ABC):
         self,
         url: str,
         method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
+        data: Data | None = None,
         **kwargs: typing.Any,
     ) -> bytes:
         pass
@@ -42,7 +50,7 @@ class ABCClient(ABC):
         self,
         url: str,
         method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
+        data: Data | None = None,
         **kwargs: typing.Any,
     ) -> bytes:
         pass
@@ -53,12 +61,28 @@ class ABCClient(ABC):
 
     @classmethod
     @abstractmethod
+    def multipart_form_factory(cls) -> MultipartForm:
+        pass
+
+    @classmethod
     def get_form(
         cls,
+        *,
         data: dict[str, typing.Any],
-        files: dict[str, tuple[str, bytes]] | None = None,
-    ) -> typing.Any:
-        pass
+        files: dict[str, tuple[str, typing.Any]] | None = None,
+    ) -> MultipartForm:
+        multipart_form = cls.multipart_form_factory()
+        files = files or {}
+
+        for k, v in encode_form_data(data, files).items():
+            multipart_form.add_field(k, v)
+
+        for n, (filename, content) in {
+            k: (n, io.BytesIO(c) if isinstance(c, bytes) else c) for k, (n, c) in files.items()
+        }.items():
+            multipart_form.add_field(n, content, filename=filename)
+
+        return multipart_form
 
     async def __aenter__(self) -> typing.Self:
         return self
@@ -68,8 +92,9 @@ class ABCClient(ABC):
         exc_type: type[BaseException],
         exc_val: typing.Any,
         exc_tb: typing.Any,
-    ) -> None:
+    ) -> bool:
         await self.close()
+        return not bool(exc_val)
 
 
 __all__ = ("ABCClient",)

telegrinder/client/aiohttp.py

@@ -11,8 +11,23 @@ from telegrinder.client.abc import ABCClient
 if typing.TYPE_CHECKING:
     from aiohttp import ClientResponse
 
+type Data = dict[str, typing.Any] | aiohttp.formdata.FormData
+type Response = ClientResponse
+
+
+class AiohttpClient(ABCClient[aiohttp.formdata.FormData]):
+    """HTTP client based on `aiohttp` module."""
+
+    CONNECTION_TIMEOUT_ERRORS = (
+        aiohttp.client.ServerConnectionError,
+        TimeoutError,
+    )
+    CLIENT_CONNECTION_ERRORS = (
+        aiohttp.client.ClientConnectionError,
+        aiohttp.client.ClientConnectorError,
+        aiohttp.ClientOSError,
+    )
 
-class AiohttpClient(ABCClient):
     def __init__(
         self,
         session: ClientSession | None = None,
@@ -35,15 +50,16 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
+        data: Data | None = None,
         **kwargs: typing.Any,
-    ) -> "ClientResponse":
+    ) -> Response:
         if not self.session:
             self.session = ClientSession(
                 connector=TCPConnector(ssl=ssl.create_default_context(cafile=certifi.where())),
                 json_serialize=json.dumps,
                 **self.session_params,
             )
+
         async with self.session.request(
             url=url,
             method=method,
@@ -58,7 +74,7 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
+        data: Data | None = None,
         **kwargs: typing.Any,
     ) -> dict[str, typing.Any]:
         response = await self.request_raw(url, method, data, **kwargs)
@@ -72,7 +88,7 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: dict[str, typing.Any] | aiohttp.FormData | None = None,
+        data: Data | None = None,
         **kwargs: typing.Any,
     ) -> str:
         response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
@@ -82,48 +98,36 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: dict[str, typing.Any] | aiohttp.FormData | None = None,
+        data: Data | None = None,
         **kwargs: typing.Any,
     ) -> bytes:
         response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
         if response._body is None:
             await response.read()
-        return response._body
+        return response._body or bytes()
 
     async def request_content(
         self,
         url: str,
         method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
+        data: Data | None = None,
         **kwargs: typing.Any,
     ) -> bytes:
         response = await self.request_raw(url, method, data, **kwargs)
-        return response._body
+        return response._body or bytes()
 
     async def close(self) -> None:
         if self.session and not self.session.closed:
             await self.session.close()
 
     @classmethod
-    def get_form(
-        cls,
-        data: dict[str, typing.Any],
-        files: dict[str, tuple[str, bytes]] | None = None,
-    ) -> aiohttp.formdata.FormData:
-        files = files or {}
-        form = aiohttp.formdata.FormData(quote_fields=False)
-        for k, v in data.items():
-            form.add_field(k, str(v))
-
-        for n, f in files.items():
-            form.add_field(n, f[1], filename=f[0])
-
-        return form
+    def multipart_form_factory(cls) -> aiohttp.formdata.FormData:
+        return aiohttp.formdata.FormData(quote_fields=False)
 
     def __del__(self) -> None:
         if self.session and not self.session.closed:
             if self.session._connector is not None and self.session._connector_owner:
-                self.session._connector.close()
+                self.session._connector._close()
             self.session._connector = None