telegrinder 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

telegrinder/bot/cute_types/chat_join_request.py

@@ -1,61 +1,61 @@
-import typing
-
-from fntypes.result import Result
-
-from telegrinder.api import API, 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):
-    api: API
-
-    @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",)
+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.chat_member_updated import ChatMemberShortcuts, chat_member_interaction
+from telegrinder.types.objects import *
+
+
+class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMemberShortcuts, kw_only=True):
+    api: API
+
+    @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

@@ -1,160 +1,160 @@
-import typing
-from datetime import datetime
-
-from fntypes.result import Result
-
-from telegrinder.api import API, APIError
-from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
-from telegrinder.model import get_params
-from telegrinder.types.objects import *
-
-
-async def chat_member_interaction(
-    update: BaseCute[typing.Any],
-    method_name: str,
-    params: dict[str, typing.Any],
-) -> Result[typing.Any, APIError]:
-    if isinstance(params.get("permissions"), dict):
-        params["permissions"] = ChatPermissions(**params["permissions"])
-    params = compose_method_params(
-        get_params(locals()),
-        update,
-        default_params={"chat_id", "user_id"},
-    )
-    return await getattr(update.ctx_api, method_name)(**params)
-
-
-class ChatMemberShortcuts:
-    """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,
-        user_id: int | None = None,
-        until_date: datetime | int | None = None,
-        revoke_messages: bool | 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,
-        user_id: int | None = None,
-        only_if_banned: bool | 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={"permissions", "chat_id", "user_id"},
-    )
-    async def restrict_chat_member(
-        self,
-        permissions: ChatPermissions | dict[str, typing.Any],
-        chat_id: int | str | None = None,
-        user_id: int | None = None,
-        use_independent_chat_permissions: bool | None = None,
-        until_date: datetime | 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,
-        chat_id: int | str | None = None,
-        user_id: int | None = None,
-        is_anonymous: bool | None = None,
-        can_manage_chat: bool | None = None,
-        can_delete_messages: bool | None = None,
-        can_manage_video_chats: bool | None = None,
-        can_restrict_members: bool | None = None,
-        can_promote_members: bool | None = None,
-        can_change_info: bool | None = None,
-        can_invite_users: bool | None = None,
-        can_post_stories: bool | None = None,
-        can_edit_stories: bool | None = None,
-        can_delete_stories: bool | None = None,
-        can_post_messages: bool | None = None,
-        can_edit_messages: bool | None = None,
-        can_pin_messages: bool | None = None,
-        can_manage_topics: bool | 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
-):
-    api: API
-
-    @property
-    def from_user(self) -> User:
-        return self.from_
-
-    @property
-    def user_id(self) -> int:
-        return self.from_user.id
-
-
-__all__ = (
-    "ChatMemberShortcuts",
-    "ChatMemberUpdatedCute",
-)
+import typing
+from datetime import datetime
+
+from fntypes.result import Result
+
+from telegrinder.api.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
+from telegrinder.model import get_params
+from telegrinder.types.objects import *
+
+
+async def chat_member_interaction(
+    update: BaseCute[typing.Any],
+    method_name: str,
+    params: dict[str, typing.Any],
+) -> Result[typing.Any, APIError]:
+    if isinstance(params.get("permissions"), dict):
+        params["permissions"] = ChatPermissions(**params["permissions"])
+    params = compose_method_params(
+        get_params(locals()),
+        update,
+        default_params={"chat_id", "user_id"},
+    )
+    return await getattr(update.ctx_api, method_name)(**params)
+
+
+class ChatMemberShortcuts:
+    """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,
+        user_id: int | None = None,
+        until_date: datetime | int | None = None,
+        revoke_messages: bool | 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,
+        user_id: int | None = None,
+        only_if_banned: bool | 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={"permissions", "chat_id", "user_id"},
+    )
+    async def restrict_chat_member(
+        self,
+        permissions: ChatPermissions | dict[str, typing.Any],
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        use_independent_chat_permissions: bool | None = None,
+        until_date: datetime | 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,
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        is_anonymous: bool | None = None,
+        can_manage_chat: bool | None = None,
+        can_delete_messages: bool | None = None,
+        can_manage_video_chats: bool | None = None,
+        can_restrict_members: bool | None = None,
+        can_promote_members: bool | None = None,
+        can_change_info: bool | None = None,
+        can_invite_users: bool | None = None,
+        can_post_stories: bool | None = None,
+        can_edit_stories: bool | None = None,
+        can_delete_stories: bool | None = None,
+        can_post_messages: bool | None = None,
+        can_edit_messages: bool | None = None,
+        can_pin_messages: bool | None = None,
+        can_manage_topics: bool | 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
+):
+    api: API
+
+    @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/inline_query.py

@@ -1,53 +1,53 @@
-import typing
-
-from fntypes.result import Result
-
-from telegrinder.api import API, APIError
-from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
-from telegrinder.model import get_params
-from telegrinder.types.objects import *
-
-
-class InlineQueryCute(BaseCute[InlineQuery], InlineQuery, kw_only=True):
-    api: API
-
-    @property
-    def from_user(self) -> User:
-        return self.from_
-
-    @shortcut("answer_inline_query", custom_params={"results"})
-    async def answer(
-        self,
-        results: InlineQueryResult | list[InlineQueryResult],
-        inline_query_id: str,
-        cache_time: int | None = None,
-        is_personal: bool | None = None,
-        next_offset: str | None = None,
-        button: InlineQueryResultsButton | 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.
-        :param inline_query_id: Unique identifier for the answered query.
-
-        :param results: A JSON-serialized array of results for the inline query.
-
-        :param cache_time: The maximum amount of time in seconds that the result of the inline querymay be cached on the server. Defaults to 300.
-
-        :param is_personal: Pass True if results may be cached on the server side only for the user thatsent the query. By default, results may be returned to any user who sendsthe same query.
-
-        :param next_offset: Pass the offset that a client should send in the next query with the same textto receive more results. Pass an empty string if there are no more resultsor if you don't support pagination. Offset length can't exceed 64 bytes.
-        :param button: A JSON-serialized object describing a button to be shown above inline queryresults."""
-
-        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",)
+import typing
+
+from fntypes.result import Result
+
+from telegrinder.api.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
+from telegrinder.model import get_params
+from telegrinder.types.objects import *
+
+
+class InlineQueryCute(BaseCute[InlineQuery], InlineQuery, kw_only=True):
+    api: API
+
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+    @shortcut("answer_inline_query", custom_params={"results"})
+    async def answer(
+        self,
+        results: InlineQueryResult | list[InlineQueryResult],
+        inline_query_id: str,
+        cache_time: int | None = None,
+        is_personal: bool | None = None,
+        next_offset: str | None = None,
+        button: InlineQueryResultsButton | 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.
+        :param inline_query_id: Unique identifier for the answered query.
+
+        :param results: A JSON-serialized array of results for the inline query.
+
+        :param cache_time: The maximum amount of time in seconds that the result of the inline querymay be cached on the server. Defaults to 300.
+
+        :param is_personal: Pass True if results may be cached on the server side only for the user thatsent the query. By default, results may be returned to any user who sendsthe same query.
+
+        :param next_offset: Pass the offset that a client should send in the next query with the same textto receive more results. Pass an empty string if there are no more resultsor if you don't support pagination. Offset length can't exceed 64 bytes.
+        :param button: A JSON-serialized object describing a button to be shown above inline queryresults."""
+
+        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",)