telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/bot/cute_types/callback_query.py

@@ -0,0 +1,248 @@
+import base64
+import typing
+from contextlib import suppress
+from datetime import timedelta
+
+import msgspec
+from kungfu.library import Nothing, Result, Some, Sum, unwrapping
+from kungfu.library.monad.option import NOTHING
+
+from telegrinder.api.api import APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
+from telegrinder.bot.cute_types.message import (
+    MessageCute,
+    MessageEditShortcuts,
+    ReplyMarkup,
+    execute_method_edit,
+)
+from telegrinder.model import UNSET, From, field
+from telegrinder.msgspec_utils import Option, decoder
+from telegrinder.types.methods_utils import get_params
+from telegrinder.types.objects import *
+
+CACHED_CALLBACK_DATA_KEY: typing.Final = "cached_callback_data"
+
+
+class CallbackQueryCute(BaseCute[CallbackQuery], MessageEditShortcuts, CallbackQuery, kw_only=True):
+    message: Option[Sum[MessageCute, InaccessibleMessage]] = field(
+        default=UNSET,
+        converter=From[MessageCute | InaccessibleMessage | None],
+    )
+    """Optional. Message sent by the bot with the callback button that originated
+    the query."""
+
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+    @property
+    @unwrapping
+    def message_cute(self) -> Option[MessageCute]:
+        return self.message.unwrap().only().cast(Some, Nothing)
+
+    @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 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
+    @unwrapping
+    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.unwrap().only().map(lambda m: m.message_thread_id.unwrap()).cast(Some, 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)
+
+    @property
+    def chat(self) -> Option[Chat]:
+        """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)
+
+    @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
+
+        keys = typing.cast(
+            "dict[type[typing.Any], typing.Any]",
+            self.__dict__.setdefault(CACHED_CALLBACK_DATA_KEY, {}),  # type: ignore
+        )
+        if to in keys:
+            return keys[to]
+
+        data = NOTHING
+        orig_to = typing.get_origin(to) or to
+
+        with suppress(msgspec.ValidationError, msgspec.DecodeError):
+            data = (
+                Some(decoder.decode(self.data.unwrap(), type=to))
+                if not issubclass(orig_to, str | bytes)
+                else self.data
+                if issubclass(orig_to, str)
+                else Some(base64.urlsafe_b64decode(self.data.unwrap()))
+            )
+
+        keys[to] = data
+        return data  # type: ignore
+
+    @shortcut("answer_callback_query", custom_params={"callback_query_id"})
+    async def answer(
+        self,
+        text: str | None = None,
+        *,
+        cache_time: timedelta | int | None = None,
+        callback_query_id: str | None = None,
+        show_alert: bool | None = None,
+        url: str | None = None,
+        **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."""
+        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={
+            "message_thread_id",
+            "chat_id",
+            "message_id",
+            "from_chat_id",
+            "reply_markup",
+        },
+    )
+    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,
+        direct_messages_topic_id: int | None = None,
+        disable_notification: bool | None = None,
+        from_chat_id: int | str | None = None,
+        message_effect_id: str | None = None,
+        message_id: int | None = None,
+        message_thread_id: str | None = None,
+        parse_mode: str | None = None,
+        protect_content: bool | None = None,
+        reply_markup: ReplyMarkup | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        show_caption_above_media: bool | None = None,
+        suggested_post_parameters: SuggestedPostParameters | None = None,
+        video_start_timestamp: timedelta | int | None = None,
+        **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, paid media
+        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."""
+        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: str | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """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
+        administrator right in a supergroup or a channel, it can delete any message
+        there. - If the bot has can_manage_direct_messages administrator right
+        in a channel, it can delete any message in the corresponding direct messages
+        chat. 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"},
+    )
+    async def edit_text(
+        self,
+        text: str,
+        *,
+        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: str | None = None,
+        parse_mode: str | None = None,
+        reply_markup: InlineKeyboardMarkup | None = None,
+        **other: typing.Any,
+    ) -> Result[Sum[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. 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).
+        :param message_id: Required if inline_message_id is not specified. Identifier of the messageto edit.
+
+        :param inline_message_id: Required if chat_id and message_id are not specified. Identifier of theinline message.
+
+        :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 formore 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."""
+        ...
+
+
+__all__ = ("CallbackQueryCute",)

telegrinder/bot/cute_types/chat_boost_removed.py

@@ -0,0 +1,9 @@
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.types.objects import ChatBoostRemoved
+
+
+class ChatBoostRemovedCute(BaseCute[ChatBoostRemoved], ChatBoostRemoved, kw_only=True):
+    pass
+
+
+__all__ = ("ChatBoostRemovedCute",)

telegrinder/bot/cute_types/chat_boost_updated.py

@@ -0,0 +1,9 @@
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.types.objects import ChatBoostUpdated
+
+
+class ChatBoostUpdatedCute(BaseCute[ChatBoostUpdated], ChatBoostUpdated, kw_only=True):
+    pass
+
+
+__all__ = ("ChatBoostUpdatedCute",)

telegrinder/bot/cute_types/chat_join_request.py

@@ -0,0 +1,59 @@
+import typing
+
+from kungfu.library.monad.result import Result
+
+from telegrinder.api.api import APIError
+from telegrinder.bot.cute_types.base import BaseCute, shortcut
+from telegrinder.bot.cute_types.chat_member_updated import ChatMemberShortcuts, chat_member_interaction
+from telegrinder.types.objects import *
+
+
+class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMemberShortcuts, kw_only=True):
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+    @property
+    def user_id(self) -> int:
+        return self.from_user.id
+
+    @shortcut(
+        "approve_chat_join_request",
+        executor=chat_member_interaction,
+        custom_params={"chat_id", "user_id"},
+    )
+    async def approve(
+        self,
+        *,
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.approve_chat_join_request()`, see the [documentation](https://core.telegram.org/bots/api#approvechatjoinrequest)
+
+        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(
+        "decline_chat_join_request",
+        executor=chat_member_interaction,
+        custom_params={"chat_id", "user_id"},
+    )
+    async def decline(
+        self,
+        *,
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.decline_chat_join_request()`, see the [documentation](https://core.telegram.org/bots/api#declinechatjoinrequest)
+
+        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."""
+        ...
+
+
+__all__ = ("ChatJoinRequestCute",)

telegrinder/bot/cute_types/chat_member_updated.py

@@ -0,0 +1,158 @@
+import typing
+from datetime import datetime
+
+from kungfu.library.monad.result import Result
+
+from telegrinder.api.api import APIError
+from telegrinder.bot.cute_types.base import BaseCute, BaseShortcuts, compose_method_params, shortcut
+from telegrinder.types.methods_utils import get_params
+from telegrinder.types.objects import *
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute  # noqa
+
+
+async def chat_member_interaction(
+    update: typing.Any,
+    method_name: str,
+    params: dict[str, typing.Any],
+) -> Result[typing.Any, APIError]:
+    params = compose_method_params(
+        get_params(params),
+        update,
+        default_params={"chat_id", "user_id"},
+    )
+    return await getattr(update.ctx_api, method_name)(**params)
+
+
+class ChatMemberShortcuts(BaseShortcuts["ChatMemberUpdatedCute | ChatJoinRequestCute"]):
+    """Shortcut methods for `ChatMemberUpdatedCute`, `ChatJoinRequestCute` objects."""
+
+    @shortcut("ban_chat_member", executor=chat_member_interaction, custom_params={"chat_id", "user_id"})
+    async def ban_chat_member(
+        self,
+        *,
+        chat_id: int | str | None = None,
+        revoke_messages: bool | None = None,
+        until_date: datetime | int | None = None,
+        user_id: int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.ban_chat_member()`, see the [documentation](https://core.telegram.org/bots/api#banchatmember)
+
+        Use this method to ban a user in a group, a supergroup or a channel. In the case
+        of supergroups and channels, the user will not be able to return to the chat
+        on their own using invite links, etc., unless unbanned first. The bot must
+        be an administrator in the chat for this to work and must have the appropriate
+        administrator rights. Returns True on success."""
+        ...
+
+    @shortcut("unban_chat_member", executor=chat_member_interaction, custom_params={"chat_id", "user_id"})
+    async def unban_chat_member(
+        self,
+        *,
+        chat_id: int | str | None = None,
+        only_if_banned: bool | None = None,
+        user_id: int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.unban_chat_member()`, see the [documentation](https://core.telegram.org/bots/api#unbanchatmember)
+
+        Use this method to unban a previously banned user in a supergroup or channel.
+        The user will not return to the group or channel automatically, but will
+        be able to join via link, etc. The bot must be an administrator for this to
+        work. By default, this method guarantees that after the call the user is
+        not a member of the chat, but will be able to join it. So if the user is a member
+        of the chat they will also be removed from the chat. If you don't want this,
+        use the parameter only_if_banned. Returns True on success."""
+        ...
+
+    @shortcut(
+        "restrict_chat_member",
+        executor=chat_member_interaction,
+        custom_params={"chat_id", "user_id"},
+    )
+    async def restrict_chat_member(
+        self,
+        *,
+        permissions: ChatPermissions,
+        chat_id: int | str | None = None,
+        until_date: datetime | int | None = None,
+        use_independent_chat_permissions: bool | None = None,
+        user_id: int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.restrict_chat_member()`, see the [documentation](https://core.telegram.org/bots/api#restrictchatmember)
+
+        Use this method to restrict a user in a supergroup. The bot must be an administrator
+        in the supergroup for this to work and must have the appropriate administrator
+        rights. Pass True for all permissions to lift restrictions from a user.
+        Returns True on success."""
+        ...
+
+    @shortcut("promote_chat_member", executor=chat_member_interaction, custom_params={"chat_id", "user_id"})
+    async def promote_chat_member(
+        self,
+        *,
+        can_change_info: bool | None = None,
+        can_delete_messages: bool | None = None,
+        can_delete_stories: bool | None = None,
+        can_edit_messages: bool | None = None,
+        can_edit_stories: bool | None = None,
+        can_invite_users: bool | None = None,
+        can_manage_chat: bool | None = None,
+        can_manage_direct_messages: bool | None = None,
+        can_manage_topics: bool | None = None,
+        can_manage_video_chats: bool | None = None,
+        can_pin_messages: bool | None = None,
+        can_post_messages: bool | None = None,
+        can_post_stories: bool | None = None,
+        can_promote_members: bool | None = None,
+        can_restrict_members: bool | None = None,
+        chat_id: int | str | None = None,
+        is_anonymous: bool | None = None,
+        user_id: int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.promote_chat_member()`, see the [documentation](https://core.telegram.org/bots/api#promotechatmember)
+
+        Use this method to promote or demote a user in a supergroup or a channel. The
+        bot must be an administrator in the chat for this to work and must have the
+        appropriate administrator rights. Pass False for all boolean parameters
+        to demote a user. Returns True on success."""
+        ...
+
+    @shortcut(
+        "set_chat_administrator_custom_title",
+        executor=chat_member_interaction,
+        custom_params={"chat_id", "user_id"},
+    )
+    async def set_chat_administrator_custom_title(
+        self,
+        *,
+        custom_title: str,
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.set_chat_administrator_custom_title()`, see the [documentation](https://core.telegram.org/bots/api#setchatadministratorcustomtitle)
+
+        Use this method to set a custom title for an administrator in a supergroup
+        promoted by the bot. Returns True on success."""
+        ...
+
+
+class ChatMemberUpdatedCute(BaseCute[ChatMemberUpdated], ChatMemberUpdated, ChatMemberShortcuts, kw_only=True):
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+    @property
+    def user_id(self) -> int:
+        return self.from_user.id
+
+
+__all__ = (
+    "ChatMemberShortcuts",
+    "ChatMemberUpdatedCute",
+)

telegrinder/bot/cute_types/chosen_inline_result.py

@@ -0,0 +1,11 @@
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.types.objects import ChosenInlineResult, User
+
+
+class ChosenInlineResultCute(BaseCute[ChosenInlineResult], ChosenInlineResult, kw_only=True):
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+
+__all__ = ("ChosenInlineResultCute",)

telegrinder/bot/cute_types/inline_query.py

@@ -0,0 +1,41 @@
+import typing
+
+from kungfu.library.monad.result import Result
+
+from telegrinder.api.api import APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
+from telegrinder.types.methods_utils import get_params
+from telegrinder.types.objects import *
+
+
+class InlineQueryCute(BaseCute[InlineQuery], InlineQuery, kw_only=True):
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+    @shortcut("answer_inline_query", custom_params={"results", "inline_query_id"})
+    async def answer(
+        self,
+        results: InlineQueryResult | list[InlineQueryResult],
+        *,
+        button: InlineQueryResultsButton | None = None,
+        cache_time: int | None = None,
+        inline_query_id: str | None = None,
+        is_personal: bool | None = None,
+        next_offset: str | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.answer_inline_query()`, see the [documentation](https://core.telegram.org/bots/api#answerinlinequery)
+
+        Use this method to send answers to an inline query. On success, True is returned.
+        No more than 50 results per query are allowed."""
+        params = compose_method_params(
+            get_params(locals()),
+            self,
+            default_params={("inline_query_id", "id")},
+        )
+        params["results"] = [results] if not isinstance(results, list) else results
+        return await self.ctx_api.answer_inline_query(**params)
+
+
+__all__ = ("InlineQueryCute",)