fixed slash adding issue

Author: kuso-senpai

discord_ui/client.py

@@ -4,7 +4,7 @@
 from .errors import MissingListenedComponentParameters, WrongType
 from .slash.tools import ParseMethod, cache_data, format_name, handle_options, handle_thing
 from .slash.http import create_global_command, create_guild_command, delete_global_command, delete_guild_command, delete_guild_commands, edit_global_command, edit_guild_command, get_command, get_command_permissions, get_global_commands, get_guild_commands, delete_global_commands, get_id, update_command_permissions
-from .slash.types import AdditionalType, CommandType, ContextCommand, MessageCommand, OptionType, SlashCommand, SlashOption, SubSlashCommandGroup, UserCommand
+from .slash.types import AdditionalType, CommandType, ContextCommand, MessageCommand, OptionType, SlashCommand, SlashOption, SlashSubcommand, UserCommand
 from .tools import MISSING, _or, get_index, setup_logger
 from .http import jsonifyMessage, BetterRoute, send_files
 from .receive import Interaction, Message, PressedButton, SelectedMenu, SlashedContext, WebhookMessage, SlashedCommand, SlashedSubCommand, getMessage
@@ -102,7 +102,7 @@ def __init__(self, client, parse_method = ParseMethod.AUTO, auto_sync=True, dele
 
         self._discord: com.Bot = client
         self.commands: Dict[(str, SlashCommand)] = {}
-        self.subcommands: Dict[(str, Dict[(str, Union[dict, SubSlashCommandGroup])])] = {}
+        self.subcommands: Dict[(str, Dict[(str, Union[dict, SlashSubcommand])])] = {}
         self.context_commands: Dict[str, ContextCommand] = {"message": {}, "user": {}}
         if discord.__version__.startswith("2"):
             self._discord.add_listener(self._on_response, "on_socket_raw_receive")
@@ -295,36 +295,48 @@ async def sync_commands(self, delete_unused=False):
         }
         own_guild_ids = [x.id for x in self._discord.guilds]
 
+        
         #region gather commands
         commands = self.commands
-        for x in self.subcommands:
-            for y in self.subcommands[x]:
-                sub = self.subcommands[x][y]
+        for _base in self.subcommands:
+            # get first base
+            for _sub in self.subcommands[_base]:
+                # get second base/command
+                sub = self.subcommands[_base][_sub]
+                # when command has subcommand groups
                 if type(sub) is dict:
-                    for z in self.subcommands[x][y]:
-                        group = self.subcommands[x][y][z]
-                        if commands.get(group.base_names[0]) is not None:
-                            index = get_index(commands[group.base_names[0]].options, group.base_names[1], lambda x: getattr(x, "name"))
+                    for _group in self.subcommands[_base][_sub]:
+                        # the subcommand group
+                        group = self.subcommands[_base][_sub][_group]
+                        # if there's already a base command
+                        if commands.get(_base) is not None:
+                            # Check if base already has an option with the subs name
+                            index = get_index(commands[_base].options, _sub, lambda x: getattr(x, "name"))
+                            # if first base_name already exists
                             if index > -1:
-                                _ops = commands[group.base_names[0]].options[index].options
-                                _ops.append(group.to_option())
-                                commands[group.base_names[0]].options[index].options = _ops
+                                # add to sub options
+                                base_ops = commands[_base].options
+                                base_ops[index].options += [group.to_option()]
+                                commands[_base].options = base_ops
+                            # if not exists
                             else:
-                                _ops = commands[group.base_names[0]].options
-                                _ops.append(SlashOption(OptionType.SUB_COMMAND_GROUP, group.base_names[1], options=[group.to_option()]))
-                                commands[group.base_names[0]].options = _ops
+                                # create sub option + group option
+                                commands[_base].options += [SlashOption(OptionType.SUB_COMMAND_GROUP, _sub, options=[group.to_option()])]
+                        # if no base command
                         else:
-                            commands[group.base_names[0]] = SlashCommand(None, group.base_names[0], MISSING, [
-                                    SlashOption(OptionType.SUB_COMMAND_GROUP, group.base_names[1], options=[group.to_option()])
+                            # create base0 command together with base1 option and groupcommand option
+                            commands[_base] = SlashCommand(None, _base, MISSING, [
+                                    SlashOption(OptionType.SUB_COMMAND_GROUP, _sub, options=[group.to_option()])
                                 ],
-                                guild_ids=group.guild_ids, default_permission=group.default_permission, guild_permissions=group.guild_permission)
+                                guild_ids=group.guild_ids, default_permission=group.default_permission, guild_permissions=group.guild_permissions)
+                # if is basic subcommand
                 else:
-                    if commands.get(sub.base_names[0]) is not None:
-                        _ops = commands[sub.base_names[0]].options
-                        _ops.append(sub.to_option())
-                        commands[sub.base_names[0]].options = _ops
+                    # If base exists
+                    if commands.get(_base) is not None:
+                        commands[_base].options += [sub.to_option()]
                     else:
-                        commands[sub.base_names[0]] = SlashCommand(None, sub.base_names[0], options=[sub.to_dict()], guild_ids=sub.guild_ids, default_permission=sub.default_permission, guild_permissions=sub.guild_permissions)
+                        # create base0 command with name option
+                        commands[_base] = SlashCommand(None, _base, options=[sub.to_dict()], guild_ids=sub.guild_ids, default_permission=sub.default_permission, guild_permissions=sub.guild_permissions)
         #endregion
 
         async def guild_stuff(command, guild_ids):
@@ -639,21 +651,31 @@ def _set_command(self, old_name, command: SlashCommand):
         else:
             del self.context_commands["user"][old_name]
             self.context_commands["user"][command.name] = command
-    def _add_to_cache(self, base: SlashCommand):
+    def _add_to_cache(self, base: Union[SlashCommand, SlashSubcommand]):
         if base.command_type is CommandType.Slash:
+            # basic slash command
             if type(base) in [SlashCommand, CogCommand]:
                 self.commands[base.name] = base
+            # subcommand or subgroup
             else:
+                # when subcommands is missing base
                 if self.subcommands.get(base.base_names[0]) is None:
                     self.subcommands[base.base_names[0]] = {}
+                # subgroup
                 if len(base.base_names) > 1:
+                    # if cache is missing second base_name 
                     if self.subcommands[base.base_names[0]].get(base.base_names[1]) is None:
                         self.subcommands[base.base_names[0]][base.base_names[1]] = {}
+                    # add to internal cache
                     self.subcommands[base.base_names[0]][base.base_names[1]][base.name] = base
+                # subcommand
                 else:
+                    # add to cache
                     self.subcommands[base.base_names[0]][base.name] = base
+        # context user command
         elif base.command_type == CommandType.User:
             self.context_commands["user"][base.name] = base
+        # context message command
         elif base.command_type == CommandType.Message:
             self.context_commands["message"][base.name] = base
 
@@ -712,21 +734,21 @@ def add_command(self, name, callback=None, description=MISSING, options=[], guil
                 If ``api`` is True, this function will return a promise
         """
         command = SlashCommand(callback, name, description, options, guild_ids=guild_ids, default_permission=default_permission, guild_permissions=guild_permissions)
-        self.commands[format_name(name)] = command
+        self._add_to_cache(command)
         if api is True:
             if self.ready is False:
                 raise Exception("Slashcommands are not ready yet")
             return self.create_command(command) 
-    def command(self, name, description=MISSING, options=[], guild_ids=MISSING, default_permission=True, guild_permissions=MISSING):
+    def command(self, name=MISSING, description=MISSING, options=[], guild_ids=MISSING, default_permission=True, guild_permissions=MISSING):
         """A decorator for a slash command
         
         command in discord:
             ``/name [options]``
 
         Parameters
         ----------
-            name: :class:`str`
-                1-32 characters long name
+            name: :class:`str`, optional
+                1-32 characters long name; default MISSING
                 .. note::
 
                     The name will be corrected automaticaly (spaces will be replaced with "-" and the name will be lowercased)
@@ -794,7 +816,7 @@ def wrapper(callback):
             """
             self.add_command(name, callback, description, options, guild_ids, default_permission, guild_permissions)
         return wrapper
-    def subcommand(self, base_names, name, description=MISSING, options=[], guild_ids=MISSING, default_permission=True, guild_permissions=MISSING):
+    def subcommand(self, base_names, name=MISSING, description=MISSING, options=[], guild_ids=MISSING, default_permission=True, guild_permissions=MISSING):
         """A decorator for a subcommand group
         
         command in discord
@@ -805,8 +827,8 @@ def subcommand(self, base_names, name, description=MISSING, options=[], guild_id
             base_names: List[:class:`str`] | :class:`str`
                 The names of the parent bases, currently limited to 2
                     If you want to make a subcommand (``/base name``), you have to use a str instead of a list
-            name: :class:`str`
-                1-32 characters long name
+            name: :class:`str`, optional
+                1-32 characters long name; default MISSING
                 .. note::
 
                     The name will be corrected automaticaly (spaces will be replaced with "-" and the name will be lowercased)
@@ -893,22 +915,19 @@ def wrapper(callback):
             if sub is not None and self.subcommands[base].get(sub) is None:
                 self.subcommands[base][sub] = {}
 
-            command = SubSlashCommandGroup(callback, base_names, name, description, options=options, guild_ids=guild_ids, default_permission=default_permission, guild_permissions=guild_permissions)
-            if sub is not None:
-                self.subcommands[base][sub][format_name(name)] = command
-            else:
-                self.subcommands[base][format_name(name)] = command
+            command = SlashSubcommand(callback, base_names, name, description, options=options, guild_ids=guild_ids, default_permission=default_permission, guild_permissions=guild_permissions)
+            self._add_to_cache(command)
 
         return wrapper
-    def user_command(self, name, guild_ids=MISSING, default_permission=True, guild_permissions = MISSING):
+    def user_command(self, name=MISSING, guild_ids=MISSING, default_permission=True, guild_permissions = MISSING):
         """Decorator for user context commands in discord.
             ``Right-click username`` -> ``apps`` -> ``commands is displayed here``
 
 
         Parameters
         ----------
-            name: :class:`str`
-                The name of the command
+            name: :class:`str`, optional
+                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
@@ -946,15 +965,15 @@ async def call(ctx, message):
         def wraper(callback):
             self.context_commands["user"][format_name(name)] = UserCommand(callback, name, guild_ids, default_permission, guild_permissions)
         return wraper
-    def message_command(self, name, guild_ids=MISSING, default_permission=True, guild_permissions=MISSING):
+    def message_command(self, name=MISSING, guild_ids=MISSING, default_permission=True, guild_permissions=MISSING):
         """Decorator for message context commands in discord.
             ``Right-click message`` -> ``apps`` -> ``commands is displayed here``
 
 
         Parameters
         ----------
-            name: :class:`str`
-                The name of the command
+            name: :class:`str`, optional
+                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

discord_ui/cogs.py

@@ -1,6 +1,6 @@
 from .components import ComponentType
 from .tools import MISSING
-from .slash.types import MessageCommand, SlashCommand, SubSlashCommandGroup, UserCommand
+from .slash.types import MessageCommand, SlashCommand, SlashSubcommand, UserCommand
 
 import discord
 from discord.errors import InvalidArgument
@@ -265,9 +265,9 @@ class CogCommand(BaseSlash, SlashCommand):
     def __init__(self, *args, **kwargs) -> None:
         SlashCommand.__init__(self, *args, **kwargs)
         BaseSlash.__init__(self, args[0])
-class CogSubCommandGroup(BaseSlash, SubSlashCommandGroup):
+class CogSubCommandGroup(BaseSlash, SlashSubcommand):
     def __init__(self, *args, **kwargs) -> None:
-        SubSlashCommandGroup.__init__(self, *args, **kwargs)
+        SlashSubcommand.__init__(self, *args, **kwargs)
         BaseSlash.__init__(self, args[0])
 class CogMessageCommand(BaseSlash, MessageCommand):
     def __init__(self, *args, **kwargs) -> None:

discord_ui/receive.py

@@ -1,7 +1,7 @@
 from discord.ext.commands import Bot
 from .errors import InvalidEvent, OutOfValidRange, WrongType
 from .slash.errors import AlreadyDeferred, EphemeralDeletion
-from .slash.types import ContextCommand, SlashCommand, SlashPermission, SubSlashCommandGroup
+from .slash.types import ContextCommand, SlashCommand, SlashPermission, SlashSubcommand
 from .tools import MISSING, setup_logger
 from .http import BetterRoute, jsonifyMessage, send_files
 from .components import ActionRow, Button, LinkButton, SelectMenu, SelectOption, make_component
@@ -306,11 +306,11 @@ def __init__(self, client, command: SlashCommand, data, user, args = None, guild
         """The options that were received"""
         self.permissions: SlashPermission = guild_permissions.get(self.guild_id)
         """The permissions for the guild"""
-class SlashedSubCommand(SlashedCommand, SubSlashCommandGroup):
+class SlashedSubCommand(SlashedCommand, SlashSubcommand):
     """A Sub-:class:`~SlashCommand` command that was used"""
     def __init__(self, client, command, data, user, args = None, guild_ids = None, guild_permissions=None) -> None:
         SlashedCommand.__init__(self, client, command, data, user, args, guild_ids=guild_ids, guild_permissions=guild_permissions)
-        SubSlashCommandGroup.__init__(self, None, "EMPTY", "EMPTY")
+        SlashSubcommand.__init__(self, None, "EMPTY", "EMPTY")
 
 class SlashedContext(Interaction, ContextCommand):
     def __init__(self, client, command: ContextCommand, data, user, param, guild_ids = None, guild_permissions = None) -> None:

discord_ui/slash/types.py

@@ -47,7 +47,7 @@ def __init__(self, argument_type, name, description=MISSING, required=False, cho
         self._json = {}
         self.argument_type = argument_type
         self.name = name
-        self.description = _or(description, name)
+        self.description = _or(description, self.name)
         if required is True:
             self.required = required
         if options is not MISSING:
@@ -165,7 +165,7 @@ class OptionType:
     STRING                  =          String               =           3
     INTEGER                 =          Integer              =           4
     BOOLEAN                 =          Boolean              =           5
-    MEMBER     =   USER     =          Member               =   User  = 6
+    MEMBER     =   USER     =          Member               =  User =   6
     CHANNEL                 =          Channel              =           7
     ROLE                    =          Role                 =           8
     MENTIONABLE             =          Mentionable          =           9
@@ -397,8 +397,7 @@ async def my_function(command, parameter=None):
         }
 
         # Check options before callback because callback makes an option check
-        if options is not MISSING:
-            self.options: typing.List[SlashOption] = options
+        self.options: typing.List[SlashOption] = options
 
         if callback is not None:
             if not inspect.iscoroutinefunction(callback):
@@ -415,7 +414,7 @@ async def my_function(command, parameter=None):
 
         self.callback: function = callback
         self.name = _or(name, self.callback.__name__ if self.callback not in [None, MISSING] else None)
-        self.description = _or(description, (inspect.getdoc(self.callback) if self.callback not in [None, MISSING] else None), name)
+        self.description = _or(description, (inspect.getdoc(self.callback) if self.callback not in [None, MISSING] else None), self.name)
         if default_permission is MISSING:
             default_permission = True
         self.default_permission: bool = default_permission
@@ -525,7 +524,7 @@ def default_permission(self, value):
 
     def to_dict(self):
         return self._json
-class SubSlashCommandGroup(SlashCommand):
+class SlashSubcommand(SlashCommand):
     def __init__(self, callback, base_names, name, description=MISSING, options=[], guild_ids=MISSING, default_permission=MISSING, guild_permissions=MISSING) -> None:
         if type(base_names) is str:
             base_names = [base_names]