merged v5 into main

Author: kvsxxx

.gitignore

@@ -133,4 +133,4 @@ dmypy.json
 .vs/
 
 internal/
-test.py
+test*.py

README.md

@@ -19,6 +19,7 @@
 
 ## Introduction
 
+
 This is a [discord.py](https://github.com/Rapptz/discord.py) ui extension made by [404kuso](https://github.com/404kuso) and [RedstoneZockt](https://github.com/RedstoneZockt)
 for using discord's newest ui features like buttons, slash commands and context commands (we got dpy2 supported if you want to keep using our libary)
 
@@ -28,7 +29,6 @@ for using discord's newest ui features like buttons, slash commands and context
 
 
 ### Windows
-
 ```cmd
 py -m pip install discord-ui
 ```
@@ -175,6 +175,30 @@ You can find more (and better) examples [here](https://github.com/discord-py-ui/
 
 
 # Changelog
+
+-   <details>
+    <summary>5.0.0</summary>
+
+    ## **Fixed**
+    - Roles not being parsed correctly
+
+    ## **Changed**
+    - default_permission
+    > default_permission can now be of type `discord.Permissions` but the api doesn't support that yet.
+    - slash http
+    > some code changes to slash-http features
+
+    ## **Added**
+    - ChoiceGeneratorContext
+    > Context class for choice generation
+    - SlashOption
+    > `choice_generator` keyword and `autocomplete` keyword. 
+    > `autocomplete` is not needed if you pass choice_generator
+    - File sending
+    > You are now able to send hidden files 
+
+    </details>
+
 -   <details>
     <summary>4.3.8</summary>
 

discord_ui/__init__.py

@@ -37,7 +37,7 @@
 from .slash.tools import ParseMethod
 from .tools import components_to_dict
 from .slash.tools import create_choice
-from .receive import Interaction, InteractionType, Message, WebhookMessage, PressedButton, SelectedMenu, ComponentContext, SlashedCommand, SlashedSubCommand, EphemeralMessage, EphemeralResponseMessage
+from .receive import Interaction, InteractionType, Message, WebhookMessage, PressedButton, SelectedMenu, ComponentContext, SlashedCommand, SlashedSubCommand, EphemeralMessage, EphemeralResponseMessage, ChoiceGeneratorContext
 from .slash import ext
 from .listener import Listener
 
@@ -46,4 +46,7 @@
 
 
 __title__ = "discord-ui"
-__version__ = "4.3.8"
+__version__ = "5.0.0a"
+
+if __version__.endswith("a"):
+    print("Warning: This version is a preview version and can contain some issues!")

discord_ui/client.py

@@ -351,8 +351,9 @@ def slash_cog(name=None, description=None, options=[], guild_ids=None, default_p
         Choices for string and int types for the user to pick from; default MISSING
     guild_ids: List[:class:`str` | :class:`int`], optional
         A list of guild ids where the command is available; default MISSING
-    default_permission: :class:`bool`, optional
-        Whether the command can be used by everyone or not
+    default_permission: :class:`bool` | :class:`discord.Permissions`, optional
+        Permissions that a user needs to have in order to execute the command, default ``True``. 
+                    If a bool was passed, it will indicate whether all users can use the command (``True``) or not (``False``)
     guild_permissions: Dict[``guild_id``: :class:`~SlashPermission`]
         The permissions for the command in guilds
             Format: ``{"guild_id": SlashPermission}``
@@ -417,8 +418,9 @@ def subslash_cog(base_names, name=None, description=None, options=[], guild_ids=
         Choices for string and int types for the user to pick from; default MISSING
     guild_ids: List[:class:`str` | :class:`int`], optional
         A list of guild ids where the command is available; default MISSING
-    default_permission: :class:`bool`, optional
-        Whether the command can be used by everyone or not
+    default_permission: :class:`bool` | :class:`discord.Permissions`, optional
+        Permissions that a user needs to have in order to execute the command, default ``True``.
+                    If a bool was passed, it will indicate whether all users can use the command (``True``) or not (``False``)
     guild_permissions: Dict[``guild_id``: :class:`~SlashPermission`]
         The permissions for the command in guilds
             Format: ``{"guild_id": SlashPermission}``
@@ -484,8 +486,9 @@ def context_cog(type: Literal["user", 2, "message", 3], name=None, guild_ids=Non
             The name of the command; default MISSING
         guild_ids: List[:class:`str` | :class:`int`]
             A list of guilds where the command can be used
-        default_permission: :class:`bool`, optional
-            Whether the command can be used by everyone; default True
+        default_permission: :class:`bool` | :class:`discord.Permissions`, optional
+            Permissions that a user needs to have in order to execute the command, default ``True``.
+                    If a bool was passed, it will indicate whether all users can use the command (``True``) or not (``False``)
         guild_permissions: Dict[:class:`SlashPermission`], optional
             Special permissions for guilds; default MISSING
 

discord_ui/cogs.py

@@ -1,16 +1,17 @@
+from .slash.http import ModifiedSlashState
 from .errors import InvalidEvent, OutOfValidRange, WrongType
 from .slash.errors import AlreadyDeferred, EphemeralDeletion
-from .slash.types import ContextCommand, OptionType, SlashCommand, SlashOption, SlashPermission, SlashSubcommand
-from .tools import MISSING, setup_logger, _none
+from .tools import MISSING, setup_logger, _none, get, _default
+from .slash.types import ContextCommand, SlashCommand, SlashOption, SlashPermission, SlashSubcommand
 from .http import BetterRoute, jsonifyMessage, send_files
-from .components import ActionRow, Button, Component, LinkButton, SelectMenu, SelectOption, UseableComponent, make_component
+from .components import ActionRow, Button, LinkButton, SelectMenu, SelectOption, UseableComponent, make_component
 
 import discord
 from discord.ext.commands import Bot
 from discord.errors import HTTPException
 from discord.state import ConnectionState
 
-from typing import List, Union, Dict
+from typing import Any, List, Union, Dict
 try:
     from typing import Literal
 except ImportError:
@@ -20,13 +21,14 @@
 
 
 class InteractionType:
-    PING                        =       Ping        =           1
-    APPLICATION_COMMAND         =      Command      =           2
-    MESSAGE_COMPONENT           =     Component     =           3
+    PING                                =       Ping        =           1
+    APPLICATION_COMMAND                 =      Command      =           2
+    MESSAGE_COMPONENT                   =     Component     =           3
+    APPLICATION_COMMAND_AUTOCOMPLETE    =    Autocomplete   =           4
 
 class Interaction():
     def __init__(self, state, data, user=None, message=None) -> None:
-        self._state: ConnectionState = state
+        self._state: ModifiedSlashState = state
 
         self.deferred: bool = False
         self.responded: bool = False
@@ -88,13 +90,12 @@ async def defer(self, hidden=False):
             logging.error(AlreadyDeferred())
             return
 
-        body = {"type": 5}
-        
+        payload = None
         if hidden is True:
-            body["data"] = {"flags": 64}
+            payload = {"flags": 64}
             self._deferred_hidden = True
 
-        await self._state.http.request(BetterRoute("POST", f'/interactions/{self.id}/{self.token}/callback'), json=body)
+        await self._state.slash_http.respond_to(self.id, self.token, 5, payload)
         self.deferred = True
 
     async def respond(self, content=MISSING, *, tts=False, embed=MISSING, embeds=MISSING, file=MISSING, files=MISSING, nonce=MISSING,
@@ -141,10 +142,7 @@ async def respond(self, content=MISSING, *, tts=False, embed=MISSING, embeds=MIS
         """
         if ninja_mode is True or all(y in [MISSING, False] for x, y in locals().items() if x not in ["self"]):
             try:
-                route = BetterRoute("POST", f'/interactions/{self.id}/{self.token}/callback')
-                r = await self._state.http.request(route, json={
-                    "type": 6
-                })
+                await self._state.slash_http.respond_to(self.id, self.token, 6)
                 return
             except HTTPException as x:
                 if "value must be one of (4, 5)" in str(x).lower():
@@ -169,49 +167,34 @@ async def respond(self, content=MISSING, *, tts=False, embed=MISSING, embeds=MIS
 
 
         r = None
-        if not _none(delete_after) and hide_message is True:
+        if delete_after is not MISSING and hide_message is True:
             raise EphemeralDeletion()
 
         if hide_message:
             payload["flags"] = 64
-
-        if (file is not MISSING or files is not MISSING) and self.deferred is False:
-            await self.defer(hidden=hide_message)
 
-        if self.deferred is False and hide_message is False:
-            route = BetterRoute("POST", f'/interactions/{self.id}/{self.token}/callback')
-            r = await self._state.http.request(route, json={
-                "type": 4,
-                "data": payload
-            })
-        else:
-            if self.deferred is False and hide_message is True:
-                await self.defer(hide_message)
+        if self.deferred:
             route = BetterRoute("PATCH", f'/webhooks/{self.application_id}/{self.token}/messages/@original')
             if file is not MISSING or files is not MISSING:
-                r = await send_files(route=route, files=[file] if files is MISSING else files, payload=payload, http=self._state.http)
+                await send_files(route=route, files=[file] if files is MISSING else files, payload=payload, http=self._state.http)
             else:
-                r = await self._state.http.request(route, json=payload)
+                await self._state.http.request(route, json=payload)    
+        else:
+            await self._state.slash_http.respond_to(self.id, self.token, 4, payload, files=[file] if file is not MISSING else _default(None, files))
         self.responded = True
 
+        r = await self._state.http.request(BetterRoute("GET", f"/webhooks/{self.application_id}/{self.token}/messages/@original"))
         if hide_message is True:
-            msg = EphemeralMessage(state=self._state, channel=self._state.get_channel(int(r["channel_id"])), data=r, application_id=self.application_id, token=self.token)
-            if listener is not MISSING:
-                listener._start(msg)
-            return msg
-
-        
-        if not hide_message:
-            responseMSG = await self._state.http.request(BetterRoute("GET", f"/webhooks/{self.application_id}/{self.token}/messages/@original"))
-            msg = await getMessage(self._state, data=responseMSG, response=False)
-            if not _none(delete_after):
-                await msg.delete(delete_after)
-            if listener is not MISSING:
-                listener._start(msg)
-            return msg
-
+            msg = EphemeralMessage(state=self._state, channel=self.channel, data=r, application_id=self.application_id, token=self.token)
+        else:
+            msg = await getMessage(self._state, data=r, response=False)
+        if listener is not MISSING:
+            listener._start(msg)
+        if not _none(delete_after):
+            await msg.delete(delete_after)
+        return msg
     async def send(self, content=None, *, tts=False, embed=MISSING, embeds=MISSING, file=MISSING, files=MISSING, nonce=MISSING,
-    allowed_mentions=MISSING, mention_author=MISSING, components=MISSING, listener=MISSING, hidden=False) -> Union['Message', 'EphemeralMessage']:
+    allowed_mentions=MISSING, mention_author=MISSING, components=MISSING, delete_after=MISSING, listener=MISSING, hidden=False) -> Union['Message', 'EphemeralMessage']:
         """
         Sends a message to the interaction using a webhook
         
@@ -237,6 +220,8 @@ async def send(self, content=None, *, tts=False, embed=MISSING, embeds=MISSING,
             Whether the author should be mentioned
         components: List[:class:`~Button` | :class:`~LinkButton` | :class:`~SelectMenu`]
             A list of message components to be included
+        delete_after: :class:`float`
+            After how many seconds the message should be deleted, only works for non-hiddend messages; default MISSING
         listener: :class:`Listener`
             A component-listener for this message
         hidden: :class:`bool`
@@ -250,7 +235,7 @@ async def send(self, content=None, *, tts=False, embed=MISSING, embeds=MISSING,
         :type: :class:`~Message` | :class:`EphemeralMessage`
         """
         if self.responded is False:
-            return await self.respond(content=content, tts=tts, embed=embed, embeds=embeds, file=file, files=files, nonce=nonce, allowed_mentions=allowed_mentions, mention_author=mention_author, components=components, listener=listener, hidden=hidden)
+            return await self.respond(content=content, tts=tts, embed=embed, embeds=embeds, file=file, files=files, nonce=nonce, allowed_mentions=allowed_mentions, mention_author=mention_author, components=components, delete_after=delete_after, listener=listener, hidden=hidden)
 
         if components is MISSING and listener is not MISSING:
             components = listener.to_components()
@@ -260,25 +245,48 @@ async def send(self, content=None, *, tts=False, embed=MISSING, embeds=MISSING,
             payload["flags"] = 64
 
         route = BetterRoute("POST", f'/webhooks/{self.application_id}/{self.token}')
-        
         if file is not MISSING or files is not MISSING:
             r = await send_files(route=route, files=[file] if files is MISSING else files, payload=payload, http=self._state.http)
         else:
             r = await self._state.http.request(route, json=payload)
 
         if hidden is True:
-            msg = EphemeralMessage(state=self._state, channel=self._state.get_channel(r["channel_id"]), data=r, application_id=self.application_id, token=self.token)
-            if listener is not MISSING:
-                listener._start(msg)
-        msg = await getMessage(self._state, r, response=False)
-        
+            msg = EphemeralMessage(state=self._state, channel=self._state.get_channel(int(r["channel_id"])), data=r, application_id=self.application_id, token=self.token)
+        else:
+            msg = await getMessage(self._state, r, response=False)
+        if delete_after is not MISSING:
+            await msg.delete(delete_after)
         if listener is not MISSING:
             listener._start(msg)
+        print(msg)
         return msg
     def _handle_auto_defer(self, auto_defer):
         self.deferred = auto_defer[0]
         self._deferred_hidden = auto_defer[1]
 
+class ChoiceGeneratorContext(Interaction):
+    """A class for information that could be needed for generating choices for autocomopletion"""
+    def __init__(self, command, state, data, options, user=None) -> None:
+        Interaction.__init__(self, state, data, user=user)
+        self.focused_option: dict = options[get(options, check=lambda x: options[x].get("focused", False))]
+        """The option for which the choices should be generated"""
+        self.value_query: Union[str, int] = self.focused_option["value"]
+        """The current 'query' for the value"""
+        self.selected_options: Dict[str, Any] = {options[x]["name"]: options[x]["value"] for x in options}
+        """All the options that were already selected"""
+        self.command: Union[SlashedCommand, SlashedCommand, SlashedContext] = command
+        """The slash command for which the choices should be generated"""
+
+    async def defer(self, *args, **kwargs):
+        """Cannot defer this type of interaction"""
+        raise NotImplementedError()
+    async def respond(self, *args, **kwargs):
+        """Cannot rerspond to this type of interaction"""
+        raise NotImplementedError()
+    async def send(self, *args, **kwargs):
+        """Cannot send followup message to this type of interaction"""
+        raise NotImplementedError()
+
 class ComponentContext(Interaction, UseableComponent):
     """A received component"""
     def __init__(self, state, data, user, message) -> None:
@@ -370,6 +378,8 @@ async def getMessage(state: ConnectionState, data, response=True):
         The User which pressed the button
     response: :class:`bool`
         Whether the Message returned should be of type `ResponseMessage` or `Message`
+    channel: :class:`discord.Messageable`
+        An alternative channel that will be used when no channel was found
 
     Returns
     -------
@@ -486,7 +496,7 @@ async def edit(self, content=MISSING, *, embed=MISSING, embeds=MISSING, attachme
         data = await self._state.http.edit_message(self.channel.id, self.id, **payload)
         self._update(data)
 
-        if not _none(delete_after):
+        if delete_after is not MISSING:
             await self.delete(delay=delete_after)
 
     async def disable_action_row(self, row, disable = True):

discord_ui/receive.py

@@ -157,8 +157,9 @@ def guild_change(guild_id, *, name=None, description=None, default_permission=Tr
         The new name; default None
     description: :class:`str`, optional
         The new description; default None
-    default_permission: :class:`bool`, optional
-        Whether this command can be used by default; default True
+    default_permission: :class:`bool` | :class:`discord.Permissions`, optional
+        Permissions that a user needs to have in order to execute the command, default ``True``.
+            If a bool was passed, it will indicate whether all users can use the command (``True``) or not (``False``)
     
     """
     def wraper(callback):