pincer.objects.app.interactions.Interaction.ack() - Code Metrics - Inspection of "✨ " - Pincer-org/Pincer - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#167)

unknown

created 2021-11-02 11:30 UTC

pincer.objects.app.interactions.Interaction.ack() A

↳ Parent: pincer.objects.app.interactions

Complexity

Conditions

Size

Total Lines	29
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	11
dl	0
loc	29
rs	9.85
c	0
b	0
f	0
cc	3
nop	2

# Copyright Pincer 2021-Present

# Full MIT License can be found in `LICENSE` at the project root.

from __future__ import annotations

from asyncio import gather, iscoroutine, sleep, ensure_future
from dataclasses import dataclass
from typing import Dict, TYPE_CHECKING, Union, Optional

from .command_types import AppCommandOptionType
from .interaction_base import InteractionType, CallbackType
from ..app.select_menu import SelectOption
from ..guild.member import GuildMember
from ..message.context import MessageContext
from ..message.user_message import UserMessage
from ..user import User
from ...exceptions import InteractionDoesNotExist, UseFollowup, \
    InteractionAlreadyAcknowledged, NotFoundError, InteractionTimedOut
from ...utils import APIObject, convert
from ...utils.convert_message import convert_message
from ...utils.snowflake import Snowflake
from ...utils.types import MISSING

if TYPE_CHECKING:
    from .interaction_flags import InteractionFlags
    from ...utils.convert_message import MessageConvertable
    from .command import AppCommandInteractionDataOption
    from ..message.message import Message
    from ..guild.channel import Channel

    from ..guild.role import Role
    from ...utils import APINullable


@dataclass
class ResolvedData(APIObject):
    """
    Represents a Discord Resolved Data structure

    :param users:
        Map of Snowflakes to user objects

    :param members:
        Map of Snowflakes to partial member objects

    :param roles:
        Map of Snowflakes to role objects

    :param channels:
        Map of Snowflakes to partial channel objects

    :param messages:
        Map of Snowflakes to partial message objects
    """
    users: APINullable[Dict[Snowflake, User]] = MISSING
    members: APINullable[Dict[Snowflake, GuildMember]] = MISSING
    roles: APINullable[Dict[Snowflake, Role]] = MISSING
    channels: APINullable[Dict[Snowflake, Channel]] = MISSING
    messages: APINullable[Dict[Snowflake, UserMessage]] = MISSING


@dataclass

class InteractionData(APIObject):
    """
    Represents a Discord Interaction Data structure

    :param id:
        the `ID` of the invoked command

    :param name:
        the `name` of the invoked command

    :param type:
        the `type` of the invoked command

    :param resolved:
        converted users + roles + channels

    :param options:
        the params + values from the user

    :param custom_id:
        the `custom_id` of the component

    :param component_type:
        the type of the component

    :param values:
        the values the user selected

    :param target_id:
        id of the user or message targeted by a user or message command
    """
    id: Snowflake
    name: str
    type: int

    resolved: APINullable[ResolvedData] = MISSING
    options: APINullable[AppCommandInteractionDataOption] = MISSING
    custom_id: APINullable[str] = MISSING
    component_type: APINullable[int] = MISSING
    values: APINullable[SelectOption] = MISSING
    target_id: APINullable[Snowflake] = MISSING


@dataclass

class Interaction(APIObject):
    """
    Represents a Discord Interaction object

    :param id:
        id of the interaction

    :param application_id:
        id of the application this interaction is for

    :param type:
        the type of interaction

    :param data:
        the command data payload

    :param guild_id:
        the guild it was sent from

    :param channel_id:
        the channel it was sent from

    :param member:
        guild member data for the invoking user, including permissions

    :param user:
        user object for the invoking user, if invoked in a DM

    :param token:
        a continuation token for responding to the interaction

    :param version:
        read-only property, always `1`

    :param message:
        for components, the message they were attached to
    """
    id: Snowflake
    application_id: Snowflake
    type: InteractionType
    token: str

    version: int = 1
    data: APINullable[InteractionData] = MISSING
    guild_id: APINullable[Snowflake] = MISSING
    channel_id: APINullable[Snowflake] = MISSING
    member: APINullable[GuildMember] = MISSING
    user: APINullable[User] = MISSING
    message: APINullable[UserMessage] = MISSING
    has_replied: bool = False
    has_acknowledged: bool = False

    def __post_init__(self):
        self.id = convert(self.id, Snowflake.from_string)
        self.application_id = convert(
            self.application_id, Snowflake.from_string
        )
        self.type = convert(self.type, InteractionType)
        self.data = convert(
            self.data,
            InteractionData.from_dict,
            InteractionData
        )
        self.guild_id = convert(self.guild_id, Snowflake.from_string)
        self.channel_id = convert(self.channel_id, Snowflake.from_string)

        self.member = convert(
            self.member,
            GuildMember.from_dict,
            GuildMember,
            client=self._client
        )

        self.user = convert(
            self.user,
            User.from_dict,
            User,
            client=self._client
        )

        self.message = convert(
            self.message,
            UserMessage.from_dict,
            UserMessage,
            client=self._client
        )

        self._convert_functions = {
            AppCommandOptionType.SUB_COMMAND: None,
            AppCommandOptionType.SUB_COMMAND_GROUP: None,

            AppCommandOptionType.STRING: str,
            AppCommandOptionType.INTEGER: int,
            AppCommandOptionType.BOOLEAN: bool,
            AppCommandOptionType.NUMBER: float,

            AppCommandOptionType.USER: lambda value:
            self._client.get_user(

                convert(value, Snowflake.from_string)
            ),
            AppCommandOptionType.CHANNEL: lambda value:
            self._client.get_channel(

                convert(value, Snowflake.from_string)
            ),
            AppCommandOptionType.ROLE: lambda value:
            self._client.get_role(

                convert(self.guild_id, Snowflake.from_string),
                convert(value, Snowflake.from_string)
            ),
            AppCommandOptionType.MENTIONABLE: None
        }

    async def build(self):
        """|coro|

        Sets the parameters in the interaction that need information
        from the discord API.
        """

        if not self.data.options:
            return

        await gather(
            *map(self.convert, self.data.options)
        )

    async def convert(self, option: AppCommandInteractionDataOption):
        """|coro|

        Sets an AppCommandInteractionDataOption value paramater to
        the payload type
        """

        converter = self._convert_functions.get(option.type)

        if not converter:
            raise NotImplementedError(
                f"Handling for AppCommandOptionType {option.type} is not "
                "implemented"
            )

        res = converter(option.value)

        option.value = (await res) if iscoroutine(res) else res

    def convert_to_message_context(self, command):

        return MessageContext(
            self.member or self.user,
            command,
            self,
            self.guild_id,
            self.channel_id
        )

    async def response(self) -> UserMessage:
        """|coro|

        Gets the original response for an interaction.

        Returns
        -------
        :class:`~pincer.objects.message.user_message.UserMessage`
            The fetched response!
        """
        if not self.has_replied:
            raise InteractionDoesNotExist(
                "No interaction reply has been sent yet!"
            )

        resp = await self._http.get(
            f"/webhooks/{self._client.bot.id}/{self.token}/messages/@original"
        )
        return UserMessage.from_dict(resp)

    async def ack(self, flags: Optional[InteractionFlags] = None):
        """|coro|

        Acknowledge an interaction, any flags here are applied to the reply.

        Parameters
        ----------
        flags :class:`~pincer.objects.app.interaction_flags.InteractionFlags`
            The flags which must be applied to the reply.

        Raises
        ------
        :class:`~pincer.exceptions.InteractionAlreadyAcknowledged`
            The interaction was already acknowledged, this can be
            because a reply or ack was already sent.
        """
        if self.has_replied or self.has_acknowledged:
            raise InteractionAlreadyAcknowledged(
                "The interaction you are trying to acknowledge has already "
                "been acknowledged"
            )

        self.has_acknowledged = True
        await self._http.post(
            f"interactions/{self.id}/{self.token}/callback",
            {
                "type": CallbackType.DEFERRED_MESSAGE,
                "data": {
                    "flags": flags
                }
            }
        )

    async def __post_send_handler(self, message: Message):
        """Process the interaction after it was sent.

        Parameters
        ----------
        message :class:`~pincer.objects.message.message.Message`
            The interaction message.
        """

        if message.delete_after:
            await sleep(message.delete_after)
            await self.delete()

    def __post_sent(self, message: Message):
        """Ensure the `__post_send_handler` method its future.

        Parameters
        ----------
        message :class:`~pincer.objects.message.message.Message`
            The interaction message.
        """
        self.has_replied = True
        ensure_future(self.__post_send_handler(message))

    async def reply(self, message: MessageConvertable):
        """|coro|

        Initial reply, only works if no ACK has been sent yet.

        Parameters
        ----------
        message :class:`~pincer.utils.convert_message.MessageConvertable`
            The response message!

        Raises
        ------
        :class:`~.pincer.errors.UseFollowup`
            Exception raised when a reply has already been sent so a
            :func:`~pincer.objects.app.interactions.Interaction.followup`
            should be used instead.
        :class:`~.pincer.errors.InteractionTimedOut`
            Exception raised when discord had to wait too long for a reply.
            You can extend the discord wait time by using the
            :func:`~pincer.objects.app.interaction.Interaction.ack`
            function.
        """
        if self.has_replied:

            raise UseFollowup(
                "A response has already been sent to the interaction. "
                "Please use a followup instead!"
            )
        elif self.has_acknowledged:
            self.has_replied = True
            await self.edit(message)
            return

        message = convert_message(self._client, message)
        content_type, data = message.serialize()

        try:
            await self._http.post(
                f"interactions/{self.id}/{self.token}/callback",
                {
                    "type": CallbackType.MESSAGE,
                    "data": data
                },
                content_type=content_type
            )
        except NotFoundError:
            raise InteractionTimedOut(
                "Discord had to wait too long for the interaction reply, "
                "you can extend the time it takes for discord to timeout by "
                "acknowledging the interaction. (using interaction.ack)"
            )

        self.__post_sent(message)

    async def edit(self, message: MessageConvertable) -> UserMessage:
        """|coro|

        Edit an interaction. This is also the way to reply to
        interactions whom have been acknowledged.

        Parameters
        ----------
        message :class:`~pincer.utils.convert_message.MessageConvertable`
            The new message!

        Returns
        -------
        :class:`~pincer.objects.message.user_message.UserMessage`
            The updated message object.

        Raises
        ------
        :class:`~.pincer.errors.InteractionDoesNotExist`
            Exception raised when no reply has been sent.
        """

        if not self.has_replied:
            raise InteractionDoesNotExist(
                "The interaction whom you are trying to edit has not "
                "been sent yet!"
            )

        message = convert_message(self._client, message)
        content_type, data = message.serialize()

        resp = await self._http.patch(
            f"webhooks/{self._client.bot.id}/{self.token}/messages/@original",
            data,
            content_type=content_type
        )
        self.__post_sent(message)
        return UserMessage.from_dict(resp)

    async def delete(self):
        """|coro|

        Delete the interaction.

        Raises
        ------
        :class:`~pincer.errors.InteractionDoesNotExist`
            Exception raised when no reply has been sent.
        """
        if not self.has_replied:
            raise InteractionDoesNotExist(
                "The interaction whom you are trying to delete has not "
                "been sent yet!"
            )

        await self._http.delete(
            f"webhooks/{self._client.bot.id}/{self.token}/messages/@original"
        )

    async def __post_followup_send_handler(
            self,
            followup: UserMessage,
            message: Message
    ):
        """Process a folloup after it was sent.

        Parameters
        ----------
        followup :class:`~pincer.objects.message.user_message.UserMessage`
            The followup message that is being post processed.
        message :class:`~pincer.objects.message.message.Message`
            The followup message.
        """

        if message.delete_after:
            await sleep(message.delete_after)
            await self.delete_followup(followup.id)

    def __post_followup_sent(
            self,
            followup: UserMessage,
            message: Message
    ):
        """Ensure the `__post_followup_send_handler` method its future.

        Parameters
        ----------
        followup :class:`~pincer.objects.message.user_message.UserMessage`
            The followup message that is being post processed.
        message :class:`~pincer.objects.message.message.Message`
            The followup message.
        """
        ensure_future(self.__post_followup_send_handler(followup, message))

    async def followup(self, message: MessageConvertable) -> UserMessage:
        """|coro|

        Create a follow up message for the interaction.
        This allows you to respond with multiple messages.

        Parameters
        ----------
        message :class:`~pincer.utils.convert_message.MessageConvertable`
            The message to sent.

        Returns
        -------
        :class:`~pincer.objects.message.user_message.UserMessage`
            The message that has been sent.
        """
        message = convert_message(self._client, message)
        content_type, data = message.serialize()

        resp = await self._http.post(
            f"webhooks/{self._client.bot.id}/{self.token}",
            data,
            content_type=content_type
        )
        msg = UserMessage.from_dict(resp)
        self.__post_followup_sent(msg, message)
        return msg

    async def edit_followup(
            self,
            message_id: int,
            message: MessageConvertable
    ) -> UserMessage:
        """|coro|

        Edit a followup message.

        Parameters
        ----------
        message_id :class:`int`
            The id of the original followup message.
        message :class:`~pincer.utils.convert_message.MessageConvertable`
            The message new message.

        Returns
        -------
        :class:`~pincer.objects.message.user_message.UserMessage`
            The updated message object.
        """
        message = convert_message(self._client, message)
        content_type, data = message.serialize()

        resp = await self._http.patch(
            f"webhooks/{self._client.bot.id}/{self.token}/messages/{message_id}",
            data,
            content_type=content_type
        )
        msg = UserMessage.from_dict(resp)
        self.__post_followup_sent(msg, message)
        return msg

    async def get_followup(self, message_id: int) -> UserMessage:
        """|coro|

        Get a followup message by id.

        Parameters
        ----------
        message_id :class:`int`
            The id of the original followup message that must be fetched.

        Returns
        -------
        :class:`~pincer.objects.message.user_message.UserMessage`
            The fetched message object.
        """

        resp = await self._http.get(
            f"webhooks/{self._client.bot.id}/{self.token}/messages/{message_id}",
        )
        return UserMessage.from_dict(resp)

    async def delete_followup(self, message: Union[UserMessage, int]):
        """|coro|

        Remove a followup message by id.

        Parameters
        ----------
        message Union[:class:`~pincer.objects.user_message.UserMessage`, :class:`int`]
            The id/followup object of the followup message that must be deleted.
        """
        message_id = message if isinstance(message, int) else message.id

        await self._http.delete(
            f"webhooks/{self._client.bot.id}/{self.token}/messages/{message_id}",
        )


1			# Copyright Pincer 2021-Present
			0 ignored issues – show introduced 2021-09-06 08:54 UTC by Report Bug Copy Issue Report Missing module docstring Loading history...
2			# Full MIT License can be found in `LICENSE` at the project root.
3
4			from __future__ import annotations
5
6			from asyncio import gather, iscoroutine, sleep, ensure_future
7			from dataclasses import dataclass
8			from typing import Dict, TYPE_CHECKING, Union, Optional
9
10			from .command_types import AppCommandOptionType
11			from .interaction_base import InteractionType, CallbackType
12			from ..app.select_menu import SelectOption
13			from ..guild.member import GuildMember
14			from ..message.context import MessageContext
15			from ..message.user_message import UserMessage
16			from ..user import User
17			from ...exceptions import InteractionDoesNotExist, UseFollowup, \
18			InteractionAlreadyAcknowledged, NotFoundError, InteractionTimedOut
19			from ...utils import APIObject, convert
20			from ...utils.convert_message import convert_message
21			from ...utils.snowflake import Snowflake
22			from ...utils.types import MISSING
23
24			if TYPE_CHECKING:
25			from .interaction_flags import InteractionFlags
26			from ...utils.convert_message import MessageConvertable
27			from .command import AppCommandInteractionDataOption
28			from ..message.message import Message
29			from ..guild.channel import Channel
			0 ignored issues – show Bug introduced 2021-10-22 14:25 UTC by Report Bug Copy Issue Report The name `channel` does not seem to exist in module `pincer.objects.guild`. Loading history... introduced 2021-10-22 14:25 UTC by Report Bug Copy Issue Report Cannot import 'guild.channel' due to syntax error 'invalid syntax (<unknown>, line 235)' Loading history...
30			from ..guild.role import Role
31			from ...utils import APINullable
32
33
34			@dataclass
35			class ResolvedData(APIObject):
36			"""
37			Represents a Discord Resolved Data structure
38
39			:param users:
40			Map of Snowflakes to user objects
41
42			:param members:
43			Map of Snowflakes to partial member objects
44
45			:param roles:
46			Map of Snowflakes to role objects
47
48			:param channels:
49			Map of Snowflakes to partial channel objects
50
51			:param messages:
52			Map of Snowflakes to partial message objects
53			"""
54			users: APINullable[Dict[Snowflake, User]] = MISSING
55			members: APINullable[Dict[Snowflake, GuildMember]] = MISSING
56			roles: APINullable[Dict[Snowflake, Role]] = MISSING
57			channels: APINullable[Dict[Snowflake, Channel]] = MISSING
58			messages: APINullable[Dict[Snowflake, UserMessage]] = MISSING
59
60
61			@dataclass
			0 ignored issues – show best-practice introduced 2021-09-07 15:34 UTC by Report Bug Copy Issue Report Too many instance attributes (9/7) Loading history...
62			class InteractionData(APIObject):
63			"""
64			Represents a Discord Interaction Data structure
65
66			:param id:
67			the `ID` of the invoked command
68
69			:param name:
70			the `name` of the invoked command
71
72			:param type:
73			the `type` of the invoked command
74
75			:param resolved:
76			converted users + roles + channels
77
78			:param options:
79			the params + values from the user
80
81			:param custom_id:
82			the `custom_id` of the component
83
84			:param component_type:
85			the type of the component
86
87			:param values:
88			the values the user selected
89
90			:param target_id:
91			id of the user or message targeted by a user or message command
92			"""
93			id: Snowflake
94			name: str
95			type: int
96
97			resolved: APINullable[ResolvedData] = MISSING
98			options: APINullable[AppCommandInteractionDataOption] = MISSING
99			custom_id: APINullable[str] = MISSING
100			component_type: APINullable[int] = MISSING
101			values: APINullable[SelectOption] = MISSING
102			target_id: APINullable[Snowflake] = MISSING
103
104
105			@dataclass
			0 ignored issues – show best-practice introduced 2021-10-28 06:41 UTC by Report Bug Copy Issue Report Too many instance attributes (14/7) Loading history...
106			class Interaction(APIObject):
107			"""
108			Represents a Discord Interaction object
109
110			:param id:
111			id of the interaction
112
113			:param application_id:
114			id of the application this interaction is for
115
116			:param type:
117			the type of interaction
118
119			:param data:
120			the command data payload
121
122			:param guild_id:
123			the guild it was sent from
124
125			:param channel_id:
126			the channel it was sent from
127
128			:param member:
129			guild member data for the invoking user, including permissions
130
131			:param user:
132			user object for the invoking user, if invoked in a DM
133
134			:param token:
135			a continuation token for responding to the interaction
136
137			:param version:
138			read-only property, always `1`
139
140			:param message:
141			for components, the message they were attached to
142			"""
143			id: Snowflake
144			application_id: Snowflake
145			type: InteractionType
146			token: str
147
148			version: int = 1
149			data: APINullable[InteractionData] = MISSING
150			guild_id: APINullable[Snowflake] = MISSING
151			channel_id: APINullable[Snowflake] = MISSING
152			member: APINullable[GuildMember] = MISSING
153			user: APINullable[User] = MISSING
154			message: APINullable[UserMessage] = MISSING
155			has_replied: bool = False
156			has_acknowledged: bool = False
157
158			def __post_init__(self):
159			self.id = convert(self.id, Snowflake.from_string)
160			self.application_id = convert(
161			self.application_id, Snowflake.from_string
162			)
163			self.type = convert(self.type, InteractionType)
164			self.data = convert(
165			self.data,
166			InteractionData.from_dict,
167			InteractionData
168			)
169			self.guild_id = convert(self.guild_id, Snowflake.from_string)
170			self.channel_id = convert(self.channel_id, Snowflake.from_string)
171
172			self.member = convert(
173			self.member,
174			GuildMember.from_dict,
175			GuildMember,
176			client=self._client
177			)
178
179			self.user = convert(
180			self.user,
181			User.from_dict,
182			User,
183			client=self._client
184			)
185
186			self.message = convert(
187			self.message,
188			UserMessage.from_dict,
189			UserMessage,
190			client=self._client
191			)
192
193			self._convert_functions = {
194			AppCommandOptionType.SUB_COMMAND: None,
195			AppCommandOptionType.SUB_COMMAND_GROUP: None,
196
197			AppCommandOptionType.STRING: str,
198			AppCommandOptionType.INTEGER: int,
199			AppCommandOptionType.BOOLEAN: bool,
200			AppCommandOptionType.NUMBER: float,
201
202			AppCommandOptionType.USER: lambda value:
203			self._client.get_user(
			0 ignored issues – show Coding Style introduced 2021-10-21 08:55 UTC by Report Bug Copy Issue Report Wrong continued indentation (add 27 spaces). Loading history...
204			convert(value, Snowflake.from_string)
205			),
206			AppCommandOptionType.CHANNEL: lambda value:
207			self._client.get_channel(
			0 ignored issues – show Coding Style introduced 2021-10-21 08:55 UTC by Report Bug Copy Issue Report Wrong continued indentation (add 30 spaces). Loading history...
208			convert(value, Snowflake.from_string)
209			),
210			AppCommandOptionType.ROLE: lambda value:
211			self._client.get_role(
			0 ignored issues – show Coding Style introduced 2021-10-21 08:55 UTC by Report Bug Copy Issue Report Wrong continued indentation (add 27 spaces). Loading history...
212			convert(self.guild_id, Snowflake.from_string),
213			convert(value, Snowflake.from_string)
214			),
215			AppCommandOptionType.MENTIONABLE: None
216			}
217
218			async def build(self):
219			"""\|coro\|
220
221			Sets the parameters in the interaction that need information
222			from the discord API.
223			"""
224
225			if not self.data.options:
226			return
227
228			await gather(
229			*map(self.convert, self.data.options)
230			)
231
232			async def convert(self, option: AppCommandInteractionDataOption):
233			"""\|coro\|
234
235			Sets an AppCommandInteractionDataOption value paramater to
236			the payload type
237			"""
238
239			converter = self._convert_functions.get(option.type)
240
241			if not converter:
242			raise NotImplementedError(
243			f"Handling for AppCommandOptionType {option.type} is not "
244			"implemented"
245			)
246
247			res = converter(option.value)
248
249			option.value = (await res) if iscoroutine(res) else res
250
251			def convert_to_message_context(self, command):
			0 ignored issues – show introduced 2021-09-26 12:43 UTC by Report Bug Copy Issue Report Missing function or method docstring Loading history...
252			return MessageContext(
253			self.member or self.user,
254			command,
255			self,
256			self.guild_id,
257			self.channel_id
258			)
259
260			async def response(self) -> UserMessage:
261			"""\|coro\|
262
263			Gets the original response for an interaction.
264
265			Returns
266			-------
267			:class:`~pincer.objects.message.user_message.UserMessage`
268			The fetched response!
269			"""
270			if not self.has_replied:
271			raise InteractionDoesNotExist(
272			"No interaction reply has been sent yet!"
273			)
274
275			resp = await self._http.get(
276			f"/webhooks/{self._client.bot.id}/{self.token}/messages/@original"
277			)
278			return UserMessage.from_dict(resp)
279
280			async def ack(self, flags: Optional[InteractionFlags] = None):
281			"""\|coro\|
282
283			Acknowledge an interaction, any flags here are applied to the reply.
284
285			Parameters
286			----------
287			flags :class:`~pincer.objects.app.interaction_flags.InteractionFlags`
288			The flags which must be applied to the reply.
289
290			Raises
291			------
292			:class:`~pincer.exceptions.InteractionAlreadyAcknowledged`
293			The interaction was already acknowledged, this can be
294			because a reply or ack was already sent.
295			"""
296			if self.has_replied or self.has_acknowledged:
297			raise InteractionAlreadyAcknowledged(
298			"The interaction you are trying to acknowledge has already "
299			"been acknowledged"
300			)
301
302			self.has_acknowledged = True
303			await self._http.post(
304			f"interactions/{self.id}/{self.token}/callback",
305			{
306			"type": CallbackType.DEFERRED_MESSAGE,
307			"data": {
308			"flags": flags
309			}
310			}
311			)
312
313			async def __post_send_handler(self, message: Message):
314			"""Process the interaction after it was sent.
315
316			Parameters
317			----------
318			message :class:`~pincer.objects.message.message.Message`
319			The interaction message.
320			"""
321
322			if message.delete_after:
323			await sleep(message.delete_after)
324			await self.delete()
325
326			def __post_sent(self, message: Message):
327			"""Ensure the `__post_send_handler` method its future.
328
329			Parameters
330			----------
331			message :class:`~pincer.objects.message.message.Message`
332			The interaction message.
333			"""
334			self.has_replied = True
335			ensure_future(self.__post_send_handler(message))
336
337			async def reply(self, message: MessageConvertable):
338			"""\|coro\|
339
340			Initial reply, only works if no ACK has been sent yet.
341
342			Parameters
343			----------
344			message :class:`~pincer.utils.convert_message.MessageConvertable`
345			The response message!
346
347			Raises
348			------
349			:class:`~.pincer.errors.UseFollowup`
350			Exception raised when a reply has already been sent so a
351			:func:`~pincer.objects.app.interactions.Interaction.followup`
352			should be used instead.
353			:class:`~.pincer.errors.InteractionTimedOut`
354			Exception raised when discord had to wait too long for a reply.
355			You can extend the discord wait time by using the
356			:func:`~pincer.objects.app.interaction.Interaction.ack`
357			function.
358			"""
359			if self.has_replied:
			0 ignored issues – show Unused Code introduced 2021-10-28 11:36 UTC by Report Bug Copy Issue Report Unnecessary "elif" after "raise" Loading history...
360			raise UseFollowup(
361			"A response has already been sent to the interaction. "
362			"Please use a followup instead!"
363			)
364			elif self.has_acknowledged:
365			self.has_replied = True
366			await self.edit(message)
367			return
368
369			message = convert_message(self._client, message)
370			content_type, data = message.serialize()
371
372			try:
373			await self._http.post(
374			f"interactions/{self.id}/{self.token}/callback",
375			{
376			"type": CallbackType.MESSAGE,
377			"data": data
378			},
379			content_type=content_type
380			)
381			except NotFoundError:
382			raise InteractionTimedOut(
383			"Discord had to wait too long for the interaction reply, "
384			"you can extend the time it takes for discord to timeout by "
385			"acknowledging the interaction. (using interaction.ack)"
386			)
387
388			self.__post_sent(message)
389
390			async def edit(self, message: MessageConvertable) -> UserMessage:
391			"""\|coro\|
392
393			Edit an interaction. This is also the way to reply to
394			interactions whom have been acknowledged.
395
396			Parameters
397			----------
398			message :class:`~pincer.utils.convert_message.MessageConvertable`
399			The new message!
400
401			Returns
402			-------
403			:class:`~pincer.objects.message.user_message.UserMessage`
404			The updated message object.
405
406			Raises
407			------
408			:class:`~.pincer.errors.InteractionDoesNotExist`
409			Exception raised when no reply has been sent.
410			"""
411
412			if not self.has_replied:
413			raise InteractionDoesNotExist(
414			"The interaction whom you are trying to edit has not "
415			"been sent yet!"
416			)
417
418			message = convert_message(self._client, message)
419			content_type, data = message.serialize()
420
421			resp = await self._http.patch(
422			f"webhooks/{self._client.bot.id}/{self.token}/messages/@original",
423			data,
424			content_type=content_type
425			)
426			self.__post_sent(message)
427			return UserMessage.from_dict(resp)
428
429			async def delete(self):
430			"""\|coro\|
431
432			Delete the interaction.
433
434			Raises
435			------
436			:class:`~pincer.errors.InteractionDoesNotExist`
437			Exception raised when no reply has been sent.
438			"""
439			if not self.has_replied:
440			raise InteractionDoesNotExist(
441			"The interaction whom you are trying to delete has not "
442			"been sent yet!"
443			)
444
445			await self._http.delete(
446			f"webhooks/{self._client.bot.id}/{self.token}/messages/@original"
447			)
448
449			async def __post_followup_send_handler(
450			self,
451			followup: UserMessage,
452			message: Message
453			):
454			"""Process a folloup after it was sent.
455
456			Parameters
457			----------
458			followup :class:`~pincer.objects.message.user_message.UserMessage`
459			The followup message that is being post processed.
460			message :class:`~pincer.objects.message.message.Message`
461			The followup message.
462			"""
463
464			if message.delete_after:
465			await sleep(message.delete_after)
466			await self.delete_followup(followup.id)
467
468			def __post_followup_sent(
469			self,
470			followup: UserMessage,
471			message: Message
472			):
473			"""Ensure the `__post_followup_send_handler` method its future.
474
475			Parameters
476			----------
477			followup :class:`~pincer.objects.message.user_message.UserMessage`
478			The followup message that is being post processed.
479			message :class:`~pincer.objects.message.message.Message`
480			The followup message.
481			"""
482			ensure_future(self.__post_followup_send_handler(followup, message))
483
484			async def followup(self, message: MessageConvertable) -> UserMessage:
485			"""\|coro\|
486
487			Create a follow up message for the interaction.
488			This allows you to respond with multiple messages.
489
490			Parameters
491			----------
492			message :class:`~pincer.utils.convert_message.MessageConvertable`
493			The message to sent.
494
495			Returns
496			-------
497			:class:`~pincer.objects.message.user_message.UserMessage`
498			The message that has been sent.
499			"""
500			message = convert_message(self._client, message)
501			content_type, data = message.serialize()
502
503			resp = await self._http.post(
504			f"webhooks/{self._client.bot.id}/{self.token}",
505			data,
506			content_type=content_type
507			)
508			msg = UserMessage.from_dict(resp)
509			self.__post_followup_sent(msg, message)
510			return msg
511
512			async def edit_followup(
513			self,
514			message_id: int,
515			message: MessageConvertable
516			) -> UserMessage:
517			"""\|coro\|
518
519			Edit a followup message.
520
521			Parameters
522			----------
523			message_id :class:`int`
524			The id of the original followup message.
525			message :class:`~pincer.utils.convert_message.MessageConvertable`
526			The message new message.
527
528			Returns
529			-------
530			:class:`~pincer.objects.message.user_message.UserMessage`
531			The updated message object.
532			"""
533			message = convert_message(self._client, message)
534			content_type, data = message.serialize()
535
536			resp = await self._http.patch(
537			f"webhooks/{self._client.bot.id}/{self.token}/messages/{message_id}",
538			data,
539			content_type=content_type
540			)
541			msg = UserMessage.from_dict(resp)
542			self.__post_followup_sent(msg, message)
543			return msg
544
545			async def get_followup(self, message_id: int) -> UserMessage:
546			"""\|coro\|
547
548			Get a followup message by id.
549
550			Parameters
551			----------
552			message_id :class:`int`
553			The id of the original followup message that must be fetched.
554
555			Returns
556			-------
557			:class:`~pincer.objects.message.user_message.UserMessage`
558			The fetched message object.
559			"""
560
561			resp = await self._http.get(
562			f"webhooks/{self._client.bot.id}/{self.token}/messages/{message_id}",
563			)
564			return UserMessage.from_dict(resp)
565
566			async def delete_followup(self, message: Union[UserMessage, int]):
567			"""\|coro\|
568
569			Remove a followup message by id.
570
571			Parameters
572			----------
573			message Union[:class:`~pincer.objects.user_message.UserMessage`, :class:`int`]
574			The id/followup object of the followup message that must be deleted.
575			"""
576			message_id = message if isinstance(message, int) else message.id
577
578			await self._http.delete(
579			f"webhooks/{self._client.bot.id}/{self.token}/messages/{message_id}",
580			)
581

Pincer-org / Pincer

Pull Request — main (#167)

pincer.objects.app.interactions.Interaction.ack() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like