Merge pull request #107 from AnotherCat/new-ui-changes

Change context and http to reflect upcoming changes

Author: eunwoo1104

discord_slash/context.py

@@ -22,10 +22,12 @@ class SlashContext:
     :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 deffered: Whether the command is current deffered (loading state)
+    :ivar _deffered_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.
@@ -46,8 +48,10 @@ def __init__(self,
         self.command_id = _json["data"]["id"]
         self._http = _http
         self.bot = _discord
-        self.logger = logger
-        self.sent = False
+        self._logger = logger
+        self.deffered = False
+        self.responded = False
+        self._deffered_hidden = False  # To check if the patch to the deffered 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"])
@@ -76,39 +80,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.
+        'Deferes' the response, showing a loading state to the user
 
-        .. 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.
-
-        :param eat: Whether to eat user's input. Default ``False``.
+        :param hidden: Whether the deffered 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.deffered or self.responded:
+            raise error.AlreadyResponded("You have already responded to this command!")
+        base = {"type": 5}
+        if hidden:
+            base["data"] = {"flags": 64}
+            self._deffered_hidden = True
+        await self._http.post_initial_response(base, self.interaction_id, self.__token)
+        self.deffered = True
 
     async def send(self,
                    content: str = "", *,
@@ -129,6 +114,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 +136,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 +149,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 +159,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.deffered:
+                if self._deffered_hidden != hidden:
+                    self._logger.warning(
+                        "Deffered response might not be what you set it to! (hidden / visible) "
+                        "This is because it was deffered in a different state"
+                    )
+                resp = await self._http.edit(base, self.__token)
+                self.deffered = 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

@@ -54,3 +54,8 @@ class IncorrectType(SlashCommandError):
     """
     Type passed was incorrect
     """
+
+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)
+

docs/faq.rst

@@ -109,7 +109,7 @@ Pretty much anything from the discord's commands extension doesn't work, also so
 .. warning::
    If you use something that might take a while, eg ``wait_for`` you'll run into two issues:
 
-   1. If you don't respond within 3 seconds (``ctx.respond()``) discord invalidates the interaction.
+   1. If you don't respond within 3 seconds (``ctx.defer()`` or `ctx.send(..)``) discord invalidates the interaction.
    2. The interaction only lasts for 15 minutes, so if you try and send something with the interaction (``ctx.send``) more than 15 mins after the command was ran it won't work.
 
    As an alternative you can use ``ctx.channel.send`` but this relies on the the bot being in the guild, and the bot having send perms in that channel.

docs/gettingstarted.rst

@@ -54,17 +54,12 @@ code as shown below:
   @slash.slash(name="test",
                description="This is just a test command, nothing more.")
   async def test(ctx):
-    await ctx.respond()
     await ctx.send(content="Hello World!")
     
 Now that we've gone over how Discord handles the declaration of slash commands
 through their Bot API, let's go over what some of the other things mean within
 the *logical* part of our code, the command function:
 
-- ``ctx.respond()``: This is a way for us to handle responses. In short, the API
-requires some way to "acknowledge" an interaction response that we want to send off.
-
-(An alias of this would be ``ctx.ack()``)
 
 Giving some options for variety.
 --------------------------------
@@ -163,7 +158,6 @@ Now, we can finally visualize this by coding an example of this being used in th
                  )
                ])
   async def test(ctx, optone: str):
-    await ctx.respond()
     await ctx.send(content=f"I got you, you said {optone}!")
     
 Additionally, we could also declare the type of our command's option through this method shown here:
@@ -233,7 +227,6 @@ a string or integer. Below is an implementation of this design in the Python cod
                  )
                ])
   async def test(ctx, optone: str):
-    await ctx.respond()
     await ctx.send(content=f"Wow, you actually chose {optone}? :(")
 
 .. _quickstart: https://discord-py-slash-command.readthedocs.io/en/latest/quickstart.html

docs/index.rst

@@ -26,7 +26,7 @@ discussion on GitHub!
 
    quickstart.rst
    gettingstarted.rst
-   migrate_to_109.rst
+   migration.rst
    discord_slash.rst
    events.rst
    discord_slash.utils.rst