telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev159__py3-none-any.whl

telegrinder/bot/cute_types/base.py

@@ -0,0 +1,138 @@
+import dataclasses
+import inspect
+import typing
+from functools import wraps
+
+from fntypes.result import Result
+
+from telegrinder.api import ABCAPI, API
+from telegrinder.model import Model, get_params
+
+F = typing.TypeVar("F", bound=typing.Callable[..., typing.Any])
+CuteT = typing.TypeVar("CuteT", bound="BaseCute")
+UpdateT = typing.TypeVar("UpdateT", bound=Model)
+
+Executor: typing.TypeAlias = typing.Callable[
+    [CuteT, str, dict[str, typing.Any]],
+    typing.Awaitable[Result[typing.Any, typing.Any]],
+]
+
+if typing.TYPE_CHECKING:
+
+    class BaseCute(Model, typing.Generic[UpdateT]):
+        api: ABCAPI
+
+        @classmethod
+        def from_update(cls, update: UpdateT, bound_api: ABCAPI) -> typing.Self:
+            ...
+
+        @property
+        def ctx_api(self) -> API:
+            ...
+
+else:
+
+    class BaseCute(typing.Generic[UpdateT]):
+        api: ABCAPI
+
+        @classmethod
+        def from_update(cls, update, bound_api):
+            return cls(**update.to_dict(), api=bound_api)
+
+        @property
+        def ctx_api(self):
+            assert isinstance(self.api, API)
+            return self.api
+
+        def to_dict(self, *, exclude_fields=None):
+            exclude_fields = exclude_fields or set()
+            return super().to_dict(exclude_fields={"api"} | exclude_fields)
+
+
+def compose_method_params(
+    params: dict[str, typing.Any],
+    update: CuteT,
+    *,
+    default_params: set[str | tuple[str, str]] | None = None,
+    validators: dict[str, typing.Callable[[CuteT], 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. \
+    type (`str`) - Attribute name to be taken from `update` if param undefined. \
+    type (`tuple[str, str]`) - tuple[0] Parameter name to be set in `params`, \
+    tuple[1] attribute name to be taken 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 be set.
+    :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
+
+
+# NOTE: implement parser on ast for methods decorated this decorator
+# to support updates to the schema Bot API.
+def shortcut(
+    method_name: str,
+    *,
+    executor: Executor[CuteT] | None = None,
+    custom_params: set[str] | None = None,
+):
+    def wrapper(func: F) -> F:
+        @wraps(func)
+        async def inner(self: CuteT, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+            if executor is None:
+                return await func(self, *args, **kwargs)
+            signature_params = {
+                k: p
+                for k, p in inspect.signature(func).parameters.items()
+                if k != "self"
+            }
+            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))
+
+        func.__repr__ = lambda _: f"<Shortcut {method_name!r}@{func!r}>"   
+        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
+class Shortcut:
+    method_name: str
+    _: dataclasses.KW_ONLY
+    executor: Executor | None = dataclasses.field(default=None)
+    custom_params: set[str] = dataclasses.field(default_factory=lambda: set())
+
+
+__all__ = ("BaseCute", "Shortcut", "compose_method_params", "shortcut")

telegrinder/bot/cute_types/callback_query.py

@@ -1,28 +1,471 @@
-from telegrinder.types import CallbackQuery, User
-from telegrinder.model import get_params
-from telegrinder.api import API, APIError
-from telegrinder.result import Result
 import typing
+from contextlib import suppress
+
+import msgspec
+from fntypes.co import Result, Some, Variative
+
+from telegrinder.api import ABCAPI, APIError
+from telegrinder.model import get_params
+from telegrinder.msgspec_utils import Nothing, Option, decoder
+from telegrinder.types import (
+    CallbackQuery,
+    InlineKeyboardMarkup,
+    InputFile,
+    InputMedia,
+    LinkPreviewOptions,
+    MessageEntity,
+    MessageId,
+    ReplyParameters,
+    User,
+)
 
+from .base import BaseCute, compose_method_params, shortcut
+from .message import MediaType, MessageCute, ReplyMarkup, execute_method_edit
 
-class CallbackQueryCute(CallbackQuery):
-    api: API
+
+class CallbackQueryCute(
+    BaseCute[CallbackQuery], CallbackQuery, kw_only=True, dict=True
+):
+    api: ABCAPI
 
     @property
     def from_user(self) -> User:
         return self.from_
+    
+    @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."""
 
+        return self.message.map(lambda m: m.v.chat.id)
+    
     @property
-    def ctx_api(self) -> API:
-        return self.api
+    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."""
+
+        return self.message.map(
+            lambda m: m.only().map(
+                lambda m: m.is_topic_message.unwrap_or(False)
+            ).unwrap_or(False)
+        )
+    
+    @property
+    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."""
+
+        return self.message.map(
+            lambda m: m.only().map(
+                lambda m: m.message_thread_id,
+            ).unwrap_or(Nothing)
+        ).unwrap_or(Nothing)
+
+    @property
+    def message_id(self) -> Option[int]:
+        """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)
+
+    def decode_callback_data(self, *, strict: bool = True) -> Option[dict[str, typing.Any]]:
+        if "cached_callback_data" in self.__dict__:
+            return self.__dict__["cached_callback_data"]
+        data = Nothing
+        with suppress(msgspec.ValidationError):
+            data = Some(decoder.decode(self.data.unwrap(), strict=strict))
+        self.__dict__["cached_callback_data"] = data
+        return data
 
+    @shortcut("answer_callback_query")
     async def answer(
         self,
-        text: typing.Optional[str] = None,
-        show_alert: typing.Optional[bool] = None,
-        url: typing.Optional[str] = None,
-        cache_time: typing.Optional[int] = None,
-        **other
+        text: str | Option[str] = Nothing,
+        callback_query_id: str | Option[str] = Nothing,
+        show_alert: bool | Option[bool] = Nothing,
+        url: str | Option[str] = Nothing,
+        cache_time: int | Option[int] = Nothing,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.answer_callback_query()`, see the [documentation](https://core.telegram.org/bots/api#answercallbackquery)
+
+        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.
+
+        :param callback_query_id: Unique identifier for the query to be answered.
+
+        :param text: Text of the notification. If not specified, nothing will be shown to the \
+        user, 0-200 characters.
+
+        :param show_alert: If True, an alert will be shown by the client instead of a notification at \
+        the top of the chat screen. Defaults to false.
+
+        :param url: URL that will be opened by the user's client. If you have created a Game and \
+        accepted the conditions via @BotFather, specify the URL that opens your \
+        game - note that this will only work if the query comes from a callback_game \
+        button. Otherwise, you may use links like t.me/your_bot?start=XXXX that \
+        open your bot with a parameter.
+
+        :param cache_time: The maximum amount of time in seconds that the result of the callback query \
+        may be cached client-side. Telegram apps will support caching starting \
+        in version 3.14. Defaults to 0."""
+
+        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"},
+    )
+    async def copy(
+        self,
+        chat_id: int | str | Option[int | str] = Nothing,
+        from_chat_id: int | str | Option[int | str] = Nothing,
+        message_id: int | Option[int] = Nothing,
+        message_thread_id: Option[int] | int = Nothing,
+        caption: Option[str] | str = Nothing,
+        parse_mode: Option[str] | str = Nothing,
+        caption_entities: Option[list[MessageEntity]] | list[MessageEntity] = Nothing,
+        disable_notification: Option[bool] | bool = Nothing,
+        protect_content: Option[bool] | bool = Nothing,
+        reply_parameters: Option[ReplyParameters | dict[str, typing.Any]]
+        | ReplyParameters
+        | dict[str, typing.Any] = Nothing,
+        reply_markup: Option[ReplyMarkup] | ReplyMarkup = Nothing,
+        **other: typing.Any,
+    ) -> Result[MessageId, APIError]:
+        """Shortcut `API.copy_message()`, see the [documentation](https://core.telegram.org/bots/api#copymessage)
+
+        Use this method to copy messages of any kind. Service messages, giveaway 
+        messages, giveaway winners messages, and invoice messages can't be copied. 
+        A quiz poll can be copied only if the value of the 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.
+
+        :param chat_id: Unique identifier for the target chat or username of the target channel \
+        (in the format @channelusername).
+
+        :param message_thread_id: Unique identifier for the target message thread (topic) of the forum; for \
+        forum supergroups only.
+
+        :param from_chat_id: Unique identifier for the chat where the original message was sent (or channel \
+        username in the format @channelusername).
+
+        :param message_id: Message identifier in the chat specified in from_chat_id.
+
+        :param caption: New caption for media, 0-1024 characters after entities parsing. If not \
+        specified, the original caption is kept.
+
+        :param parse_mode: Mode for parsing entities in the new caption. See formatting options for \
+        more details.
+
+        :param caption_entities: A JSON-serialized list of special entities that appear in the new caption, \
+        which can be specified instead of parse_mode.
+
+        :param disable_notification: Sends the message silently. Users will receive a notification with no sound. \
+
+        :param protect_content: Protects the contents of the sent message from forwarding and saving.
+
+        :param reply_parameters: Description of the message to reply to.
+
+        :param reply_markup: Additional interface options. A JSON-serialized object for an inline \
+        keyboard, custom reply keyboard, instructions to remove reply keyboard \
+        or to force a reply from the user.
+        """
+
+        return await MessageCute.copy(self, **get_params(locals()))  # type: ignore
+
+    @shortcut("delete_message", custom_params={"message_thread_id"})
+    async def delete(
+        self,
+        chat_id: int | Option[int] = Nothing,
+        message_id: int | Option[int] = Nothing,
+        message_thread_id: int | Option[int] = Nothing,
+        **other: typing.Any,
     ) -> Result[bool, APIError]:
-        params = get_params(locals())
-        return await self.ctx_api.answer_callback_query(self.id, **params)
+        """Shortcut `API.delete_message()`, see the [documentation](https://core.telegram.org/bots/api#deletemessage)
+
+        Use this method to delete a message, including service messages, with the 
+        following limitations: - A message can only be deleted if it was sent less 
+        than 48 hours ago. - Service messages about a supergroup, channel, or forum 
+        topic creation can't be deleted. - A dice message in a private chat can only 
+        be deleted if it was sent more than 24 hours ago. - Bots can delete outgoing 
+        messages in private chats, groups, and supergroups. - Bots can delete incoming 
+        messages in private chats. - Bots granted can_post_messages permissions 
+        can delete outgoing messages in channels. - If the bot is an administrator 
+        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.
+
+        :param chat_id: Unique identifier for the target chat or username of the target channel \
+        (in the format @channelusername).
+
+        :param message_id: Identifier of the message to delete.
+
+        :param message_thread_id: Unique identifier for the target message thread (topic) of the forum; for \
+        forum supergroups only."""
+
+        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"}
+    )
+    async def edit_text(
+        self,
+        text: str | Option[str],
+        inline_message_id: int | Option[int] = Nothing,
+        chat_id: Option[int | str] | int | str = Nothing,
+        message_id: Option[int] | int = Nothing,
+        message_thread_id: int | Option[int] = Nothing,
+        parse_mode: str | Option[str] = Nothing,
+        entities: list[MessageEntity] | Option[list[MessageEntity]] = Nothing,
+        link_preview_options: Option[LinkPreviewOptions | dict[str, typing.Any]]
+        | LinkPreviewOptions
+        | dict[str, typing.Any] = Nothing,
+        reply_markup: InlineKeyboardMarkup | Option[InlineKeyboardMarkup] = Nothing,
+        **other: typing.Any,
+    ) -> Result[Variative[MessageCute, bool], APIError]:
+        """Shortcut `API.edit_message_text()`, see the [documentation](https://core.telegram.org/bots/api#editmessagetext)
+
+        Use this method to edit text and game messages. On success, if the edited 
+        message is not an inline message, the edited Message is returned, otherwise 
+        True is returned.
+
+        :param inline_message_id: Required if chat_id and message_id are not specified. Identifier of the \
+        inline message.
+
+        :param chat_id: Required if inline_message_id is not specified. Unique identifier for \
+        the target chat or username of the target channel (in the format @channelusername). \
+
+        :param message_id: Required if inline_message_id is not specified. Identifier of the message \
+        to edit.
+
+        :param message_thread_id: Unique identifier for the target message thread (topic) of the forum; for \
+        forum supergroups only.
+
+        :param text: New text of the message, 1-4096 characters after entities parsing.
+
+        :param parse_mode: Mode for parsing entities in the message text. See formatting options for \
+        more details.
+
+        :param entities: A JSON-serialized list of special entities that appear in message text, \
+        which can be specified instead of parse_mode.
+
+        :param link_preview_options: Link preview generation options for the message.
+
+        :param reply_markup: A JSON-serialized object for an inline keyboard."""
+
+        ...
+    
+    @shortcut(
+        "edit_message_live_location",
+        executor=execute_method_edit,
+        custom_params={"message_thread_id"},
+    )
+    async def edit_live_location(
+        self,
+        latitude: float,
+        longitude: float,
+        inline_message_id: Option[str] | str = Nothing,
+        message_thread_id: int | Option[int] = Nothing,
+        chat_id: Option[int | str] | int | str = Nothing,
+        message_id: Option[int] | int = Nothing,
+        horizontal_accuracy: Option[float] | float = Nothing,
+        heading: Option[int] | int = Nothing,
+        proximity_alert_radius: Option[int] | int = Nothing,
+        reply_markup: Option[InlineKeyboardMarkup] | InlineKeyboardMarkup = Nothing,
+        **other: typing.Any,
+    ) -> Result[Variative[MessageCute, bool], APIError]:
+        """Shortcut `API.edit_message_live_location()`, see the [documentation](https://core.telegram.org/bots/api#editmessagelivelocation)
+
+        Use this method to edit live location messages. A location can be edited 
+        until its live_period expires or editing is explicitly disabled by a call 
+        to stopMessageLiveLocation. On success, if the edited message is not an 
+        inline message, the edited Message is returned, otherwise True is returned.
+
+        :param inline_message_id: Required if chat_id and message_id are not specified. Identifier of the \
+        inline message.
+
+        :param chat_id: Required if inline_message_id is not specified. Unique identifier for \
+        the target chat or username of the target channel (in the format @channelusername). \
+
+        :param message_id: Required if inline_message_id is not specified. Identifier of the message \
+        to edit.
+
+        :param message_thread_id: Unique identifier for the target message thread (topic) of the forum; for \
+        forum supergroups only.
+
+        :param latitude: Latitude of new location.
+
+        :param longitude: Longitude of new location.
+
+        :param horizontal_accuracy: The radius of uncertainty for the location, measured in meters; 0-1500. \
+
+        :param heading: Direction in which the user is moving, in degrees. Must be between 1 and 360 \
+        if specified.
+
+        :param proximity_alert_radius: The maximum distance for proximity alerts about approaching another chat \
+        member, in meters. Must be between 1 and 100000 if specified.
+
+        :param reply_markup: A JSON-serialized object for a new inline keyboard."""
+
+        ...
+    
+    @shortcut(
+        "edit_message_caption",
+        executor=execute_method_edit,
+        custom_params={"message_thread_id"},
+    )
+    async def edit_caption(
+        self,
+        caption: Option[str] | str,
+        chat_id: Option[int | str] | int | str = Nothing,
+        message_id: Option[int] | int = Nothing,
+        message_thread_id: int | Option[int] = Nothing,
+        inline_message_id: Option[str] | str = Nothing,
+        parse_mode: Option[str] | str = Nothing,
+        caption_entities: Option[list[MessageEntity]] | list[MessageEntity] = Nothing,
+        reply_markup: Option[InlineKeyboardMarkup] | InlineKeyboardMarkup = Nothing,
+        **other: typing.Any,
+    ) -> Result[Variative[MessageCute, bool], APIError]:
+        """Shortcut `API.edit_message_caption()`, see the [documentation](https://core.telegram.org/bots/api#editmessagecaption)
+
+        Use this method to edit captions of messages. On success, if the edited message 
+        is not an inline message, the edited Message is returned, otherwise True 
+        is returned.
+
+        :param chat_id: Required if inline_message_id is not specified. Unique identifier for \
+        the target chat or username of the target channel (in the format @channelusername). \
+
+        :param message_id: Required if inline_message_id is not specified. Identifier of the message \
+        to edit.
+
+        :param inline_message_id: Required if chat_id and message_id are not specified. Identifier of the \
+        inline message.
+
+        :param message_thread_id: Unique identifier for the target message thread (topic) of the forum; for \
+        forum supergroups only.
+
+        :param caption: New caption of the message, 0-1024 characters after entities parsing. \
+
+        :param parse_mode: Mode for parsing entities in the message caption. See formatting options \
+        for more details.
+
+        :param caption_entities: A JSON-serialized list of special entities that appear in the caption, \
+        which can be specified instead of parse_mode.
+
+        :param reply_markup: A JSON-serialized object for an inline keyboard."""
+
+        ...
+
+    @shortcut(
+        "edit_message_media",
+        custom_params={
+            "media",
+            "type",
+            "message_thread_id",
+            "caption",
+            "parse_mode",
+            "caption_entities",
+        },
+    )
+    async def edit_media(
+        self,
+        media: str | InputFile | InputMedia,
+        type: MediaType | Option[MediaType] = Nothing,
+        caption: Option[str] | str = Nothing,
+        parse_mode: Option[str] | str = Nothing,
+        caption_entities: Option[list[MessageEntity]] | list[MessageEntity] = Nothing,
+        inline_message_id: Option[str] | str = Nothing,
+        chat_id: Option[int | str] | int | str = Nothing,
+        message_id: Option[int] | int = Nothing,
+        message_thread_id: Option[int] | int = Nothing,
+        reply_markup: Option[InlineKeyboardMarkup] | InlineKeyboardMarkup = Nothing,
+        **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.
+
+        :param chat_id: Required if inline_message_id is not specified. Unique identifier for \
+        the target chat or username of the target channel (in the format @channelusername). \
+
+        :param message_id: Required if inline_message_id is not specified. Identifier of the message \
+        to edit.
+
+        :param inline_message_id: Required if chat_id and message_id are not specified. Identifier of the \
+        inline message.
+
+        :param message_thread_id: Unique identifier for the target message thread (topic) of the forum; for \
+        forum supergroups only.
+
+        :param media: A JSON-serialized object for a new media content of the message.
+
+        :param caption: Audio caption, 0-1024 characters after entities parsing.
+
+        :param parse_mode: Mode for parsing entities in the audio caption. See formatting options \
+        for more details.
+
+        :param caption_entities: A JSON-serialized list of special entities that appear in the caption, \
+        which can be specified instead of parse_mode.
+        
+        :param type: Required if media is not an `str | InputMedia` object. Type of the media, \
+        must be one of `photo`, `video`, `animation`, `audio`, `document`.
+
+        :param reply_markup: A JSON-serialized object for a new inline keyboard."""
+
+        return await MessageCute.edit_media(self, **get_params(locals()))  # type: ignore
+
+    @shortcut(
+        "edit_message_reply_markup",
+        executor=execute_method_edit,
+        custom_params={"message_thread_id"},
+    )
+    async def edit_reply_markup(
+        self,
+        inline_message_id: Option[str] | str = Nothing,
+        message_id: Option[int] | int = Nothing,
+        message_thread_id: Option[int] | int = Nothing,
+        chat_id: Option[int | str] | int | str = Nothing,
+        reply_markup: Option[InlineKeyboardMarkup] | InlineKeyboardMarkup = Nothing,
+        **other: typing.Any,
+    ) -> Result[Variative[MessageCute, bool], APIError]:
+        """Shortcut `API.edit_message_reply_markup()`, see the [documentation](https://core.telegram.org/bots/api#editmessagereplymarkup)
+
+        Use this method to edit only the reply markup of messages. On success, if 
+        the edited message is not an inline message, the edited Message is returned, 
+        otherwise True is returned.
+
+        :param chat_id: Required if inline_message_id is not specified. Unique identifier for \
+        the target chat or username of the target channel (in the format @channelusername). \
+
+        :param message_id: Required if inline_message_id is not specified. Identifier of the message \
+        to edit.
+
+        :param message_thread_id: Unique identifier for the target message thread (topic) of the forum; for \
+        forum supergroups only.
+
+        :param inline_message_id: Required if chat_id and message_id are not specified. Identifier of the \
+        inline message.
+
+        :param reply_markup: A JSON-serialized object for an inline keyboard."""
+
+        ...
+
+
+__all__ = ("CallbackQueryCute",)

telegrinder/bot/cute_types/inline_query.py

@@ -1,35 +1,41 @@
-from telegrinder.types import InlineQuery, User
-from telegrinder.api import API, APIError
-from telegrinder.result import Result
 import typing
 
+from fntypes.result import Result
 
-class InlineQueryCute(InlineQuery):
-    api: API
+from telegrinder.api import ABCAPI, APIError
+from telegrinder.model import get_params
+from telegrinder.msgspec_utils import Nothing, Option
+from telegrinder.types import (
+    InlineQuery,
+    InlineQueryResult,
+    InlineQueryResultsButton,
+    User,
+)
+
+from .base import BaseCute
+
+
+class InlineQueryCute(BaseCute[InlineQuery], InlineQuery, kw_only=True):
+    api: ABCAPI
 
     @property
     def from_user(self) -> User:
         return self.from_
 
-    @property
-    def ctx_api(self) -> API:
-        return self.api
-
     async def answer(
         self,
-        results: typing.Optional[list] = None,
-        cache_time: typing.Optional[int] = None,
-        is_personal: typing.Optional[bool] = None,
-        next_offset: typing.Optional[str] = None,
-        switch_pm_text: typing.Optional[str] = None,
-        switch_pm_parameter: typing.Optional[str] = None,
+        results: InlineQueryResult | list[InlineQueryResult],
+        inline_query_id: str | Option[str] = Nothing,
+        cache_time: int | Option[int] = Nothing,
+        is_personal: bool | Option[bool] = Nothing,
+        next_offset: str | Option[str] = Nothing,
+        button: Option[InlineQueryResultsButton] | InlineQueryResultsButton = Nothing,
+        **other: typing.Any,
     ) -> Result[bool, APIError]:
-        return await self.ctx_api.answer_inline_query(
-            self.id,
-            results=results,
-            cache_time=cache_time,
-            is_personal=is_personal,
-            next_offset=next_offset,
-            switch_pm_text=switch_pm_text,
-            switch_pm_parameter=switch_pm_parameter,
-        )
+        params = get_params(locals())
+        params["results"] = [results] if not isinstance(results, list) else results
+        params.setdefault("inline_query_id", self.id)
+        return await self.ctx_api.answer_inline_query(**params)
+
+
+__all__ = ("InlineQueryCute",)