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

telegrinder/bot/cute_types/base.py

@@ -1,46 +1,54 @@
-import dataclasses
-import inspect
 import typing
-from functools import wraps
 
 import msgspec
-import typing_extensions
-from fntypes.result import Result
 
 from telegrinder.api.api import API
-from telegrinder.model import Model, get_params
+from telegrinder.model import Model, is_none
 
-F = typing.TypeVar("F", bound=typing.Callable[..., typing.Any])
-Cute = typing.TypeVar("Cute", bound="BaseCute")
-Update = typing_extensions.TypeVar("Update", bound=Model)
-CtxAPI = typing_extensions.TypeVar("CtxAPI", bound=API, default=API)
 
-Executor: typing.TypeAlias = typing.Callable[
-    [Cute, str, dict[str, typing.Any]],
-    typing.Awaitable[Result[typing.Any, typing.Any]],
-]
+def compose_method_params[Cute: BaseCute](
+    params: dict[str, typing.Any],
+    update: Cute,
+    *,
+    default_params: set[str | tuple[str, str]] | None = None,
+    validators: dict[str, typing.Callable[[Cute], bool]] | None = None,
+) -> dict[str, typing.Any]:
+    default_params = default_params or set()
+    validators = validators or {}
+
+    for param in default_params:
+        param_name = param if isinstance(param, str) else param[0]
+        if param_name not in params:
+            if param_name in validators and not validators[param_name](update):
+                continue
+            params[param_name] = getattr(update, param if isinstance(param, str) else param[1])
+
+    return params
+
 
 if typing.TYPE_CHECKING:
+    from telegrinder.node.base import Node
 
-    class BaseCute(Model, typing.Generic[Update, CtxAPI]):
+    class BaseCute[Update: Model](Model):
         api: API
 
+        @classmethod
+        def as_node(cls) -> type[Node]: ...
+
         @classmethod
         def from_update(cls, update: Update, bound_api: API) -> typing.Self: ...
 
         @property
-        def ctx_api(self) -> CtxAPI: ...
+        def ctx_api(self) -> API: ...
 
         def to_dict(
             self,
             *,
             exclude_fields: set[str] | None = None,
         ) -> dict[str, typing.Any]:
-            """
-            :param exclude_fields: Cute model field names to exclude from the dictionary representation of this cute model.
+            """:param exclude_fields: Cute model field names to exclude from the dictionary representation of this cute model.
             :return: A dictionary representation of this cute model.
             """
-
             ...
 
         def to_full_dict(
@@ -48,21 +56,19 @@ if typing.TYPE_CHECKING:
             *,
             exclude_fields: set[str] | None = None,
         ) -> dict[str, typing.Any]:
-            """
-            :param exclude_fields: Cute model field names to exclude from the dictionary representation of this cute model.
+            """:param exclude_fields: Cute model field names to exclude from the dictionary representation of this cute model.
             :return: A dictionary representation of this model including all models, structs, custom types.
             """
-
             ...
 
 else:
     import msgspec
     from fntypes.co import Nothing, Some, Variative
 
-    from telegrinder.msgspec_utils import Option, decoder, encoder
+    from telegrinder.msgspec_utils import Option, decoder, encoder, struct_as_dict
     from telegrinder.msgspec_utils import get_class_annotations as _get_class_annotations
 
-    def _get_cute_from_generic(generic_args):
+    def _get_cute_from_generic(generic_args, /):
         for arg in generic_args:
             orig_arg = typing.get_origin(arg) or arg
 
@@ -70,12 +76,12 @@ else:
                 continue
             if orig_arg in (Variative, Some, Option):
                 return _get_cute_from_generic(typing.get_args(arg))
-            if issubclass(arg, BaseCute):
+            if issubclass(orig_arg, BaseCute):
                 return arg
 
         return None
 
-    def _get_cute_annotations(annotations):
+    def _get_cute_annotations(annotations, /):
         cute_annotations = {}
 
         for key, hint in annotations.items():
@@ -88,7 +94,7 @@ else:
 
         return cute_annotations
 
-    def _get_value(value):
+    def _validate_value(value, /):
         while isinstance(value, Variative | Some):
             if isinstance(value, Variative):
                 value = value.v
@@ -96,7 +102,9 @@ else:
                 value = value.value
         return value
 
-    class BaseCute(typing.Generic[Update, CtxAPI]):
+    class BaseCute[Update]:
+        api: API
+
         def __init_subclass__(cls, *args, **kwargs):
             super().__init_subclass__(*args, **kwargs)
 
@@ -105,6 +113,15 @@ else:
 
             cls.__is_solved_annotations__ = False
             cls.__cute_annotations__ = None
+            cls.__event_node__ = None
+
+        @classmethod
+        def as_node(cls):
+            if cls.__event_node__ is None:
+                from telegrinder.node.event import _EventNode
+
+                cls.__event_node__ = _EventNode[cls]
+            return cls.__event_node__
 
         @classmethod
         def from_update(cls, update, bound_api):
@@ -118,10 +135,10 @@ else:
             return cls(
                 **{
                     field: decoder.convert(
-                        cls.__cute_annotations__[field].from_update(_get_value(value), bound_api=bound_api),
+                        cls.__cute_annotations__[field].from_update(_validate_value(value), bound_api=bound_api),
                         type=cls.__annotations__[field],
                     )
-                    if field in cls.__cute_annotations__ and not isinstance(value, Nothing)
+                    if field in cls.__cute_annotations__ and not isinstance(value, Nothing | msgspec.UnsetType)
                     else value
                     for field, value in update.to_dict().items()
                 },
@@ -135,15 +152,17 @@ else:
         def _to_dict(self, dct_name, exclude_fields, full):
             if dct_name not in self.__dict__:
                 self.__dict__[dct_name] = (
-                    msgspec.structs.asdict(self)
+                    struct_as_dict(self)
                     if not full
                     else encoder.to_builtins(
                         {
                             k: field.to_dict(exclude_fields=exclude_fields)
-                            if isinstance(field := _get_value(getattr(self, k)), BaseCute)
+                            if isinstance(field, BaseCute)
                             else field
                             for k in self.__struct_fields__
                             if k not in exclude_fields
+                            and not isinstance(field := _validate_value(getattr(self, k)), msgspec.UnsetType)
+                            and not is_none(field)
                         },
                         order="deterministic",
                     )
@@ -154,105 +173,12 @@ else:
 
             return {key: value for key, value in self.__dict__[dct_name].items() if key not in exclude_fields}
 
-        def to_dict(self, *, exclude_fields=None):
+        def to_dict(self, *, exclude_fields=None, full=False):
             exclude_fields = exclude_fields or set()
-            return self._to_dict("model_as_dict", exclude_fields={"api"} | exclude_fields, full=False)
+            return self._to_dict("model_as_dict", exclude_fields={"api"} | exclude_fields, full=full)
 
         def to_full_dict(self, *, exclude_fields=None):
-            exclude_fields = exclude_fields or set()
-            return self._to_dict("model_as_full_dict", exclude_fields={"api"} | exclude_fields, full=True)
-
-
-def compose_method_params(
-    params: dict[str, typing.Any],
-    update: Cute,
-    *,
-    default_params: set[str | tuple[str, str]] | None = None,
-    validators: dict[str, typing.Callable[[Cute], bool]] | None = None,
-) -> dict[str, typing.Any]:
-    """Compose method `params` from `update` by `default_params` and `validators`.
-
-    :param params: Method params.
-    :param update: Update object.
-    :param default_params: Default params. \
-    (`str`) - Attribute name to be get from `update` if param is undefined. \
-    (`tuple[str, str]`): tuple[0] - Parameter name to be set in `params`, \
-    tuple[1] - attribute name to be get from `update`.
-    :param validators: Validators mapping (`str, Callable`), key - `Parameter name` \
-    for which the validator will be applied, value - `Validator`, if returned `True` \
-    parameter will be set, otherwise will not.
-    :return: Composed params.
-    """
-
-    default_params = default_params or set()
-    validators = validators or {}
-
-    for param in default_params:
-        param_name = param if isinstance(param, str) else param[0]
-        if param_name not in params:
-            if param_name in validators and not validators[param_name](update):
-                continue
-            params[param_name] = getattr(update, param if isinstance(param, str) else param[1])
-
-    return params
-
-
-def shortcut(
-    method_name: str,
-    *,
-    executor: Executor[Cute] | None = None,
-    custom_params: set[str] | None = None,
-):
-    def wrapper(func: F) -> F:
-        @wraps(func)
-        async def inner(
-            self: Cute,
-            *args: typing.Any,
-            **kwargs: typing.Any,
-        ) -> typing.Any:
-            if executor is None:
-                return await func(self, *args, **kwargs)
-
-            if not hasattr(func, "_signature_params"):
-                setattr(
-                    func,
-                    "_signature_params",
-                    {k: p for k, p in inspect.signature(func).parameters.items() if k != "self"},
-                )
-
-            signature_params: dict[str, inspect.Parameter] = getattr(func, "_signature_params")
-            params: dict[str, typing.Any] = {}
-            index = 0
-
-            for k, p in signature_params.items():
-                if p.kind in (p.POSITIONAL_OR_KEYWORD, p.POSITIONAL_ONLY) and len(args) > index:
-                    params[k] = args[index]
-                    index += 1
-                    continue
-
-                if p.kind in (p.VAR_KEYWORD, p.VAR_POSITIONAL):
-                    params[k] = kwargs.copy() if p.kind is p.VAR_KEYWORD else args[index:]
-                    continue
-
-                params[k] = kwargs.pop(k, p.default) if p.default is not p.empty else kwargs.pop(k)
-
-            return await executor(self, method_name, get_params(params))
-
-        inner.__shortcut__ = Shortcut(  # type: ignore
-            method_name=method_name,
-            executor=executor,
-            custom_params=custom_params or set(),
-        )
-        return inner  # type: ignore
-
-    return wrapper
-
-
-@dataclasses.dataclass(slots=True, frozen=True)
-class Shortcut:
-    method_name: str
-    executor: Executor | None = dataclasses.field(default=None, kw_only=True)
-    custom_params: set[str] = dataclasses.field(default_factory=lambda: set(), kw_only=True)
+            return self.to_dict(exclude_fields=exclude_fields, full=True)
 
 
-__all__ = ("BaseCute", "Shortcut", "compose_method_params", "shortcut")
+__all__ = ("BaseCute", "compose_method_params")

telegrinder/bot/cute_types/callback_query.py

@@ -1,3 +1,4 @@
+import base64
 import typing
 from contextlib import suppress
 
@@ -5,10 +6,11 @@ import msgspec
 from fntypes.co import Nothing, Result, Some, Variative, unwrapping
 
 from telegrinder.api import API, APIError
-from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params
 from telegrinder.bot.cute_types.message import MediaType, MessageCute, ReplyMarkup, execute_method_edit
-from telegrinder.model import From, field, get_params
+from telegrinder.model import UNSET, From, field, get_params
 from telegrinder.msgspec_utils import Option, decoder
+from telegrinder.tools.magic import shortcut
 from telegrinder.types.objects import *
 
 
@@ -16,7 +18,7 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
     api: API
 
     message: Option[Variative[MessageCute, InaccessibleMessage]] = field(
-        default=Nothing(),
+        default=UNSET,
         converter=From[MessageCute | InaccessibleMessage | None],
     )
     """Optional. Message sent by the bot with the callback button that originated
@@ -29,16 +31,16 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
     @property
     def chat_id(self) -> Option[int]:
         """Optional. Message from chat ID. This will be present if the message is sent
-        by the bot with the callback button that originated the query."""
-
+        by the bot with the callback button that originated the query.
+        """
         return self.message.map(lambda m: m.v.chat.id)
 
     @property
     def is_topic_message(self) -> Option[bool]:
         """Optional. True, if the message is a topic message with a name,
         color and icon. This will be present if the message is sent
-        by the bot with the callback button that originated the query."""
-
+        by the bot with the callback button that originated the query.
+        """
         return self.message.map(
             lambda m: m.only().map(lambda m: m.is_topic_message.unwrap_or(False)).unwrap_or(False),
         )
@@ -48,8 +50,8 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
     def message_thread_id(self) -> Option[int]:
         """Optional. Unique identifier of the target message thread (for forum supergroups only).
         This will be present if the message is sent
-        by the bot with the callback button that originated the query."""
-
+        by the bot with the callback button that originated the query.
+        """
         return self.message.unwrap().only().map(lambda m: m.message_thread_id.unwrap()).cast(Some, Nothing)
 
     @property
@@ -57,7 +59,6 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         """Optional. Unique message identifier inside this chat. This will be present
         if the message is sent by the bot with the callback button that originated the query.
         """
-
         return self.message.map(lambda m: m.v.message_id)
 
     @property
@@ -65,26 +66,43 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         """Optional. Chat the callback query originated from. This will be present
         if the message is sent by the bot with the callback button that originated the query.
         """
-
         return self.message.map(lambda m: m.v.chat)
 
-    def decode_callback_data(self) -> Option[dict[str, typing.Any]]:
+    @typing.overload
+    def decode_data(self) -> Option[dict[str, typing.Any]]: ...
+
+    @typing.overload
+    def decode_data[T](self, *, to: type[T]) -> Option[T]: ...
+
+    def decode_data[T](self, *, to: type[T] = dict[str, typing.Any]) -> Option[T]:
+        if not self.data:
+            return Nothing()
+
         if "cached_callback_data" in self.__dict__:
             return self.__dict__["cached_callback_data"]
+
         data = Nothing()
         with suppress(msgspec.ValidationError, msgspec.DecodeError):
-            data = Some(decoder.decode(self.data.unwrap()))
+            data = (
+                Some(decoder.decode(self.data.unwrap(), type=to))
+                if not issubclass(to, str | bytes)
+                else self.data
+                if issubclass(to, str)
+                else Some(base64.urlsafe_b64decode(self.data.unwrap()))
+            )
+
         self.__dict__["cached_callback_data"] = data
-        return data
+        return data  # type: ignore
 
     @shortcut("answer_callback_query", custom_params={"callback_query_id"})
     async def answer(
         self,
         text: str | None = None,
+        *,
+        cache_time: int | None = None,
         callback_query_id: str | None = None,
         show_alert: bool | None = None,
         url: str | None = None,
-        cache_time: int | None = None,
         **other: typing.Any,
     ) -> Result[bool, APIError]:
         """Shortcut `API.answer_callback_query()`, see the [documentation](https://core.telegram.org/bots/api#answercallbackquery)
@@ -92,16 +110,12 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         Use this method to send answers to callback queries sent from inline keyboards.
         The answer will be displayed to the user as a notification at the top of the
         chat screen or as an alert. On success, True is returned."""
-
-        params = compose_method_params(
-            get_params(locals()), self, default_params={("callback_query_id", "id")}
-        )
+        params = compose_method_params(get_params(locals()), self, default_params={("callback_query_id", "id")})
         return await self.ctx_api.answer_callback_query(**params)
 
     @shortcut(
         "copy_message",
         custom_params={
-            "reply_parameters",
             "message_thread_id",
             "chat_id",
             "message_id",
@@ -112,17 +126,20 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
     async def copy(
         self,
         chat_id: int | str | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
+        caption: str | None = None,
+        caption_entities: list[MessageEntity] | None = None,
+        disable_notification: bool | None = None,
         from_chat_id: int | str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
-        caption: str | None = None,
         parse_mode: str | None = None,
-        caption_entities: list[MessageEntity] | None = None,
-        disable_notification: bool | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
         reply_markup: ReplyMarkup | None = None,
+        reply_parameters: ReplyParameters | None = None,
         show_caption_above_media: bool | None = None,
+        video_start_timestamp: int | None = None,
         **other: typing.Any,
     ) -> Result[MessageId, APIError]:
         """Shortcut `API.copy_message()`, see the [documentation](https://core.telegram.org/bots/api#copymessage)
@@ -133,12 +150,12 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         field correct_option_id is known to the bot. The method is analogous to
         the method forwardMessage, but the copied message doesn't have a link to
         the original message. Returns the MessageId of the sent message on success."""
-
         return await MessageCute.copy(self, **get_params(locals()))  # type: ignore
 
     @shortcut("delete_message", custom_params={"message_thread_id", "chat_id", "message_id"})
     async def delete(
         self,
+        *,
         chat_id: int | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
@@ -157,26 +174,26 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         of a group, it can delete any message there. - If the bot has can_delete_messages
         permission in a supergroup or a channel, it can delete any message there.
         Returns True on success."""
-
         return await MessageCute.delete(self, **get_params(locals()))  # type: ignore
 
     @shortcut(
         "edit_message_text",
         executor=execute_method_edit,
-        custom_params={"message_thread_id", "link_preview_options"},
+        custom_params={"message_thread_id"},
     )
     async def edit_text(
         self,
         text: str,
-        inline_message_id: str | None = None,
+        *,
+        business_connection_id: str | None = None,
         chat_id: int | str | None = None,
+        entities: list[MessageEntity] | None = None,
+        inline_message_id: str | None = None,
+        link_preview_options: LinkPreviewOptions | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
         parse_mode: str | None = None,
-        entities: list[MessageEntity] | None = None,
-        link_preview_options: LinkPreviewOptions | dict[str, typing.Any] | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
-        business_connection_id: str | None = None,
         **other: typing.Any,
     ) -> Result[Variative[MessageCute, bool], APIError]:
         """Shortcut `API.edit_message_text()`, see the [documentation](https://core.telegram.org/bots/api#editmessagetext)
@@ -202,7 +219,6 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         :param link_preview_options: Link preview generation options for the message.
 
         :param reply_markup: A JSON-serialized object for an inline keyboard."""
-
         ...
 
     @shortcut(
@@ -212,18 +228,18 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
     )
     async def edit_live_location(
         self,
-        latitude: float,
+        *,
         longitude: float,
-        inline_message_id: str | None = None,
-        message_thread_id: int | None = None,
+        business_connection_id: str | None = None,
         chat_id: int | str | None = None,
-        message_id: int | None = None,
-        horizontal_accuracy: float | None = None,
         heading: int | None = None,
+        horizontal_accuracy: float | None = None,
+        inline_message_id: str | None = None,
+        live_period: int | None = None,
+        message_id: int | None = None,
+        message_thread_id: int | None = None,
         proximity_alert_radius: int | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
-        business_connection_id: str | None = None,
-        live_period: int | None = None,
         **other: typing.Any,
     ) -> Result[Variative[MessageCute, bool], APIError]:
         """Shortcut `API.edit_message_live_location()`, see the [documentation](https://core.telegram.org/bots/api#editmessagelivelocation)
@@ -251,7 +267,6 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         :param proximity_alert_radius: The maximum distance for proximity alerts about approaching another chatmember, in meters. Must be between 1 and 100000 if specified.
 
         :param reply_markup: A JSON-serialized object for a new inline keyboard."""
-
         ...
 
     @shortcut(
@@ -262,14 +277,15 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
     async def edit_caption(
         self,
         caption: str | None = None,
+        *,
+        business_connection_id: str | None = None,
+        caption_entities: list[MessageEntity] | None = None,
         chat_id: int | str | None = None,
+        inline_message_id: str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
-        inline_message_id: str | None = None,
         parse_mode: str | None = None,
-        caption_entities: list[MessageEntity] | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
-        business_connection_id: str | None = None,
         show_caption_above_media: bool | None = None,
         **other: typing.Any,
     ) -> Result[Variative[MessageCute, bool], APIError]:
@@ -295,7 +311,6 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         :param show_caption_above_media: Pass True, if the caption must be shown above the message media. Supportedonly for animation, photo and video messages.
 
         :param reply_markup: A JSON-serialized object for an inline keyboard."""
-
         ...
 
     @shortcut(
@@ -312,29 +327,30 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
     async def edit_media(
         self,
         media: str | InputFile | InputMedia,
-        type: MediaType | None = None,
+        *,
+        business_connection_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
-        inline_message_id: str | None = None,
         chat_id: int | str | None = None,
+        inline_message_id: str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
-        business_connection_id: str | None = None,
+        type: MediaType | None = None,
         **other: typing.Any,
     ) -> Result[Variative[MessageCute, bool], APIError]:
         """Shortcut `API.edit_message_media()`, see the [documentation](https://core.telegram.org/bots/api#editmessagemedia)
 
-        Use this method to edit animation, audio, document, photo, or video messages.
-        If a message is part of a message album, then it can be edited only to an audio
-        for audio albums, only to a document for document albums and to a photo or
-        a video otherwise. When an inline message is edited, a new file can't be uploaded;
-        use a previously uploaded file via its file_id or specify a URL. On success,
-        if the edited message is not an inline message, the edited Message is returned,
-        otherwise True is returned. Note that business messages that were not sent
-        by the bot and do not contain an inline keyboard can only be edited within
-        48 hours from the time they were sent.
+        Use this method to edit animation, audio, document, photo, or video messages,
+        or to add media to text messages. If a message is part of a message album, then
+        it can be edited only to an audio for audio albums, only to a document for document
+        albums and to a photo or a video otherwise. When an inline message is edited,
+        a new file can't be uploaded; use a previously uploaded file via its file_id
+        or specify a URL. On success, if the edited message is not an inline message,
+        the edited Message is returned, otherwise True is returned. Note that business
+        messages that were not sent by the bot and do not contain an inline keyboard
+        can only be edited within 48 hours from the time they were sent.
         :param business_connection_id: Unique identifier of the business connection on behalf of which the messageto be edited was sent.
 
         :param chat_id: Required if inline_message_id is not specified. Unique identifier forthe target chat or username of the target channel (in the format @channelusername).
@@ -345,7 +361,6 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         :param media: A JSON-serialized object for a new media content of the message.
 
         :param reply_markup: A JSON-serialized object for a new inline keyboard."""
-
         return await MessageCute.edit_media(self, **get_params(locals()))  # type: ignore
 
     @shortcut(
@@ -355,12 +370,13 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
     )
     async def edit_reply_markup(
         self,
+        *,
+        business_connection_id: str | None = None,
+        chat_id: int | str | None = None,
         inline_message_id: str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
-        chat_id: int | str | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
-        business_connection_id: str | None = None,
         **other: typing.Any,
     ) -> Result[Variative[MessageCute, bool], APIError]:
         """Shortcut `API.edit_message_reply_markup()`, see the [documentation](https://core.telegram.org/bots/api#editmessagereplymarkup)
@@ -378,7 +394,6 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
         :param inline_message_id: Required if chat_id and message_id are not specified. Identifier of theinline message.
 
         :param reply_markup: A JSON-serialized object for an inline keyboard."""
-
         ...
 
 

telegrinder/bot/cute_types/chat_join_request.py

@@ -3,8 +3,9 @@ import typing
 from fntypes.result import Result
 
 from telegrinder.api.api import API, APIError
-from telegrinder.bot.cute_types.base import BaseCute, shortcut
+from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.cute_types.chat_member_updated import ChatMemberShortcuts, chat_member_interaction
+from telegrinder.tools.magic import shortcut
 from telegrinder.types.objects import *
 
 
@@ -26,6 +27,7 @@ class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMember
     )
     async def approve(
         self,
+        *,
         chat_id: int | str | None = None,
         user_id: int | None = None,
         **other: typing.Any,
@@ -35,7 +37,6 @@ class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMember
         Use this method to approve a chat join request. The bot must be an administrator
         in the chat for this to work and must have the can_invite_users administrator
         right. Returns True on success."""
-
         ...
 
     @shortcut(
@@ -45,6 +46,7 @@ class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMember
     )
     async def decline(
         self,
+        *,
         chat_id: int | str | None = None,
         user_id: int | None = None,
         **other: typing.Any,
@@ -54,7 +56,6 @@ class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMember
         Use this method to decline a chat join request. The bot must be an administrator
         in the chat for this to work and must have the can_invite_users administrator
         right. Returns True on success."""
-
         ...