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

telegrinder/bot/polling/polling.py

@@ -1,26 +1,27 @@
 import asyncio
+import sys
 import typing
+from http import HTTPStatus
 
-import aiohttp
 import msgspec
 from fntypes.result import Error, Ok
 
-from telegrinder.api.api import API
-from telegrinder.api.error import InvalidTokenError
+from telegrinder.api.api import API, HTTPClient
+from telegrinder.api.error import APIServerError, InvalidTokenError
 from telegrinder.bot.polling.abc import ABCPolling
 from telegrinder.modules import logger
 from telegrinder.msgspec_utils import decoder
 from telegrinder.types.objects import Update, UpdateType
 
 
-class Polling(ABCPolling):
+class Polling(ABCPolling, typing.Generic[HTTPClient]):
     def __init__(
         self,
-        api: API,
+        api: API[HTTPClient],
         *,
         offset: int = 0,
-        reconnection_timeout: float = 5,
-        max_reconnetions: int = 10,
+        reconnection_timeout: float = 5.0,
+        max_reconnetions: int = 15,
         include_updates: set[str | UpdateType] | None = None,
         exclude_updates: set[str | UpdateType] | None = None,
     ) -> None:
@@ -30,9 +31,9 @@ class Polling(ABCPolling):
             exclude_updates=exclude_updates,
         )
         self.reconnection_timeout = 5.0 if reconnection_timeout < 0 else reconnection_timeout
-        self.max_reconnetions = 10 if max_reconnetions < 0 else max_reconnetions
+        self.max_reconnetions = 15 if max_reconnetions < 0 else max_reconnetions
         self.offset = offset
-        self._stop = False
+        self._stop = True
 
     def __repr__(self) -> str:
         return (
@@ -59,9 +60,7 @@ class Polling(ABCPolling):
             return allowed_updates
 
         if include_updates and exclude_updates:
-            allowed_updates = [
-                x for x in allowed_updates if x in include_updates and x not in exclude_updates
-            ]
+            allowed_updates = [x for x in allowed_updates if x in include_updates and x not in exclude_updates]
         elif exclude_updates:
             allowed_updates = [x for x in allowed_updates if x not in exclude_updates]
         elif include_updates:
@@ -69,60 +68,69 @@ class Polling(ABCPolling):
 
         return [x.value if isinstance(x, UpdateType) else x for x in allowed_updates]
 
-    async def get_updates(self) -> msgspec.Raw | None:
+    async def get_updates(self) -> msgspec.Raw:
         raw_updates = await self.api.request_raw(
-            "getUpdates",
-            {
-                "offset": self.offset,
-                "allowed_updates": self.allowed_updates,
-            },
+            method="getUpdates",
+            data=dict(
+                offset=self.offset,
+                allowed_updates=self.allowed_updates,
+            ),
         )
+
         match raw_updates:
             case Ok(value):
                 return value
-            case Error(err) if err.code in (401, 404):
-                raise InvalidTokenError("Token seems to be invalid")
+            case Error(err):
+                if err.code in (HTTPStatus.UNAUTHORIZED, HTTPStatus.NOT_FOUND):
+                    raise InvalidTokenError("Token seems to be invalid")
+                if err.code in (HTTPStatus.BAD_GATEWAY, HTTPStatus.GATEWAY_TIMEOUT):
+                    raise APIServerError("Unavilability of the API Telegram server")
+                raise err from None
 
     async def listen(self) -> typing.AsyncGenerator[list[Update], None]:
         logger.debug("Listening polling")
         reconn_counter = 0
+        self._stop = False
 
-        while not self._stop:
-            try:
-                updates = await self.get_updates()
-                reconn_counter = 0
-                if not updates:
-                    continue
-                updates_list: list[Update] = decoder.decode(updates, type=list[Update])
-                if updates_list:
-                    yield updates_list
-                    self.offset = updates_list[-1].update_id + 1
-            except InvalidTokenError as e:
-                logger.error(e)
-                self.stop()
-                exit(3)
-            except asyncio.CancelledError:
-                logger.info("Caught cancel, polling stopping...")
-                self.stop()
-            except (aiohttp.client.ServerConnectionError, TimeoutError):
-                if reconn_counter > self.max_reconnetions:
-                    logger.error(
-                        "Failed to reconnect to the server after {} attempts, polling stopping.",
-                        self.max_reconnetions,
-                    )
+        with decoder(list[Update]) as dec:  # For improve performance
+            while not self._stop:
+                try:
+                    updates = await self.get_updates()
+                    reconn_counter = 0
+                    updates_list = dec.decode(updates)
+                    if updates_list:
+                        yield updates_list
+                        self.offset = updates_list[-1].update_id + 1
+                except InvalidTokenError as e:
+                    logger.error(e)
+                    self.stop()
+                    sys.exit(3)
+                except APIServerError as e:
+                    logger.error(f"{e}, waiting {self.reconnection_timeout} seconds to the next request...")
+                    await asyncio.sleep(self.reconnection_timeout)
+                except asyncio.CancelledError:
+                    logger.info("Caught cancel, polling stopping...")
                     self.stop()
-                    exit(6)
-                else:
-                    logger.warning(
-                        "Server disconnected, waiting 5 seconds to reconnect...",
-                    )
-                    reconn_counter += 1
+                except self.api.http.CONNECTION_TIMEOUT_ERRORS:
+                    if reconn_counter > self.max_reconnetions:
+                        logger.error(
+                            "Failed to reconnect to the server after {} attempts, polling stopping.",
+                            self.max_reconnetions,
+                        )
+                        self.stop()
+                        sys.exit(6)
+                    else:
+                        logger.warning(
+                            "Server disconnected, waiting {} seconds to reconnect...",
+                            self.reconnection_timeout,
+                        )
+                        reconn_counter += 1
+                        await asyncio.sleep(self.reconnection_timeout)
+                except self.api.http.CLIENT_CONNECTION_ERRORS:
+                    logger.error("Client connection failed, attempted to reconnect...")
                     await asyncio.sleep(self.reconnection_timeout)
-            except (aiohttp.ClientConnectorError, aiohttp.ClientOSError):
-                logger.error("Client connection failed, attempted to reconnect...")
-                await asyncio.sleep(self.reconnection_timeout)
-            except BaseException as e:
-                logger.exception(e)
+                except BaseException as e:
+                    logger.exception("Traceback message below:")
 
     def stop(self) -> None:
         self._stop = True

telegrinder/bot/rules/__init__.py

@@ -19,6 +19,7 @@ from telegrinder.bot.rules.command import Argument, Command
 from telegrinder.bot.rules.enum_text import EnumTextRule
 from telegrinder.bot.rules.func import FuncRule
 from telegrinder.bot.rules.fuzzy import FuzzyText
+from telegrinder.bot.rules.id import IdRule
 from telegrinder.bot.rules.inline import (
     HasLocation,
     InlineQueryChatType,
@@ -45,16 +46,28 @@ from telegrinder.bot.rules.is_from import (
     IsUser,
     IsUserId,
 )
+from telegrinder.bot.rules.logic import If
 from telegrinder.bot.rules.markup import Markup
 from telegrinder.bot.rules.mention import HasMention
 from telegrinder.bot.rules.message import MessageRule
 from telegrinder.bot.rules.message_entities import HasEntities, MessageEntities
 from telegrinder.bot.rules.node import NodeRule
+from telegrinder.bot.rules.payload import (
+    PayloadEqRule,
+    PayloadJsonEqRule,
+    PayloadMarkupRule,
+    PayloadModelRule,
+    PayloadRule,
+)
+from telegrinder.bot.rules.payment_invoice import (
+    PaymentInvoiceCurrency,
+    PaymentInvoiceRule,
+)
 from telegrinder.bot.rules.regex import Regex
 from telegrinder.bot.rules.rule_enum import RuleEnum
 from telegrinder.bot.rules.start import StartCommand
 from telegrinder.bot.rules.state import State, StateMeta
-from telegrinder.bot.rules.text import HasText, Text
+from telegrinder.bot.rules.text import HasCaption, HasText, Text
 from telegrinder.bot.rules.update import IsUpdateType
 
 __all__ = (
@@ -73,12 +86,15 @@ __all__ = (
     "EnumTextRule",
     "FuncRule",
     "FuzzyText",
+    "HasCaption",
     "HasData",
     "HasEntities",
     "HasInviteLink",
     "HasLocation",
     "HasMention",
     "HasText",
+    "IdRule",
+    "If",
     "InlineQueryChatType",
     "InlineQueryMarkup",
     "InlineQueryRule",
@@ -110,6 +126,13 @@ __all__ = (
     "NodeRule",
     "NotRule",
     "OrRule",
+    "PayloadEqRule",
+    "PayloadJsonEqRule",
+    "PayloadMarkupRule",
+    "PayloadModelRule",
+    "PayloadRule",
+    "PaymentInvoiceCurrency",
+    "PaymentInvoiceRule",
     "Regex",
     "RuleEnum",
     "StartCommand",

telegrinder/bot/rules/abc.py

@@ -7,9 +7,10 @@ import typing_extensions as typing
 from telegrinder.bot.cute_types import MessageCute, UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.process import check_rule
-from telegrinder.bot.rules.adapter import ABCAdapter, RawUpdateAdapter
-from telegrinder.bot.rules.adapter.node import Event
-from telegrinder.node.base import Node, get_nodes, is_node
+from telegrinder.node.base import NodeType, get_nodes, is_node
+from telegrinder.tools.adapter import ABCAdapter
+from telegrinder.tools.adapter.node import Event
+from telegrinder.tools.adapter.raw_update import RawUpdateAdapter
 from telegrinder.tools.i18n.abc import ABCTranslator
 from telegrinder.tools.magic import (
     cache_translation,
@@ -24,7 +25,8 @@ if typing.TYPE_CHECKING:
 
 AdaptTo = typing.TypeVar("AdaptTo", default=typing.Any, contravariant=True)
 
-CheckResult: typing.TypeAlias = bool | typing.Awaitable[bool]
+type CheckResult = bool | typing.Awaitable[bool]
+
 Message: typing.TypeAlias = MessageCute
 Update: typing.TypeAlias = UpdateCute
 
@@ -58,8 +60,15 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
         def check(self, *args, **kwargs):
             pass
 
-    def __init_subclass__(cls, requires: list["ABCRule"] | None = None) -> None:
+    def __init_subclass__(
+        cls,
+        *,
+        requires: list["ABCRule"] | None = None,
+        adapter: ABCAdapter[UpdateObject, AdaptTo] | None = None,
+    ) -> None:
         """Merges requirements from inherited classes and rule-specific requirements."""
+        if adapter is not None:
+            cls.adapter = adapter
 
         requirements = []
         for base in inspect.getmro(cls):
@@ -77,7 +86,6 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
         rule #> AndRule(HasText(), HasCaption()) -> True if all rules in an AndRule are True, otherwise False.
         ```
         """
-
         return AndRule(self, other)
 
     def __or__(self, other: "ABCRule") -> "OrRule":
@@ -88,7 +96,6 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
         rule #> OrRule(HasText(), HasCaption()) -> True if any rule in an OrRule are True, otherwise False.
         ```
         """
-
         return OrRule(self, other)
 
     def __invert__(self) -> "NotRule":
@@ -99,7 +106,6 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
         rule # NotRule(HasText()) -> True if rule returned False, otherwise False.
         ```
         """
-
         return NotRule(self)
 
     def __repr__(self) -> str:
@@ -109,7 +115,7 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
         )
 
     @cached_property
-    def required_nodes(self) -> dict[str, type[Node]]:
+    def required_nodes(self) -> dict[str, type[NodeType]]:
         return get_nodes(self.check)
 
     def as_optional(self) -> "ABCRule":
@@ -120,8 +126,9 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
 
     async def bounding_check(
         self,
-        adapted_value: AdaptTo,
         ctx: Context,
+        *,
+        adapted_value: AdaptTo,
         node_col: "NodeCollection | None" = None,
     ) -> bool:
         bound_check_rule = self.check

telegrinder/bot/rules/callback_data.py

@@ -3,35 +3,41 @@ import inspect
 import typing
 from contextlib import suppress
 
-import msgspec
-
 from telegrinder.bot.cute_types import CallbackQueryCute
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.adapter import EventAdapter
-from telegrinder.model import decoder
-from telegrinder.tools.buttons import DataclassInstance
+from telegrinder.bot.rules.abc import ABCRule, CheckResult
+from telegrinder.bot.rules.payload import (
+    PayloadEqRule,
+    PayloadJsonEqRule,
+    PayloadMarkupRule,
+    PayloadModelRule,
+)
+from telegrinder.tools.adapter.event import EventAdapter
 from telegrinder.types.enums import UpdateType
 
-from .abc import ABCRule, CheckResult
-from .markup import Markup, PatternLike, check_string
-
 CallbackQuery: typing.TypeAlias = CallbackQueryCute
 Validator: typing.TypeAlias = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
 MapDict: typing.TypeAlias = dict[str, "typing.Any | type[typing.Any] | Validator | list[MapDict] | MapDict"]
 CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type[typing.Any] | Validator | CallbackMap"]]
 CallbackMapStrict: typing.TypeAlias = list[tuple[str, "Validator | CallbackMapStrict"]]
+CallbackDataEq: typing.TypeAlias = PayloadEqRule
+CallbackDataJsonEq: typing.TypeAlias = PayloadJsonEqRule
+CallbackDataMarkup: typing.TypeAlias = PayloadMarkupRule
+CallbackDataJsonModel: typing.TypeAlias = PayloadModelRule
 
 
-class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
-    adapter: EventAdapter[CallbackQuery] = EventAdapter(UpdateType.CALLBACK_QUERY, CallbackQuery)
-
+class CallbackQueryRule(
+    ABCRule[CallbackQuery],
+    abc.ABC,
+    adapter=EventAdapter(UpdateType.CALLBACK_QUERY, CallbackQuery),
+):
     @abc.abstractmethod
     def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
 
 
 class HasData(CallbackQueryRule):
     def check(self, event: CallbackQuery) -> bool:
-        return bool(event.data.unwrap_or_none())
+        return bool(event.data)
 
 
 class CallbackQueryDataRule(CallbackQueryRule, abc.ABC, requires=[HasData()]):
@@ -47,7 +53,6 @@ class CallbackDataMap(CallbackQueryDataRule):
     @classmethod
     def transform_to_map(cls, mapping: MapDict) -> CallbackMap:
         """Transforms MapDict to CallbackMap."""
-
         callback_map = []
 
         for k, v in mapping.items():
@@ -60,7 +65,6 @@ class CallbackDataMap(CallbackQueryDataRule):
     @classmethod
     def transform_to_callbacks(cls, callback_map: CallbackMap) -> CallbackMapStrict:
         """Transforms `CallbackMap` to `CallbackMapStrict`."""
-
         callback_map_result = []
 
         for key, value in callback_map:
@@ -79,7 +83,6 @@ class CallbackDataMap(CallbackQueryDataRule):
     @staticmethod
     async def run_validator(value: typing.Any, validator: Validator) -> bool:
         """Run async or sync validator."""
-
         with suppress(BaseException):
             result = validator(value)
             if inspect.isawaitable(result):
@@ -91,15 +94,12 @@ class CallbackDataMap(CallbackQueryDataRule):
     @classmethod
     async def match(cls, callback_data: dict[str, typing.Any], callback_map: CallbackMapStrict) -> bool:
         """Matches callback_data with callback_map recursively."""
-
         for key, validator in callback_map:
             if key not in callback_data:
                 return False
 
             if isinstance(validator, list):
-                if not (
-                    isinstance(callback_data[key], dict) and await cls.match(callback_data[key], validator)
-                ):
+                if not (isinstance(callback_data[key], dict) and await cls.match(callback_data[key], validator)):
                     return False
 
             elif not await cls.run_validator(callback_data[key], validator):
@@ -108,7 +108,7 @@ class CallbackDataMap(CallbackQueryDataRule):
         return True
 
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
-        callback_data = event.decode_callback_data().unwrap_or_none()
+        callback_data = event.decode_data().unwrap_or_none()
         if callback_data is None:
             return False
         if await self.match(callback_data, self.mapping):
@@ -117,47 +117,6 @@ class CallbackDataMap(CallbackQueryDataRule):
         return False
 
 
-class CallbackDataEq(CallbackQueryDataRule):
-    def __init__(self, value: str, /) -> None:
-        self.value = value
-
-    def check(self, event: CallbackQuery) -> bool:
-        return event.data.unwrap() == self.value
-
-
-class CallbackDataJsonEq(CallbackQueryDataRule):
-    def __init__(self, d: dict[str, typing.Any], /) -> None:
-        self.d = d
-
-    def check(self, event: CallbackQuery) -> bool:
-        return event.decode_callback_data().unwrap_or_none() == self.d
-
-
-class CallbackDataJsonModel(CallbackQueryDataRule):
-    def __init__(
-        self,
-        model: type[msgspec.Struct] | type[DataclassInstance],
-        *,
-        alias: str | None = None,
-    ) -> None:
-        self.model = model
-        self.alias = alias or "data"
-
-    def check(self, event: CallbackQuery, ctx: Context) -> bool:
-        with suppress(BaseException):
-            ctx.set(self.alias, decoder.decode(event.data.unwrap().encode(), type=self.model))
-            return True
-        return False
-
-
-class CallbackDataMarkup(CallbackQueryDataRule):
-    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
-        self.patterns = Markup(patterns).patterns
-
-    def check(self, event: CallbackQuery, ctx: Context) -> bool:
-        return check_string(self.patterns, event.data.unwrap(), ctx)
-
-
 __all__ = (
     "CallbackDataEq",
     "CallbackDataJsonEq",

telegrinder/bot/rules/chat_join.py

@@ -2,7 +2,7 @@ import abc
 import typing
 
 from telegrinder.bot.cute_types import ChatJoinRequestCute
-from telegrinder.bot.rules.adapter import EventAdapter
+from telegrinder.tools.adapter.event import EventAdapter
 from telegrinder.types.enums import UpdateType
 
 from .abc import ABCRule, CheckResult
@@ -10,9 +10,11 @@ from .abc import ABCRule, CheckResult
 ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
 
 
-class ChatJoinRequestRule(ABCRule[ChatJoinRequest], requires=[]):
-    adapter: EventAdapter[ChatJoinRequest] = EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest)
-
+class ChatJoinRequestRule(
+    ABCRule[ChatJoinRequest],
+    abc.ABC,
+    adapter=EventAdapter(UpdateType.CHAT_JOIN_REQUEST, ChatJoinRequest),
+):
     @abc.abstractmethod
     def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
 

telegrinder/bot/rules/command.py

@@ -4,12 +4,12 @@ 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.node.source import ChatSource
 from telegrinder.types.enums import ChatType
 
 from .abc import ABCRule
 
-Validator: typing.TypeAlias = typing.Callable[[str], typing.Any | None]
+type Validator = typing.Callable[[str], typing.Any | None]
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
@@ -97,7 +97,7 @@ class Command(ABCRule):
 
         return None
 
-    def check(self, command: CommandInfo, me: Me, src: Source, ctx: Context) -> bool:
+    def check(self, command: CommandInfo, me: Me, chat: ChatSource, ctx: Context) -> bool:
         name = self.remove_prefix(command.name)
         if name is None:
             return False
@@ -105,7 +105,7 @@ class Command(ABCRule):
         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:
+        if not command.mention and self.mention_needed_in_chat and chat.type is not ChatType.PRIVATE:
             return False
 
         if command.mention and self.validate_mention:  # noqa

telegrinder/bot/rules/enum_text.py

@@ -1,15 +1,12 @@
 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]):
+class EnumTextRule[T: enum.Enum](ABCRule):
     def __init__(self, enum_t: type[T], *, lower_case: bool = True) -> None:
         self.enum_t = enum_t
         self.texts = list(

telegrinder/bot/rules/func.py

@@ -2,9 +2,11 @@ import inspect
 import typing
 
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.raw_update import RawUpdateAdapter
 from telegrinder.types.objects import Update
 
-from .abc import ABCAdapter, ABCRule, AdaptTo, RawUpdateAdapter
+from .abc import ABCRule, AdaptTo
 
 
 class FuncRule(ABCRule, typing.Generic[AdaptTo]):
@@ -19,8 +21,8 @@ class FuncRule(ABCRule, typing.Generic[AdaptTo]):
     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
+            result = await result
+        return result
 
 
 __all__ = ("FuncRule",)

telegrinder/bot/rules/fuzzy.py

@@ -7,7 +7,7 @@ from .abc import ABCRule
 
 
 class FuzzyText(ABCRule):
-    def __init__(self, texts: str | list[str], min_ratio: float = 0.7) -> None:
+    def __init__(self, texts: str | list[str], /, min_ratio: float = 0.7) -> None:
         if isinstance(texts, str):
             texts = [texts]
         self.texts = texts

telegrinder/bot/rules/id.py

@@ -0,0 +1,24 @@
+import typing
+
+from telegrinder.types.objects import Update
+
+from .abc import ABCRule
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.adapter.abc import ABCAdapter
+
+
+class IdRule[Identifier](ABCRule[Identifier]):
+    def __init__(
+        self,
+        adapter: "ABCAdapter[Update, Identifier]",
+        tracked_identifiers: set[Identifier] | None = None,
+    ):
+        self.tracked_identifiers = tracked_identifiers or set()
+        self.adapter = adapter
+
+    async def check(self, event: Identifier) -> bool:
+        return event in self.tracked_identifiers
+
+
+__all__ = ("IdRule",)

telegrinder/bot/rules/inline.py

@@ -4,7 +4,7 @@ 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.tools.adapter.event import EventAdapter
 from telegrinder.types.enums import ChatType, UpdateType
 
 from .markup import Markup, PatternLike, check_string
@@ -12,9 +12,11 @@ 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)
-
+class InlineQueryRule(
+    ABCRule[InlineQuery],
+    abc.ABC,
+    adapter=EventAdapter(UpdateType.INLINE_QUERY, InlineQuery),
+):
     @abc.abstractmethod
     def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult: ...
 

telegrinder/bot/rules/integer.py

@@ -1,3 +1,4 @@
+from telegrinder.node.base import as_node
 from telegrinder.node.text import TextInteger
 
 from .abc import ABCRule
@@ -6,7 +7,7 @@ from .node import NodeRule
 
 class IsInteger(NodeRule):
     def __init__(self) -> None:
-        super().__init__(TextInteger)
+        super().__init__(as_node(TextInteger))
 
 
 class IntegerInRange(ABCRule):

telegrinder/bot/rules/logic.py

@@ -0,0 +1,18 @@
+import typing
+
+from .abc import ABCRule, Context, UpdateCute, check_rule
+
+
+class If(ABCRule):
+    def __init__(self, condition: ABCRule) -> None:
+        self.conditions = [condition]
+
+    async def check(self, update: UpdateCute, ctx: Context) -> bool:
+        for condition in self.conditions[:-1]:
+            if not await check_rule(update.api, condition, update, ctx):
+                return True
+        return await check_rule(update.api, self.conditions[-1], update, ctx)
+
+    def then(self, condition: ABCRule) -> typing.Self:
+        self.conditions.append(condition)
+        return self