Merge branch 'master' into anothercat/prevent-uneeded-requests-autoregister

Author: quirky-bluejay

.github/PULL_REQUEST_TEMPLATE.md

@@ -13,5 +13,5 @@ What changes were made?
     - Issue:
 - [ ] This adds something new.
 - [ ] There is/are breaking change(s).
-- [ ] (If required) Relavent documentation has been updated/added.
+- [ ] (If required) Relevant documentation has been updated/added.
 - [ ] This is not a code change. (README, docs, etc.)

discord_slash/__init__.py

@@ -13,4 +13,4 @@
 from .context import SlashContext
 from .utils import manage_commands
 
-__version__ = "1.0.9.5"
+__version__ = "1.1.1"

discord_slash/client.py

@@ -729,12 +729,15 @@ async def invoke_command(self, func, ctx, args):
         try:
             not_kwargs = False
             if isinstance(args, dict):
+                ctx.kwargs = args
+                ctx.args = list(args.values())
                 try:
                     await func.invoke(ctx, **args)
                 except TypeError:
                     args = list(args.values())
                     not_kwargs = True
             else:
+                ctx.args = args
                 not_kwargs = True
             if not_kwargs:
                 await func.invoke(ctx, *args)
@@ -873,5 +876,5 @@ async def on_slash_command_error(ctx, ex):
         if hasattr(self._discord, "on_slash_command_error"):
             self._discord.dispatch("slash_command_error", ctx, ex)
             return
-        # Prints exception if not overrided or has no listener for error.
+        # Prints exception if not overridden or has no listener for error.
         self.logger.exception(f"An exception has occurred while executing command `{ctx.name}`:")

discord_slash/context.py

@@ -1,5 +1,7 @@
 import typing
 import asyncio
+from warnings import warn
+
 import discord
 from contextlib import suppress
 from discord.ext import commands
@@ -18,14 +20,18 @@ class SlashContext:
 
     :ivar message: Message that invoked the slash command.
     :ivar name: Name of the command.
+    :ivar args: List of processed arguments invoked with the command.
+    :ivar kwargs: Dictionary of processed arguments invoked with the command.
     :ivar subcommand_name: Subcommand of the command.
     :ivar subcommand_group: Subcommand group of the command.
     :ivar interaction_id: Interaction ID of the command message.
     :ivar command_id: ID of the command.
-    :ivar _http: :class:`.http.SlashCommandRequest` of the client.
     :ivar bot: discord.py client.
-    :ivar logger: Logger instance.
-    :ivar sent: Whether you sent the initial response.
+    :ivar _http: :class:`.http.SlashCommandRequest` of the client.
+    :ivar _logger: Logger instance.
+    :ivar deferred: Whether the command is current deferred (loading state)
+    :ivar _deferred_hidden: Internal var to check that state stays the same
+    :ivar responded: Whether you have responded with a message to the interaction.
     :ivar guild_id: Guild ID of the command message. If the command was invoked in DM, then it is ``None``
     :ivar author_id: User ID representing author of the command message.
     :ivar channel_id: Channel ID representing channel of the command message.
@@ -40,14 +46,18 @@ def __init__(self,
         self.__token = _json["token"]
         self.message = None # Should be set later.
         self.name = self.command = self.invoked_with = _json["data"]["name"]
+        self.args = []
+        self.kwargs = {}
         self.subcommand_name = self.invoked_subcommand = self.subcommand_passed = None
         self.subcommand_group = self.invoked_subcommand_group = self.subcommand_group_passed = None
         self.interaction_id = _json["id"]
         self.command_id = _json["data"]["id"]
         self._http = _http
         self.bot = _discord
-        self.logger = logger
-        self.sent = False
+        self._logger = logger
+        self.deferred = False
+        self.responded = False
+        self._deferred_hidden = False  # To check if the patch to the deferred response matches
         self.guild_id = int(_json["guild_id"]) if "guild_id" in _json.keys() else None
         self.author_id = int(_json["member"]["user"]["id"] if "member" in _json.keys() else _json["user"]["id"])
         self.channel_id = int(_json["channel_id"])
@@ -58,6 +68,26 @@ def __init__(self,
         else:
             self.author = discord.User(data=_json["user"], state=self.bot._connection)
 
+    @property
+    def _deffered_hidden(self):
+        warn("`_deffered_hidden` as been renamed to `_deferred_hidden`.", DeprecationWarning, stacklevel=2)
+        return self._deferred_hidden
+
+    @_deffered_hidden.setter
+    def _deffered_hidden(self, value):
+        warn("`_deffered_hidden` as been renamed to `_deferred_hidden`.", DeprecationWarning, stacklevel=2)
+        self._deferred_hidden = value
+
+    @property
+    def deffered(self):
+        warn("`deffered` as been renamed to `deferred`.", DeprecationWarning, stacklevel=2)
+        return self.deferred
+
+    @deffered.setter
+    def deffered(self, value):
+        warn("`deffered` as been renamed to `deferred`.", DeprecationWarning, stacklevel=2)
+        self.deferred = value
+
     @property
     def guild(self) -> typing.Optional[discord.Guild]:
         """
@@ -76,39 +106,20 @@ def channel(self) -> typing.Optional[typing.Union[discord.TextChannel, discord.D
         """
         return self.bot.get_channel(self.channel_id)
 
-    async def respond(self, eat: bool = False):
+    async def defer(self, hidden: bool = False):
         """
-        Sends command invoke response.\n
-        You should call this first.
-
-        .. note::
-            - If `eat` is ``False``, there is a chance that ``message`` variable is present.
-            - While it is recommended to be manually called, this will still be automatically called
-              if this isn't called but :meth:`.send()` is called.
+        'Defers' the response, showing a loading state to the user
 
-        :param eat: Whether to eat user's input. Default ``False``.
+        :param hidden: Whether the deferred response should be ephemeral . Default ``False``.
         """
-        base = {"type": 2 if eat else 5}
-        _task = self.bot.loop.create_task(self._http.post(base, self.interaction_id, self.__token, True))
-        self.sent = True
-        if not eat and (not self.guild_id or (self.channel and self.channel.permissions_for(self.guild.me).view_channel)):
-            with suppress(asyncio.TimeoutError):
-                def check(message: discord.Message):
-                    user_id = self.author_id
-                    is_author = message.author.id == user_id
-                    channel_id = self.channel_id
-                    is_channel = channel_id == message.channel.id
-                    is_user_input = message.type == 20
-                    is_correct_command = message.content.startswith(f"</{self.name}:{self.command_id}>")
-                    return is_author and is_channel and is_user_input and is_correct_command
-
-                self.message = await self.bot.wait_for("message", timeout=3, check=check)
-        await _task
-
-    @property
-    def ack(self):
-        """Alias of :meth:`.respond`."""
-        return self.respond
+        if self.deferred or self.responded:
+            raise error.AlreadyResponded("You have already responded to this command!")
+        base = {"type": 5}
+        if hidden:
+            base["data"] = {"flags": 64}
+            self._deferred_hidden = True
+        await self._http.post_initial_response(base, self.interaction_id, self.__token)
+        self.deferred = True
 
     async def send(self,
                    content: str = "", *,
@@ -129,6 +140,7 @@ async def send(self,
         .. warning::
             - Since Release 1.0.9, this is completely changed. If you are migrating from older version, please make sure to fix the usage.
             - You can't use both ``embed`` and ``embeds`` at the same time, also applies to ``file`` and ``files``.
+            - You cannot send files in the initial response
 
         :param content:  Content of the response.
         :type content: str
@@ -150,15 +162,6 @@ async def send(self,
         :type delete_after: float
         :return: Union[discord.Message, dict]
         """
-        if isinstance(content, int) and 2 <= content <= 5:
-            raise error.IncorrectFormat("`.send` Method is rewritten at Release 1.0.9. Please read the docs and fix all the usages.")
-        if not self.sent:
-            self.logger.info(f"At command `{self.name}`: It is recommended to call `.respond()` first!")
-            await self.respond(eat=hidden)
-        if hidden:
-            if embeds or embed or files or file:
-                self.logger.warning("Embed/File is not supported for `hidden`!")
-            return await self.send_hidden(content)
         if embed and embeds:
             raise error.IncorrectFormat("You can't use both `embed` and `embeds`!")
         if embed:
@@ -172,6 +175,8 @@ async def send(self,
             raise error.IncorrectFormat("You can't use both `file` and `files`!")
         if file:
             files = [file]
+        if delete_after and hidden:
+            raise error.IncorrectFormat("You can't delete a hidden message!")
 
         base = {
             "content": content,
@@ -180,30 +185,47 @@ async def send(self,
             "allowed_mentions": allowed_mentions.to_dict() if allowed_mentions
             else self.bot.allowed_mentions.to_dict() if self.bot.allowed_mentions else {}
         }
-
-        resp = await self._http.post(base, self.interaction_id, self.__token, files=files)
-        smsg = model.SlashMessage(state=self.bot._connection,
-                                  data=resp,
-                                  channel=self.channel or discord.Object(id=self.channel_id),
-                                  _http=self._http,
-                                  interaction_token=self.__token)
-        if delete_after:
-            self.bot.loop.create_task(smsg.delete(delay=delete_after))
-        return smsg
-
-    def send_hidden(self, content: str = ""):
-        """
-        Sends hidden response.\n
-        This is automatically used if you pass ``hidden=True`` at :meth:`.send`.
-
-        .. note::
-            This is not intended to be manually called. Please use :meth:`.send` instead.
-
-        :param content: Message content.
-        :return: Coroutine
-        """
-        base = {
-            "content": content,
-            "flags": 64
-        }
-        return self._http.post(base, self.interaction_id, self.__token)
+        if hidden:
+            if embeds or files:
+                self._logger.warning("Embed/File is not supported for `hidden`!")
+            base["flags"] = 64
+
+        initial_message = False
+        if not self.responded:
+            initial_message = True
+            if files:
+                raise error.IncorrectFormat("You cannot send files in the initial response!")
+            if self.deferred:
+                if self._deferred_hidden != hidden:
+                    self._logger.warning(
+                        "deferred response might not be what you set it to! (hidden / visible) "
+                        "This is because it was deferred in a different state"
+                    )
+                resp = await self._http.edit(base, self.__token)
+                self.deferred = False
+            else:
+                json_data = {
+                    "type": 4,
+                    "data": base
+                }
+                await self._http.post_initial_response(json_data, self.interaction_id, self.__token)
+                if not hidden:
+                    resp = await self._http.edit({}, self.__token)
+                else:
+                    resp = {}
+            self.responded = True
+        else:
+            resp = await self._http.post_followup(base, self.__token, files=files)
+        if not hidden:
+            smsg = model.SlashMessage(state=self.bot._connection,
+                                      data=resp,
+                                      channel=self.channel or discord.Object(id=self.channel_id),
+                                      _http=self._http,
+                                      interaction_token=self.__token)
+            if delete_after:
+                self.bot.loop.create_task(smsg.delete(delay=delete_after))
+            if initial_message:
+                self.message = smsg
+            return smsg
+        else:
+            return resp

discord_slash/error.py

@@ -55,7 +55,14 @@ class IncorrectType(SlashCommandError):
     Type passed was incorrect
     """
 
+
 class IncorrectCommandData(SlashCommandError):
     """
     Incorrect data was passed to a slash command data object
     """
+    
+
+class AlreadyResponded(SlashCommandError):
+    """
+    The interaction was already responded to
+    """

discord_slash/http.py

@@ -3,6 +3,7 @@
 import aiohttp
 import discord
 from discord.http import Route
+from . import error
 
 
 class CustomRoute(Route):
@@ -83,49 +84,75 @@ def command_request(self, method, guild_id, url_ending="", **kwargs):
         route = CustomRoute(method, url)
         return self._discord.http.request(route, **kwargs)
 
-    def post(self, _resp, interaction_id, token, initial=False, files: typing.List[discord.File] = None):
+    def post_followup(self, _resp, token, files: typing.List[discord.File] = None):
         """
-        Sends command response POST request to Discord API.
+        Sends command followup response POST request to Discord API.
 
         :param _resp: Command response.
         :type _resp: dict
-        :param interaction_id: Interaction ID.
         :param token: Command message token.
-        :param initial: Whether this request is initial. Default ``False``
         :param files: Files to send. Default ``None``
         :type files: List[discord.File]
         :return: Coroutine
         """
         if files:
             return self.post_with_files(_resp, files, token)
-        req_url = f"/interactions/{interaction_id}/{token}/callback" if initial else f"/webhooks/{self.application_id}/{token}"
-        route = CustomRoute("POST", req_url)
-        return self._discord.http.request(route, json=_resp)
+        return self.command_response(token, True, "POST", json=_resp)
+
+    def post_initial_response(self, _resp, interaction_id, token):
+        """
+        Sends an initial "POST" response to the Discord API.
+         
+        :param _resp: Command response.
+        :type _resp: dict
+        :param interaction_id: Interaction ID.
+        :param token: Command message token.
+        :return: Coroutine
+        """
+        return self.command_response(token, False, "POST", interaction_id, json=_resp)
+
+    def command_response(self, token, use_webhook, method, interaction_id= None, url_ending = "", **kwargs):
+        """
+        Sends a command response to discord (POST, PATCH, DELETE)
+
+        :param token: Interaction token
+        :param use_webhook: Whether to use webhooks
+        :param method: The HTTP request to use
+        :param interaction_id: The id of the interaction
+        :param url_ending: String to append onto the end of the url.
+        :param \**kwargs: Kwargs to pass into discord.py's `request function <https://github.com/Rapptz/discord.py/blob/master/discord/http.py#L134>`_
+        :return: Coroutine
+        """
+        if not use_webhook and not interaction_id:
+            raise error.IncorrectFormat("Internal Error! interaction_id must be set if use_webhook is False")
+        req_url = f"/webhooks/{self.application_id}/{token}" if use_webhook else f"/interactions/{interaction_id}/{token}/callback"
+        req_url += url_ending
+        route = CustomRoute(method, req_url)
+        return self._discord.http.request(route, **kwargs)
 
     def post_with_files(self, _resp, files: typing.List[discord.File], token):
-        req_url = f"/webhooks/{self.application_id}/{token}"
-        route = CustomRoute("POST", req_url)
+
         form = aiohttp.FormData()
         form.add_field("payload_json", json.dumps(_resp))
         for x in range(len(files)):
             name = f"file{x if len(files) > 1 else ''}"
             sel = files[x]
             form.add_field(name, sel.fp, filename=sel.filename, content_type="application/octet-stream")
-        return self._discord.http.request(route, data=form, files=files)
+        return self.command_response(token, True, "POST", data=form, files=files)
 
     def edit(self, _resp, token, message_id="@original"):
         """
-        Sends edit command response POST request to Discord API.
+        Sends edit command response PATCH request to Discord API.
 
         :param _resp: Edited response.
         :type _resp: dict
         :param token: Command message token.
         :param message_id: Message ID to edit. Default initial message.
         :return: Coroutine
         """
-        req_url = f"/webhooks/{self.application_id}/{token}/messages/{message_id}"
-        route = CustomRoute("PATCH", req_url)
-        return self._discord.http.request(route, json=_resp)
+        req_url = f"/messages/{message_id}"
+        return self.command_response(token, True, "PATCH", url_ending = req_url, json=_resp)
+
 
     def delete(self, token, message_id="@original"):
         """
@@ -135,6 +162,6 @@ def delete(self, token, message_id="@original"):
         :param message_id: Message ID to delete. Default initial message.
         :return: Coroutine
         """
-        req_url = f"/webhooks/{self.application_id}/{token}/messages/{message_id}"
-        route = CustomRoute("DELETE", req_url)
-        return self._discord.http.request(route)
+        req_url = f"/messages/{message_id}"
+        return self.command_response(token, True, "DELETE", url_ending = req_url)
+