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

telegrinder/bot/cute_types/pre_checkout_query.py

@@ -0,0 +1,42 @@
+import typing
+
+from fntypes.result import Result
+
+from telegrinder.api.api import API
+from telegrinder.api.error import APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params
+from telegrinder.model import get_params
+from telegrinder.tools.magic import shortcut
+from telegrinder.types.objects import PreCheckoutQuery, User
+
+
+class PreCheckoutQueryCute(BaseCute[PreCheckoutQuery], PreCheckoutQuery, kw_only=True):
+    api: API
+
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+    @shortcut("answer_pre_checkout_query", custom_params={"pre_checkout_query_id"})
+    async def answer(
+        self,
+        ok: bool,
+        *,
+        error_message: str | None = None,
+        pre_checkout_query_id: str | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.answer_pre_checkout_query()`, see the [documentation](https://core.telegram.org/bots/api#answerprecheckoutquery)
+
+        Once the user has confirmed their payment and shipping details, the Bot
+        API sends the final confirmation in the form of an Update with the field pre_checkout_query.
+        Use this method to respond to such pre-checkout queries. On success, True
+        is returned. Note: The Bot API must receive an answer within 10 seconds after
+        the pre-checkout query was sent."""
+        params = compose_method_params(
+            get_params(locals()), self, default_params={("pre_checkout_query_id", "id")}
+        )
+        return await self.ctx_api.answer_pre_checkout_query(**params)
+
+
+__all__ = ("PreCheckoutQueryCute",)

telegrinder/bot/cute_types/update.py

@@ -1,104 +1,112 @@
-import typing
-
-from fntypes.co import Nothing, Some
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
-from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
-from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
-from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
-from telegrinder.bot.cute_types.inline_query import InlineQueryCute
-from telegrinder.bot.cute_types.message import MessageCute
-from telegrinder.model import From, field
-from telegrinder.msgspec_utils import Option
-from telegrinder.types.objects import *
-
-EventModel = typing.TypeVar("EventModel", bound=Model)
-
-
-class UpdateCute(BaseCute[Update], Update, kw_only=True):
-    api: API
-
-    message: Option[MessageCute] = field(
-        default=Nothing(),
-        converter=From[MessageCute | None],
-    )
-    """Optional. New incoming message of any kind - text, photo, sticker, etc."""
-
-    edited_message: Option[MessageCute] = field(
-        default=Nothing(),
-        converter=From[MessageCute | None],
-    )
-    """Optional. New version of a message that is known to the bot and was edited.
-    This update may at times be triggered by changes to message fields that are
-    either unavailable or not actively used by your bot."""
-
-    channel_post: Option[MessageCute] = field(
-        default=Nothing(),
-        converter=From[MessageCute | None],
-    )
-    """Optional. New incoming channel post of any kind - text, photo, sticker,
-    etc."""
-
-    edited_channel_post: Option[MessageCute] = field(
-        default=Nothing(),
-        converter=From[MessageCute | None],
-    )
-    """Optional. New version of a channel post that is known to the bot and was edited.
-    This update may at times be triggered by changes to message fields that are
-    either unavailable or not actively used by your bot."""
-
-    business_message: Option[MessageCute] = field(
-        default=Nothing(),
-        converter=From[MessageCute | None],
-    )
-    """Optional. New message from a connected business account."""
-
-    edited_business_message: Option[MessageCute] = field(
-        default=Nothing(),
-        converter=From[MessageCute | None],
-    )
-    """Optional. New version of a message from a connected business account."""
-
-    inline_query: Option[InlineQueryCute] = field(
-        default=Nothing(),
-        converter=From[InlineQueryCute | None],
-    )
-    """Optional. New incoming inline query."""
-
-    callback_query: Option[CallbackQueryCute] = field(
-        default=Nothing(),
-        converter=From[CallbackQueryCute | None],
-    )
-    """Optional. New incoming callback query."""
-
-    my_chat_member: Option[ChatMemberUpdatedCute] = field(
-        default=Nothing(),
-        converter=From[ChatMemberUpdatedCute | None],
-    )
-    """Optional. The bot's chat member status was updated in a chat. For private
-    chats, this update is received only when the bot is blocked or unblocked
-    by the user."""
-
-    chat_member: Option[ChatMemberUpdatedCute] = field(
-        default=Nothing(),
-        converter=From[ChatMemberUpdatedCute | None],
-    )
-    """Optional. A chat member's status was updated in a chat. The bot must be an
-    administrator in the chat and must explicitly specify `chat_member` in
-    the list of allowed_updates to receive these updates."""
-
-    chat_join_request: Option[ChatJoinRequestCute] = field(
-        default=Nothing(),
-        converter=From[ChatJoinRequestCute | None],
-    )
-    """Optional. A request to join the chat has been sent. The bot must have the can_invite_users
-    administrator right in the chat to receive these updates."""
-
-    def get_event(self, event_model: type[EventModel]) -> Option[EventModel]:
-        if isinstance(self.incoming_update, event_model):
-            return Some(self.incoming_update)
-        return Nothing()
-
-
-__all__ = ("UpdateCute",)
+import typing
+
+from fntypes.co import Nothing, Some
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
+from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
+from telegrinder.bot.cute_types.inline_query import InlineQueryCute
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
+from telegrinder.model import UNSET, From, field
+from telegrinder.msgspec_utils import Option
+from telegrinder.types.objects import *
+
+EventModel = typing.TypeVar("EventModel", bound=Model)
+
+
+class UpdateCute(BaseCute[Update], Update, kw_only=True):
+    api: API
+
+    message: Option[MessageCute] = field(
+        default=UNSET,
+        converter=From[MessageCute | None],
+    )
+    """Optional. New incoming message of any kind - text, photo, sticker, etc."""
+
+    edited_message: Option[MessageCute] = field(
+        default=UNSET,
+        converter=From[MessageCute | None],
+    )
+    """Optional. New version of a message that is known to the bot and was edited.
+    This update may at times be triggered by changes to message fields that are
+    either unavailable or not actively used by your bot."""
+
+    channel_post: Option[MessageCute] = field(
+        default=UNSET,
+        converter=From[MessageCute | None],
+    )
+    """Optional. New incoming channel post of any kind - text, photo, sticker,
+    etc."""
+
+    edited_channel_post: Option[MessageCute] = field(
+        default=UNSET,
+        converter=From[MessageCute | None],
+    )
+    """Optional. New version of a channel post that is known to the bot and was edited.
+    This update may at times be triggered by changes to message fields that are
+    either unavailable or not actively used by your bot."""
+
+    business_message: Option[MessageCute] = field(
+        default=UNSET,
+        converter=From[MessageCute | None],
+    )
+    """Optional. New message from a connected business account."""
+
+    edited_business_message: Option[MessageCute] = field(
+        default=UNSET,
+        converter=From[MessageCute | None],
+    )
+    """Optional. New version of a message from a connected business account."""
+
+    inline_query: Option[InlineQueryCute] = field(
+        default=UNSET,
+        converter=From[InlineQueryCute | None],
+    )
+    """Optional. New incoming inline query."""
+
+    callback_query: Option[CallbackQueryCute] = field(
+        default=UNSET,
+        converter=From[CallbackQueryCute | None],
+    )
+    """Optional. New incoming callback query."""
+
+    my_chat_member: Option[ChatMemberUpdatedCute] = field(
+        default=UNSET,
+        converter=From[ChatMemberUpdatedCute | None],
+    )
+    """Optional. The bot's chat member status was updated in a chat. For private
+    chats, this update is received only when the bot is blocked or unblocked
+    by the user."""
+
+    chat_member: Option[ChatMemberUpdatedCute] = field(
+        default=UNSET,
+        converter=From[ChatMemberUpdatedCute | None],
+    )
+    """Optional. A chat member's status was updated in a chat. The bot must be an
+    administrator in the chat and must explicitly specify `chat_member` in
+    the list of allowed_updates to receive these updates."""
+
+    chat_join_request: Option[ChatJoinRequestCute] = field(
+        default=UNSET,
+        converter=From[ChatJoinRequestCute | None],
+    )
+    """Optional. A request to join the chat has been sent. The bot must have the can_invite_users
+    administrator right in the chat to receive these updates."""
+
+    pre_checkout_query: Option[PreCheckoutQueryCute] = field(
+        default=UNSET,
+        converter=From[PreCheckoutQueryCute | None],
+    )
+    """Optional. New incoming pre-checkout query. Contains full information
+    about checkout."""
+
+    def get_event(self, event_model: type[EventModel]) -> Option[EventModel]:
+        if isinstance(self.incoming_update, event_model):
+            return Some(self.incoming_update)
+        return Nothing()
+
+
+__all__ = ("UpdateCute",)

telegrinder/bot/cute_types/utils.py

@@ -1,95 +1,62 @@
-import typing
-
-from telegrinder.model import get_params
-from telegrinder.types.objects import (
-    InputFile,
-    InputMediaAnimation,
-    InputMediaAudio,
-    InputMediaDocument,
-    InputMediaPhoto,
-    InputMediaVideo,
-    LinkPreviewOptions,
-    MessageEntity,
-    ReactionEmoji,
-    ReactionType,
-    ReactionTypeEmoji,
-    ReplyParameters,
-)
-
-InputMedia: typing.TypeAlias = typing.Union[
-    InputMediaAnimation,
-    InputMediaAudio,
-    InputMediaDocument,
-    InputMediaPhoto,
-    InputMediaVideo,
-]
-
-INPUT_MEDIA_TYPES: typing.Final[dict[str, type[InputMedia]]] = {
-    "animation": InputMediaAnimation,
-    "audio": InputMediaAudio,
-    "document": InputMediaDocument,
-    "photo": InputMediaPhoto,
-    "video": InputMediaVideo,
-}
-
-
-def compose_reactions(
-    reactions: str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType],
-    /,
-) -> list[ReactionType]:
-    if not isinstance(reactions, list):
-        reactions = [reactions]
-    return [
-        (
-            ReactionTypeEmoji(emoji)
-            if isinstance(emoji, ReactionEmoji)
-            else (ReactionTypeEmoji(ReactionEmoji(emoji)) if isinstance(emoji, str) else emoji)
-        )
-        for emoji in ([reactions] if isinstance(reactions, str) else reactions)  # type: ignore
-    ]
-
-
-def compose_reply_params(
-    message_id: int | None,
-    chat_id: int | str | None,
-    *,
-    allow_sending_without_reply: bool | None = None,
-    quote: str | None = None,
-    quote_parse_mode: str | None = None,
-    quote_entities: list[MessageEntity] | None = None,
-    quote_position: int | None = None,
-    **other: typing.Any,
-) -> ReplyParameters:
-    return ReplyParameters(**get_params(locals()))
-
-
-def compose_link_preview_options(
-    *,
-    is_disabled: bool | None = None,
-    url: str | None = None,
-    prefer_small_media: bool | None = None,
-    prefer_large_media: bool | None = None,
-    show_above_text: bool | None = None,
-    **other: typing.Any,
-) -> LinkPreviewOptions:
-    return LinkPreviewOptions(**get_params(locals()))
-
-
-def input_media(
-    type: typing.Literal["animation", "audio", "document", "photo", "video"],
-    media: str | InputFile,
-    *,
-    caption: str | None = None,
-    parse_mode: str | None = None,
-    caption_entities: list[MessageEntity] | None = None,
-    **other: typing.Any,
-) -> InputMedia:
-    return INPUT_MEDIA_TYPES[type](**get_params(locals()))
-
-
-__all__ = (
-    "compose_link_preview_options",
-    "compose_reactions",
-    "compose_reply_params",
-    "input_media",
-)
+import typing
+
+from telegrinder.model import get_params
+from telegrinder.types.objects import (
+    InputFile,
+    InputMediaAnimation,
+    InputMediaAudio,
+    InputMediaDocument,
+    InputMediaPhoto,
+    InputMediaVideo,
+    MessageEntity,
+    ReactionEmoji,
+    ReactionType,
+    ReactionTypeEmoji,
+)
+
+type InputMedia = typing.Union[
+    InputMediaAnimation,
+    InputMediaAudio,
+    InputMediaDocument,
+    InputMediaPhoto,
+    InputMediaVideo,
+]
+
+INPUT_MEDIA_TYPES: typing.Final[dict[str, type[InputMedia]]] = {
+    "animation": InputMediaAnimation,
+    "audio": InputMediaAudio,
+    "document": InputMediaDocument,
+    "photo": InputMediaPhoto,
+    "video": InputMediaVideo,
+}
+
+
+def compose_reactions(
+    reactions: str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType],
+    /,
+) -> list[ReactionType]:
+    if not isinstance(reactions, list):
+        reactions = [reactions]
+    return [
+        (
+            ReactionTypeEmoji(emoji)
+            if isinstance(emoji, ReactionEmoji)
+            else (ReactionTypeEmoji(ReactionEmoji(emoji)) if isinstance(emoji, str) else emoji)
+        )
+        for emoji in reactions
+    ]
+
+
+def input_media(
+    type: typing.Literal["animation", "audio", "document", "photo", "video"],
+    media: str | InputFile,
+    *,
+    caption: str | None = None,
+    parse_mode: str | None = None,
+    caption_entities: list[MessageEntity] | None = None,
+    **other: typing.Any,
+) -> InputMedia:
+    return INPUT_MEDIA_TYPES[type](**get_params(locals()))
+
+
+__all__ = ("compose_reactions", "input_media")

telegrinder/bot/dispatch/__init__.py

@@ -1,56 +1,58 @@
-from telegrinder.bot.dispatch.abc import ABCDispatch
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.dispatch import Dispatch, TelegrinderContext
-from telegrinder.bot.dispatch.handler import (
-    ABCHandler,
-    AudioReplyHandler,
-    DocumentReplyHandler,
-    FuncHandler,
-    MediaGroupReplyHandler,
-    MessageReplyHandler,
-    PhotoReplyHandler,
-    StickerReplyHandler,
-    VideoReplyHandler,
-)
-from telegrinder.bot.dispatch.middleware import ABCMiddleware
-from telegrinder.bot.dispatch.process import check_rule, process_inner
-from telegrinder.bot.dispatch.return_manager import (
-    ABCReturnManager,
-    BaseReturnManager,
-    CallbackQueryReturnManager,
-    InlineQueryReturnManager,
-    Manager,
-    MessageReturnManager,
-    register_manager,
-)
-from telegrinder.bot.dispatch.view import (
-    ABCStateView,
-    ABCView,
-    BaseStateView,
-    BaseView,
-    CallbackQueryView,
-    ChatJoinRequestView,
-    ChatMemberView,
-    InlineQueryView,
-    MessageView,
-    RawEventView,
-    ViewBox,
-)
-from telegrinder.bot.dispatch.waiter_machine import (
-    CALLBACK_QUERY_FOR_MESSAGE,
-    CALLBACK_QUERY_FROM_CHAT,
-    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
-    MESSAGE_FROM_USER,
-    MESSAGE_FROM_USER_IN_CHAT,
-    MESSAGE_IN_CHAT,
-    Hasher,
-    ShortState,
-    StateViewHasher,
-    WaiterMachine,
-    clear_wm_storage_worker,
-)
-
-__all__ = (
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.dispatch import Dispatch, TelegrinderContext
+from telegrinder.bot.dispatch.handler import (
+    ABCHandler,
+    AudioReplyHandler,
+    DocumentReplyHandler,
+    FuncHandler,
+    MediaGroupReplyHandler,
+    MessageReplyHandler,
+    PhotoReplyHandler,
+    StickerReplyHandler,
+    VideoReplyHandler,
+)
+from telegrinder.bot.dispatch.middleware import ABCMiddleware
+from telegrinder.bot.dispatch.process import check_rule, process_inner
+from telegrinder.bot.dispatch.return_manager import (
+    ABCReturnManager,
+    BaseReturnManager,
+    CallbackQueryReturnManager,
+    InlineQueryReturnManager,
+    Manager,
+    MessageReturnManager,
+    PreCheckoutQueryManager,
+    register_manager,
+)
+from telegrinder.bot.dispatch.view import (
+    ABCStateView,
+    ABCView,
+    BaseStateView,
+    BaseView,
+    CallbackQueryView,
+    ChatJoinRequestView,
+    ChatMemberView,
+    InlineQueryView,
+    MessageView,
+    PreCheckoutQueryView,
+    RawEventView,
+    ViewBox,
+)
+from telegrinder.bot.dispatch.waiter_machine import (
+    CALLBACK_QUERY_FOR_MESSAGE,
+    CALLBACK_QUERY_FROM_CHAT,
+    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
+    MESSAGE_FROM_USER,
+    MESSAGE_FROM_USER_IN_CHAT,
+    MESSAGE_IN_CHAT,
+    Hasher,
+    ShortState,
+    StateViewHasher,
+    WaiterMachine,
+    clear_wm_storage_worker,
+)
+
+__all__ = (
     "ABCDispatch",
     "ABCHandler",
     "ABCMiddleware",
@@ -84,6 +86,8 @@ __all__ = (
     "MessageReturnManager",
     "MessageView",
     "PhotoReplyHandler",
+    "PreCheckoutQueryManager",
+    "PreCheckoutQueryView",
     "RawEventView",
     "ShortState",
     "StateViewHasher",
@@ -96,5 +100,5 @@ __all__ = (
     "clear_wm_storage_worker",
     "clear_wm_storage_worker",
     "process_inner",
-    "register_manager",
-)
+    "register_manager",
+)