added hidden responses, issues fixed

Author: kuso-senpai

README.md

@@ -196,9 +196,9 @@ Buttons(client: discord.ext.commands.client)
     <summary><b>send</b></summary>
 
     ```py
-    async def send(self, channel, content = None, *, tts = False, embed = None,
-                embeds = None, file = None, files = None, delete_after = None, nonce = None,
-                allowed_mentions = None, reference = None, mention_author = None, buttons = None
+    async def send(self, channel, content=None, *, tts=False, embed=None,
+                embeds=None, file=None, files = None, delete_after = None, nonce = None,
+                allowed_mentions=None, reference=None, mention_author=None, buttons=None
             ) -> Message:
     ```
 
@@ -208,8 +208,6 @@ Buttons(client: discord.ext.commands.client)
 
     - channel: `discord.TextChannel`
         > The textchannel where the message should be sent
-        >
-        > __Required__
 
     - content: `str`
         > The text content of the message
@@ -499,23 +497,30 @@ Extends the `Message` object
 - pressedButton: `Button`
     > The button which was pressed
 
-- acknowledged: `bool`
-    > Whether the message was acknowledged
+- deferred: `bool`
+    > Whether the message was deferred
 
 </details>
 
 <details>
 <summary><b>Methods</b></summary>
 
 -   <details>
-    <summary>acknowledge: <code>function</code></summary>
+    <summary>defer: <code>function</code></summary>
 
-    Acknowledges that the interaction was received
+    defers that the interaction was received
 
     ```py
-    def acknowledge():
+    async def defer(hidden = False):
     ```
 
+    _| coroutine |_
+
+    #### **Parameters**
+
+    - hidden
+        > Whether the loading thing will be shown only to the user
+
     > This function should be used if your client needs more than 15 seconds to responod
 
     </details>
@@ -527,7 +532,7 @@ Extends the `Message` object
     ```py
     async def respond(self, content=None, *, tts=False,
             embed = None, embeds=None, file=None, files=None, nonce=None,
-            allowed_mentions=None, mention_author=None, buttons=None,
+            allowed_mentions=None, mention_author=None, buttons=None, hidden=False,
         ninjaMode = False) -> Message or None:
     ```
 
@@ -564,6 +569,9 @@ Extends the `Message` object
 
     - buttons: `List[Button]`
         > A list of buttons in this message
+    
+    - hidden: `bool`
+        > Whether the message should be only visible to the user
 
     - ninjaMode: `bool`
         > Whether the client should respond silent like a ninja to the interaction
@@ -572,7 +580,7 @@ Extends the `Message` object
 
     #### **Returns**
     - `Message or None`
-        > The sent message if ninjaMode is false
+        > The sent message if ninjaMode and hidden are both set to false
 
     </details>
 </details>
@@ -617,19 +625,41 @@ Added events for `client.wait_for` and `client.listen`
 # Changelog
 
 
+-   <details>
+    <summary>1.1.0</summary>
+
+    ### **Changed**
+    - Major changes to request code, now using the client's request
+    - `ResponseMessage.acknowledge()` -> `ResponseMessage.defer()`
+        > Changed the name of the function + changed `ResponseMessage.acknowledged` -> `ResponseMessage.deferred`
+    - `ResponseMessage.defer()` => `await ResponseMessage.defer()`
+        > `defer` (`acknowledge`) is now async and needs to be awaited
+
+    ### **Added**
+    - hidden responses
+        > You can now send responses only visible to the user
+    
+
+    ### **Fixed**
+    - `ResponseMessage.respond()`
+        > Now doesn't show a failed interaction
+ 
+
+    </details>
+
 -   <details>
     <summary>1.0.5</summary>
 
     ### **Fixed**
     - `ResponseMessage.respond()`
-        > responding now doesn't fail after sending the message, it will now acknowledge the interaction by it self if not already acknowledged and then send the message
+        > responding now doesn't fail after sending the message, it will now defer the interaction by it self if not already deferred and then send the message
 
 -   <details>
     <summary>1.0.4</summary>
 
     ### **Added**
     - `ResponseMessage.acknowledged`
-        > If the message was acknowledged with the `ResponseMessage.acknowledge()` function, the variable will be set to true
+        > Whether the message was acknowledged with the `ResponseMessage.acknowledged()` function
 
     ### **Changed**
 

discord_py_buttons/__init__.py

@@ -2,4 +2,4 @@
 from .buttons import Button, LinkButton, Colors
 from .receive import ResponseMessage, Message, PressedButton
 
-__version__ = "1.0.5"
+__version__ = "1.1.0"

discord_py_buttons/client.py

@@ -1,4 +1,5 @@
-from . import apiRequests
+from typing import List
+from .tools import jsonifyMessage, V8Route
 from .receive import Message, getResponseMessage
 
 import discord
@@ -61,7 +62,7 @@ async def on_socket_response(self, msg):
 
 
     async def send(self, channel: discord.TextChannel, content=None, *, tts=False,
-            embed=None, embeds=None, file=None, files=None, delete_after=None, nonce=None,
+            embed=None, embeds=None, file: discord.File=None, files: List[discord.File]=None, delete_after=None, nonce=None,
             allowed_mentions=None, reference=None, mention_author=None, buttons=None
         ) -> Message:
         """
@@ -133,14 +134,14 @@ async def send(self, channel: discord.TextChannel, content=None, *, tts=False,
         if type(channel) != discord.TextChannel:
             raise discord.InvalidArgument("Channel must be of type discord.TextChannel")
 
-        r = apiRequests.POST(self._discord.http.token, f"{apiRequests.url}/channels/{channel.id}/messages", data=apiRequests.jsonifyMessage(content, tts=tts, embed=embed, embeds=embeds, file=file, files=files, nonce=nonce, allowed_mentions=allowed_mentions, reference=reference, mention_author=mention_author, buttons=buttons))
-        if r.status_code == 403:
-            raise discord.ClientException(r.json(), "Got forbidden response")
-        if r.status_code != 200:
-            raise Exception(r.json())
+        payload = jsonifyMessage(content, tts=tts, embed=embed, embeds=embeds, nonce=nonce, allowed_mentions=allowed_mentions, reference=reference, mention_author=mention_author, buttons=buttons)
+        
 
-        msg = await getResponseMessage(self._discord, r.json(), response=False)
+        route = V8Route("POST", f"/channels/{channel.id}/messages")
 
+        r = await self._discord.http.request(route, json=payload)
+        msg = await getResponseMessage(self._discord, r, response=False)
+            
         if delete_after is not None:
             await msg.delete(delay=delete_after)
 

discord_py_buttons/receive.py

@@ -1,5 +1,5 @@
 from .buttons import Button, LinkButton
-from .apiRequests import POST, url, jsonifyMessage
+from .tools import V8Route, jsonifyMessage
 
 import discord
 from discord.ext import commands
@@ -219,12 +219,12 @@ class ResponseMessage(Message):
     ----------------
     pressedButton: `PressedButton`
         The button which was presed
-    acknowledge: `function`
-        Function to acknowledge the button-press interaction
+    defer: `function`
+        Function to defer the button-press interaction
     respond: `function`
         Function to respond to the buttonPress interaction
-    acknowledged: `bool`
-        Whether the button was acknowledged with the acknowledge functionn
+    deferred: `bool`
+        Whether the button was deferred with the defer functionn
 
     Attributes
     ----------------
@@ -336,23 +336,22 @@ def __init__(self, *, state, channel, data, user, client):
             if hasattr(x, 'custom_id') and x.custom_id == data["data"]["custom_id"]:
                 self.pressedButton = PressedButton(data, user, x)
 
-    def acknowledge(self):
+    async def defer(self, hidden=False):
         """
         This will acknowledge the interaction. This will show the (*Bot* is thinking...) Dialog
 
         This function should be used if the Bot needs more than 15 seconds to respond
         """
 
-        r = POST(self._discord.http.token, f'{url}/interactions/{self.pressedButton.interaction["id"]}/{self.pressedButton.interaction["token"]}/callback', {
-            "type": 5
-        })
-        if r.status_code == 403:
-            raise discord.ClientException(r.json(), "forbidden")
-
-        self.acknowledged = True
+        body = {"type": 5}
+        if hidden == True:
+            body |= { "flags": 64 }
+        
+        await self._discord.http.request(V8Route("POST", f'/interactions/{self.pressedButton.interaction["id"]}/{self.pressedButton.interaction["token"]}/callback'), json=body)
+        self.deferred = True
 
     async def respond(self, content=None, *, tts=False, embed = None, embeds=None, file=None, files=None, nonce=None,
-        allowed_mentions=None, mention_author=None, buttons=None,
+        allowed_mentions=None, mention_author=None, buttons=None, hidden=False,
         ninjaMode = False) -> Message or None:
         """
         | coro |
@@ -402,7 +401,10 @@ async def respond(self, content=None, *, tts=False, embed = None, embeds=None, f
         List[Button] buttons
         ```
             A list of Buttons for the message to be included
-
+        ```py
+        (bool) hidden
+        ```
+        Whether the response should be visible only to the user 
         ```py
         (bool) ninjaMode
         ```
@@ -416,23 +418,22 @@ async def respond(self, content=None, *, tts=False, embed = None, embeds=None, f
         The sent message if ninjaMode is false, otherwise `None` 
 
         """
-        msg = None
-        if not ninjaMode:
-            json = jsonifyMessage(content=content, tts=tts, embed=embed, embeds=embeds, file=file, files=files, nonce=nonce, allowed_mentions=allowed_mentions, reference=discord.MessageReference(message_id=self.id, channel_id=self.channel.id), mention_author=mention_author, buttons=buttons)
-            r = POST(token=self._discord.http.token, URL=(url + f"/channels/{self.channel.id}/messages"), data=json)
-            
-            if not self.acknowledged:
-                # Preventing the interaction to fail while fetching the channel
-                self.acknowledge()
-            msg = await getResponseMessage(self._discord, r.json(), response=False)
+        if ninjaMode:
+            await self._discord.http.request(V8Route("POST", f'/interactions/{self.pressedButton.interaction["id"]}/{self.pressedButton.interaction["token"]}/callback'), json={
+                "type": 6
+            })
+            return
+
+        body = jsonifyMessage(content=content, tts=tts, embed=embed, embeds=embeds, nonce=nonce, allowed_mentions=allowed_mentions, reference=discord.MessageReference(message_id=self.id, channel_id=self.channel.id), mention_author=mention_author, buttons=buttons)
 
-        r = POST(self._discord.http.token, f'https://discord.com/api/v8/interactions/{self.pressedButton.interaction["id"]}/{self.pressedButton.interaction["token"]}/callback', {
-            "type": 6
-        })
+        if hidden:
+            body |= {"flags": 64}
 
-        if r.status_code == 403:
-            raise discord.ClientException(r.json(), "Forbidden")
-        if r.status_code == 400:
-            raise discord.ClientException(r.json(), "Error while sending message")
-    
-        return msg
+        await self._discord.http.request(V8Route("POST", f'/interactions/{self.pressedButton.interaction["id"]}/{self.pressedButton.interaction["token"]}/callback'), json={
+            "type": 4,
+            "data": body
+        })
+        if not hidden:
+            responseMSG = await self._discord.http.request(V8Route("GET", f"/webhooks/{self._discord.user.id}/{self.pressedButton.interaction['token']}/messages/@original"))
+            
+            return await getResponseMessage(self._discord, responseMSG, response=False)

discord_py_buttons/apiRequests.py renamed to discord_py_buttons/tools.py

@@ -1,29 +1,19 @@
 from .buttons import Button
+from discord.http import Route
 
 import discord
 
-import requests
 from typing import List
 
 url = "https://discord.com/api/v8"
 
 
-def POST(token, URL, data):
-    """POST request with the Bot token in the Authorization Header"""
-    return requests.post(URL,
-        json=data, headers={"Authorization": f"Bot {token}"})
-def GET(token, URL):
-    """GET request with the Bot token in the Authorization Header"""
-    return requests.get(URL,
-        headers={"Authorization": f"Bot {token}"})
-def DELETE(token, URL):
-    """DELETE request with the Bot token in the Authorization Header"""
-    return requests.delete(URL,
-        headers={"Authorization": f"Bot {token}"})
+class V8Route(Route):
+    BASE = "https://discord.com/api/v8"
 
 def jsonifyMessage(content = None, *, tts=False,
-            embed: discord.Embed = None, embeds: List[discord.Embed], file: discord.File = None, files: List[discord.File] = None, nonce: int = None,
-            allowed_mentions: discord.AllowedMentions = None, reference: discord.MessageReference = None, mention_author: bool = None, buttons: List[Button] = None):
+                embed: discord.Embed = None, embeds: List[discord.Embed], nonce: int = None,
+                allowed_mentions: discord.AllowedMentions = None, reference: discord.MessageReference = None, mention_author: bool = None, buttons: List[Button] = None):
     """Turns parameters from the `discord.TextChannel.send` function into json for requests"""
     payload = { "tts": tts }
 
@@ -33,18 +23,6 @@ def jsonifyMessage(content = None, *, tts=False,
     if nonce is not None:
         payload["nonce"] = nonce
 
-    if file is not None and files is not None:
-        raise discord.InvalidArgument("cannot pass both 'files' and 'file' parameter")
-    
-    if file is not None:
-        if type(file) is not discord.File:
-            raise TypeError("file must be of type discord.File")
-        raise Exception("sending file is not supportet in this version, instead try using the normal discord.TextChannel.send(file=yourFile) function until this is completed")
-    if files is not None:
-        if type(file) is not discord.File:
-            raise TypeError("file must be of type discord.File")
-        raise Exception("sending files is not supportet in this version, instead try using the normal discord.TextChannel.send(files=[yourFiles...]) function until this is completed")
-
     if embed is not None and embeds is not None:
         raise discord.InvalidArgument("cannot pass both 'embed' and 'embeds' parameter")