telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/bot/polling/polling.py

@@ -0,0 +1,167 @@
+import datetime
+import typing
+from http import HTTPStatus
+
+import msgspec
+from kungfu.library.misc import is_ok
+
+from telegrinder.api.api import API
+from telegrinder.api.error import APIServerError, InvalidTokenError
+from telegrinder.bot.polling.abc import ABCPolling
+from telegrinder.bot.polling.error_handler import ErrorHandler
+from telegrinder.bot.polling.utils import compute_number
+from telegrinder.modules import logger
+from telegrinder.msgspec_utils import decoder
+from telegrinder.types.objects import Update, UpdateType
+
+DEFAULT_OFFSET: typing.Final = 0
+DEFAULT_RECONNECT_AFTER: typing.Final = 5.0
+DEFAULT_MAX_RECONNECTS: typing.Final = 15
+
+
+class Polling(ABCPolling):
+    __slots__ = (
+        "api",
+        "timeout",
+        "limit",
+        "allowed_updates",
+        "reconnect_after",
+        "max_reconnects",
+        "offset",
+        "_running",
+        "_reconnects_counter",
+        "_error_handler",
+    )
+
+    def __init__(
+        self,
+        api: API,
+        *,
+        timeout: int | float | datetime.timedelta | None = None,
+        limit: int | None = None,
+        offset: int = DEFAULT_OFFSET,
+        reconnect_after: float = DEFAULT_RECONNECT_AFTER,
+        max_reconnects: int = DEFAULT_MAX_RECONNECTS,
+        include_updates: set[UpdateType] | None = None,
+        exclude_updates: set[UpdateType] | None = None,
+    ) -> None:
+        self.api = api
+        self.timeout = timeout if isinstance(timeout, datetime.timedelta) else datetime.timedelta(seconds=timeout or 0)
+        self.timeout_seconds = int(self.timeout.total_seconds())
+        self.limit = limit
+        self.offset = max(DEFAULT_OFFSET, offset)
+        self.allowed_updates = self.get_allowed_updates(
+            include_updates=include_updates,
+            exclude_updates=exclude_updates,
+        )
+        self.reconnect_after = compute_number(DEFAULT_RECONNECT_AFTER, reconnect_after, 0.0)
+        self.max_reconnects = compute_number(DEFAULT_MAX_RECONNECTS, max_reconnects, 0)
+        self._running = False
+        self._reconnects_counter = 0
+        self._error_handler = ErrorHandler(self)
+
+    def __repr__(self) -> str:
+        return (
+            "<{}: api={!r}, running={}, offset={}, timeout={}, limit={}, "
+            "allowed_updates={!r}, max_reconnects={}, reconnect_after={}>"
+        ).format(
+            type(self).__name__,
+            self.api,
+            self._running,
+            self.offset,
+            self.timeout,
+            self.limit,
+            self.allowed_updates,
+            self.max_reconnects,
+            self.reconnect_after,
+        )
+
+    @staticmethod
+    def get_allowed_updates(
+        *,
+        include_updates: set[UpdateType] | None = None,
+        exclude_updates: set[UpdateType] | None = None,
+    ) -> list[UpdateType]:
+        allowed_updates = list(UpdateType)
+
+        if include_updates and exclude_updates:
+            return [x for x in allowed_updates if x in include_updates and x not in exclude_updates]
+
+        if exclude_updates:
+            return [x for x in allowed_updates if x not in exclude_updates]
+
+        if include_updates:
+            return [x for x in allowed_updates if x in include_updates]
+
+        return allowed_updates
+
+    @property
+    def reconnects_counter(self) -> int:
+        return self._reconnects_counter
+
+    @property
+    def running(self) -> bool:
+        return self._running
+
+    def _reset_reconnects_counter(self) -> None:
+        self._reconnects_counter = 0
+
+    async def get_updates(self) -> msgspec.Raw:
+        try:
+            raw_updates = await self.api.request_raw(
+                method="getUpdates",
+                data=dict(
+                    offset=self.offset,
+                    limit=self.limit,
+                    timeout=self.timeout_seconds,
+                    allowed_updates=self.allowed_updates,
+                ),
+                timeout=self.timeout + self.api.http.timeout,
+            )
+        except TimeoutError:
+            return msgspec.Raw(b"")
+
+        if is_ok(raw_updates):
+            return raw_updates.value
+
+        match (error := raw_updates.error).status_code:
+            case HTTPStatus.CONFLICT:
+                error = APIServerError("Cannot run polling, because another bot instance is already running.")
+            case HTTPStatus.UNAUTHORIZED | HTTPStatus.NOT_FOUND as status:
+                error = InvalidTokenError(
+                    "Token seems to be invalid" if status == HTTPStatus.NOT_FOUND else "Invalid token (unauthorized)",
+                )
+            case HTTPStatus.BAD_GATEWAY | HTTPStatus.GATEWAY_TIMEOUT as status:
+                error = APIServerError(
+                    message="Telegram API server responded a {}".format(status.name.replace("_", " ")),
+                    retry_after=int(self.reconnect_after),
+                )
+
+        raise error from None
+
+    async def listen(self) -> typing.AsyncGenerator[list[Update], None]:
+        await logger.adebug("Listening polling")
+        self._running = True
+
+        with decoder(list[Update]) as updates_decoder:
+            while self._running:
+                try:
+                    if (raw := await self.get_updates()) and (updates := updates_decoder.decode(raw)):
+                        yield updates
+                        self.offset = updates[-1].update_id + 1
+
+                    if self._reconnects_counter != 0:
+                        self._reset_reconnects_counter()
+                except BaseException as error:
+                    if not await self._error_handler.handle(error):
+                        await logger.aexception("Traceback message below:")
+
+                    if isinstance(error, self.api.http.CONNECTION_TIMEOUT_ERRORS):
+                        self._reconnects_counter += 1
+
+    def stop(self) -> None:
+        self._running = False
+        self._reset_reconnects_counter()
+
+
+__all__ = ("Polling",)

telegrinder/bot/polling/utils.py

@@ -0,0 +1,12 @@
+def compute_number(
+    default: int | float,
+    input_value: int | float,
+    conditional_value: int | float,
+    /,
+) -> int | float:
+    return max(default, input_value) * (input_value <= conditional_value) + input_value * (
+        input_value >= conditional_value
+    )
+
+
+__all__ = ("compute_number",)

telegrinder/bot/rules/__init__.py

@@ -0,0 +1,166 @@
+from telegrinder.bot.rules.abc import ABCRule, AndRule, NotRule, OrRule, check_rule
+from telegrinder.bot.rules.button import ButtonRule
+from telegrinder.bot.rules.callback_data import (
+    CallbackDataEq,
+    CallbackDataJsonEq,
+    CallbackDataJsonModel,
+    CallbackDataMap,
+    CallbackDataMarkup,
+    CallbackQueryDataRule,
+    HasData,
+)
+from telegrinder.bot.rules.chat_join import (
+    HasInviteLink,
+    InviteLinkByCreator,
+    InviteLinkName,
+)
+from telegrinder.bot.rules.chat_member_updated import ChatMemberUpdatedRule, MemberStatus
+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.inline import (
+    HasLocation,
+    InlineQueryChatType,
+    InlineQueryMarkup,
+    InlineQueryText,
+)
+from telegrinder.bot.rules.integer import IntegerInRange, IsInteger
+from telegrinder.bot.rules.is_from import (
+    IsBot,
+    IsChat,
+    IsChatId,
+    IsChecklist,
+    IsContact,
+    IsDice,
+    IsDiceEmoji,
+    IsDocument,
+    IsForum,
+    IsForward,
+    IsForwardType,
+    IsGame,
+    IsGroup,
+    IsLanguageCode,
+    IsLeftChatMember,
+    IsLocation,
+    IsNewChatMembers,
+    IsNewChatPhoto,
+    IsNewChatTitle,
+    IsPhoto,
+    IsPoll,
+    IsPremium,
+    IsPrivate,
+    IsReply,
+    IsSticker,
+    IsSuperGroup,
+    IsTelegram,
+    IsUser,
+    IsUserId,
+    IsVenue,
+    IsVideoNote,
+)
+from telegrinder.bot.rules.logic import If
+from telegrinder.bot.rules.magic import Magic
+from telegrinder.bot.rules.markup import Markup
+from telegrinder.bot.rules.mention import HasMention
+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
+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 HasCaption, HasText, Text
+from telegrinder.bot.rules.update import IsUpdateType
+
+__all__ = (
+    "ABCRule",
+    "AndRule",
+    "Argument",
+    "ButtonRule",
+    "CallbackDataEq",
+    "CallbackDataJsonEq",
+    "CallbackDataJsonModel",
+    "CallbackDataMap",
+    "CallbackDataMarkup",
+    "CallbackQueryDataRule",
+    "ChatMemberUpdatedRule",
+    "Command",
+    "EnumTextRule",
+    "FuncRule",
+    "FuzzyText",
+    "HasCaption",
+    "HasData",
+    "HasEntities",
+    "HasInviteLink",
+    "HasLocation",
+    "HasMention",
+    "HasText",
+    "If",
+    "InlineQueryChatType",
+    "InlineQueryMarkup",
+    "InlineQueryText",
+    "IntegerInRange",
+    "InviteLinkByCreator",
+    "InviteLinkName",
+    "IsBot",
+    "IsChat",
+    "IsChatId",
+    "IsChecklist",
+    "IsContact",
+    "IsDice",
+    "IsDiceEmoji",
+    "IsDocument",
+    "IsForum",
+    "IsForward",
+    "IsForwardType",
+    "IsGame",
+    "IsGroup",
+    "IsInteger",
+    "IsLanguageCode",
+    "IsLeftChatMember",
+    "IsLocation",
+    "IsNewChatMembers",
+    "IsNewChatPhoto",
+    "IsNewChatTitle",
+    "IsPhoto",
+    "IsPoll",
+    "IsPremium",
+    "IsPrivate",
+    "IsReply",
+    "IsSticker",
+    "IsSuperGroup",
+    "IsTelegram",
+    "IsUpdateType",
+    "IsUser",
+    "IsUserId",
+    "IsVenue",
+    "IsVideoNote",
+    "Magic",
+    "Markup",
+    "MemberStatus",
+    "MessageEntities",
+    "NodeRule",
+    "NotRule",
+    "OrRule",
+    "PayloadEqRule",
+    "PayloadJsonEqRule",
+    "PayloadMarkupRule",
+    "PayloadModelRule",
+    "PayloadRule",
+    "PaymentInvoiceCurrency",
+    "Regex",
+    "RuleEnum",
+    "StartCommand",
+    "State",
+    "StateMeta",
+    "Text",
+    "check_rule",
+)

telegrinder/bot/rules/abc.py

@@ -0,0 +1,150 @@
+import typing
+from abc import ABC, abstractmethod
+from collections import deque
+from functools import cached_property
+
+from nodnod.agent.event_loop.agent import EventLoopAgent
+from nodnod.interface.node_from_function import create_node_from_function
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.node.compose import create_composable
+from telegrinder.node.utils import get_globals_from_function, get_locals_from_function
+from telegrinder.tools.fullname import fullname
+
+if typing.TYPE_CHECKING:
+    from nodnod.agent.base import Agent
+
+    from telegrinder.node.compose import Composable
+
+type CheckResult = bool | typing.Awaitable[bool]
+type Node = typing.Any
+
+
+class ABCRule(ABC):
+    required_nodes: typing.Mapping[str, Node] | None = None
+    agent_cls: type[Agent] = EventLoopAgent
+    requires: deque[ABCRule] = deque()
+
+    @abstractmethod
+    def check(self, *args: typing.Any, **kwargs: typing.Any) -> CheckResult:
+        pass
+
+    def __init_subclass__(
+        cls,
+        *,
+        requires: typing.Iterable[ABCRule] | None = None,
+    ) -> None:
+        requirements: list[ABCRule] = []
+
+        for base in cls.__mro__:
+            if issubclass(base, ABCRule) and base != cls:
+                requirements.extend(base.requires or ())
+
+        requirements.extend(requires or ())
+        cls.requires = deque(dict.fromkeys(requirements))
+
+    def __and__(self, other: object, /) -> AndRule:
+        if not isinstance(other, ABCRule):
+            return NotImplemented
+        return AndRule(self, other)
+
+    def __iadd__(self, other: object, /) -> AndRule:
+        return self.__and__(other)
+
+    def __or__(self, other: object, /) -> OrRule:
+        if not isinstance(other, ABCRule):
+            return NotImplemented
+        return OrRule(self, other)
+
+    def __ior__(self, other: object, /) -> OrRule:
+        return self.__or__(other)
+
+    def __invert__(self) -> NotRule:
+        return NotRule(self)
+
+    def __repr__(self) -> str:
+        return "<{}{}>".format(
+            fullname(self),
+            "" if not self.requires else ", requires={!r}".format(self.requires),
+        )
+
+    def as_optional(self) -> ABCRule:
+        return self | Always()
+
+    def should_fail(self) -> ABCRule:
+        return self & Never()
+
+    @cached_property
+    def composable(self) -> Composable:
+        node = create_node_from_function(
+            self.check,
+            dependencies=self.required_nodes,
+            forward_refs=get_globals_from_function(self.check),
+            namespace=get_locals_from_function(self.check),
+        )
+        return create_composable(node, agent_cls=self.agent_cls)
+
+
+class AndRule(ABCRule):
+    def __init__(self, *rules: ABCRule) -> None:
+        self.rules = rules
+
+    async def check(self, context: Context) -> bool:
+        ctx_copy = context.copy()
+
+        for rule in self.rules:
+            if not await check_rule(rule, ctx_copy):
+                return False
+
+        context |= ctx_copy
+        return True
+
+
+class OrRule(ABCRule):
+    def __init__(self, *rules: ABCRule) -> None:
+        self.rules = rules
+
+    async def check(self, context: Context) -> bool:
+        for rule in self.rules:
+            ctx_copy = context.copy()
+
+            if await check_rule(rule, ctx_copy):
+                context |= ctx_copy
+                return True
+
+        return False
+
+
+class NotRule(ABCRule):
+    def __init__(self, rule: ABCRule) -> None:
+        self.rule = rule
+
+    async def check(self, context: Context) -> bool:
+        return not await check_rule(self.rule, context.copy())
+
+
+class Never(ABCRule):
+    """Neutral element for `|` (OrRule)."""
+
+    def check(self) -> typing.Literal[False]:
+        return False
+
+
+class Always(ABCRule):
+    """Neutral element for `&` (AndRule)."""
+
+    def check(self) -> typing.Literal[True]:
+        return True
+
+
+__all__ = (
+    "ABCRule",
+    "Always",
+    "AndRule",
+    "CheckResult",
+    "Never",
+    "NotRule",
+    "OrRule",
+    "check_rule",
+)

telegrinder/bot/rules/button.py

@@ -0,0 +1,20 @@
+import typing
+
+from telegrinder.bot.rules.abc import ABCRule, CheckResult
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.keyboard.button import BaseButton
+
+
+class ButtonRule[KeyboardButton: BaseButton[typing.Any]](ABCRule):
+    def __init__(self, button: KeyboardButton, rule: ABCRule) -> None:
+        self.button = button
+        self.rule = rule
+        self.composable = rule.composable
+
+    @property
+    def check(self) -> typing.Callable[..., CheckResult]:
+        return self.rule.check
+
+
+__all__ = ("ButtonRule",)

telegrinder/bot/rules/callback_data.py

@@ -0,0 +1,109 @@
+import abc
+import typing
+from contextlib import suppress
+
+from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.payload import (
+    PayloadEqRule,
+    PayloadJsonEqRule,
+    PayloadMarkupRule,
+    PayloadModelRule,
+)
+from telegrinder.tools.aio import maybe_awaitable
+
+type Validator = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
+type CallbackMap = dict[str, typing.Any | type[typing.Any] | Validator | CallbackMap]
+type CallbackMapStrict = dict[str, Validator | CallbackMapStrict]
+
+CallbackQuery: typing.TypeAlias = CallbackQueryCute
+CallbackDataEq: typing.TypeAlias = PayloadEqRule
+CallbackDataJsonEq: typing.TypeAlias = PayloadJsonEqRule
+CallbackDataMarkup: typing.TypeAlias = PayloadMarkupRule
+CallbackDataJsonModel: typing.TypeAlias = PayloadModelRule
+
+
+class HasData(ABCRule):
+    def check(self, event: CallbackQuery) -> bool:
+        return bool(event.data)
+
+
+class CallbackQueryDataRule(ABCRule, abc.ABC, requires=[HasData()]):
+    pass
+
+
+class CallbackDataMap(CallbackQueryDataRule):
+    def __init__(self, mapping: CallbackMap, /, *, allow_extra_fields: bool = False) -> None:
+        """Callback data map validation.
+        :param mapping: A callback data mapping with validators.
+        :param allow_extra_fields: Allows extra fields in a callback query data.
+        """
+        self.mapping = self.transform_to_callbacks(mapping)
+        self.allow_extra_fields = allow_extra_fields
+
+    @classmethod
+    def transform_to_callbacks(cls, callback_map: CallbackMap) -> CallbackMapStrict:
+        """Transforms `CallbackMap` to `CallbackMapStrict`."""
+        callback_map_result = []
+
+        for key, value in callback_map.items():
+            if isinstance(value, type):
+                validator = (lambda tp: lambda v: isinstance(v, tp))(value)
+            elif isinstance(value, dict):
+                validator = cls.transform_to_callbacks(value)
+            elif not callable(value):
+                validator = (lambda val: lambda v: val == v)(value)
+            else:
+                validator = value
+            callback_map_result.append((key, validator))
+
+        return dict(callback_map_result)
+
+    @staticmethod
+    async def run_validator(value: typing.Any, validator: Validator) -> bool:
+        """Runs sync/async validator."""
+        with suppress(Exception):
+            return await maybe_awaitable(validator(value))
+        return False
+
+    @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.items():
+            if key not in callback_data:
+                return False
+
+            if isinstance(validator, dict):
+                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):
+                return False
+
+        return True
+
+    async def check(self, event: CallbackQuery, ctx: Context) -> bool:
+        callback_data = event.decode_data().unwrap_or_none()
+        if callback_data is None:
+            return False
+
+        if not self.allow_extra_fields and self.mapping.keys() != callback_data.keys():
+            return False
+
+        if await self.match(callback_data, self.mapping):
+            ctx |= {k: callback_data[k] for k in self.mapping}
+            return True
+
+        return False
+
+
+__all__ = (
+    "CallbackDataEq",
+    "CallbackDataJsonEq",
+    "CallbackDataJsonModel",
+    "CallbackDataMap",
+    "CallbackDataMarkup",
+    "CallbackQueryDataRule",
+    "HasData",
+)

telegrinder/bot/rules/chat_join.py

@@ -0,0 +1,28 @@
+from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
+from telegrinder.bot.rules.abc import ABCRule
+
+type ChatJoinRequest = ChatJoinRequestCute
+
+
+class HasInviteLink(ABCRule):
+    def check(self, event: ChatJoinRequest) -> bool:
+        return bool(event.invite_link)
+
+
+class InviteLinkName(ABCRule, requires=[HasInviteLink()]):
+    def __init__(self, name: str, /) -> None:
+        self.name = name
+
+    def check(self, event: ChatJoinRequest) -> bool:
+        return event.invite_link.unwrap().name.unwrap_or_none() == self.name
+
+
+class InviteLinkByCreator(ABCRule, requires=[HasInviteLink()]):
+    def __init__(self, creator_id: int, /) -> None:
+        self.creator_id = creator_id
+
+    def check(self, event: ChatJoinRequest) -> bool:
+        return event.invite_link.unwrap().creator.id == self.creator_id
+
+
+__all__ = ("HasInviteLink", "InviteLinkByCreator", "InviteLinkName")