Change context and http to reflect upcoming changes

Author: quirky-bluejay

discord_slash/context.py

@@ -20,12 +20,14 @@ class SlashContext:
     :ivar name: Name of 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 _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 _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 _sent: Whether you sent the initial response.
     :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.
@@ -42,12 +44,14 @@ def __init__(self,
         self.name = self.command = self.invoked_with = _json["data"]["name"]
         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._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._deffered = False
+        self._sent = 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,18 @@ def channel(self) -> typing.Optional[typing.Union[discord.abc.GuildChannel, disc
         """
         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
+        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 +112,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
@@ -152,13 +136,6 @@ async def send(self,
         """
         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:
@@ -180,27 +157,38 @@ 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 {}
         }
+        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._sent:
+            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:
+                base["type"] = 4
+                resp = await self._http.post_initial_response(base, self._interaction_id, self.__token)
+            self._sent = True
+        else:
+            resp = await self._http.post_followup(base, self.__token, files=files)
 
-        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))
+        if initial_message:
+            self.message = smsg
         return smsg
-
-    def send_hidden(self, content: str = ""):
-        """
-        Sends hidden response.\n
-        This is automatically used if you pass ``hidden=True`` at :meth:`.send`.
-
-        :param content: Message content.
-        :return: Coroutine
-        """
-        base = {
-            "content": content,
-            "flags": 64
-        }
-        return self._http.post(base, self.interaction_id, self.__token)

discord_slash/http.py

@@ -3,6 +3,7 @@
 import aiohttp
 import discord
 from discord.http import Route
+from . import error
 
 
 class CustomRoute(Route):
@@ -78,49 +79,73 @@ 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._discord.user.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._discord.user.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._discord.user.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._discord.user.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"):
         """
@@ -130,6 +155,5 @@ def delete(self, token, message_id="@original"):
         :param message_id: Message ID to delete. Default initial message.
         :return: Coroutine
         """
-        req_url = f"/webhooks/{self._discord.user.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)