Merge pull request #462 from Pycord-Development/groups

Redesigning slash command groups

Author: Lulalaby

discord/bot.py

@@ -118,6 +118,9 @@ def add_application_command(self, command: ApplicationCommand) -> None:
         command: :class:`.ApplicationCommand`
             The command to add.
         """
+        if isinstance(command, SlashCommand) and command.is_subcommand:
+            raise TypeError("The provided command is a sub-command of group")
+
         if self.debug_guilds and command.guild_ids is None:
             command.guild_ids = self.debug_guilds
         self._pending_application_commands.append(command)
@@ -508,7 +511,6 @@ def application_command(self, **kwargs):
         """
 
         def decorator(func) -> ApplicationCommand:
-            kwargs.setdefault("parent", self)
             result = command(**kwargs)(func)
             self.add_application_command(result)
             return result
@@ -532,14 +534,78 @@ def command(self, **kwargs):
         """
         return self.application_command(**kwargs)
 
-    def command_group(
-        self, name: str, description: str, guild_ids=None
+    def create_group(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        guild_ids: Optional[List[int]] = None,
     ) -> SlashCommandGroup:
-        # TODO: Write documentation for this. I'm not familiar enough with what this function does to do it myself.
+        """A shortcut method that creates a slash command group with no subcommands and adds it to the internal
+        command list via :meth:`~.ApplicationCommandMixin.add_application_command`.
+
+        .. versionadded:: 2.0
+
+        Parameters
+        ----------
+        name: :class:`str`
+            The name of the group to create.
+        description: Optional[:class:`str`]
+            The description of the group to create.
+        guild_ids: Optional[List[:class:`int`]]
+            A list of the IDs of each guild this group should be added to, making it a guild command.
+            This will be a global command if ``None`` is passed.
+
+        Returns
+        --------
+        SlashCommandGroup
+            The slash command group that was created.
+        """
+        description = description or "No description provided."
         group = SlashCommandGroup(name, description, guild_ids)
         self.add_application_command(group)
         return group
 
+    def group(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        guild_ids: Optional[List[int]] = None,
+    ) -> Callable[[Type[SlashCommandGroup]], SlashCommandGroup]:
+        """A shortcut decorator that initializes the provided subclass of :class:`.SlashCommandGroup`
+        and adds it to the internal command list via :meth:`~.ApplicationCommandMixin.add_application_command`.
+
+        .. versionadded:: 2.0
+
+        Parameters
+        ----------
+        name: :class:`str`
+            The name of the group to create.
+        description: Optional[:class:`str`]
+            The description of the group to create.
+        guild_ids: Optional[List[:class:`int`]]
+            A list of the IDs of each guild this group should be added to, making it a guild command.
+            This will be a global command if ``None`` is passed.
+
+        Returns
+        --------
+        Callable[[Type[SlashCommandGroup]], SlashCommandGroup]
+            The slash command group that was created.
+        """
+        def inner(cls: Type[SlashCommandGroup]) -> SlashCommandGroup:
+            group = cls(
+                name,
+                (
+                    description or inspect.cleandoc(cls.__doc__).splitlines()[0]
+                    if cls.__doc__ is not None else "No description provided"
+                ),
+                guild_ids=guild_ids
+            )
+            self.add_application_command(group)
+            return group
+        return inner
+
+    slash_group = group
+
     async def get_application_context(
         self, interaction: Interaction, cls=None
     ) -> ApplicationContext:

discord/cog.py

@@ -29,7 +29,7 @@
 import discord.utils
 import types
 from . import errors
-from .commands import SlashCommand, UserCommand, MessageCommand, ApplicationCommand
+from .commands import SlashCommand, UserCommand, MessageCommand, ApplicationCommand, SlashCommandGroup
 
 from typing import Any, Callable, Mapping, ClassVar, Dict, Generator, List, Optional, TYPE_CHECKING, Tuple, TypeVar, Type
 
@@ -145,6 +145,13 @@ def __new__(cls: Type[CogMeta], *args: Any, **kwargs: Any) -> CogMeta:
                 if elem in listeners:
                     del listeners[elem]
 
+                try:
+                    if getattr(value, "parent") is not None:
+                        # Skip commands if they are a part of a group
+                        continue
+                except AttributeError:
+                    pass
+
                 is_static_method = isinstance(value, staticmethod)
                 if is_static_method:
                     value = value.__func__
@@ -445,7 +452,8 @@ def _inject(self: CogT, bot) -> CogT:
         # we've added so far for some form of atomic loading.
 
         for index, command in enumerate(self.__cog_commands__):
-            command.cog = self
+            command._set_cog(self)
+
             if not isinstance(command, ApplicationCommand):
                 if command.parent is None:
                     try:

discord/commands/commands.py

@@ -31,7 +31,7 @@
 import re
 import types
 from collections import OrderedDict
-from typing import Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
+from typing import Any, Callable, Dict, List, Optional, Type, Union, TYPE_CHECKING
 
 from .context import ApplicationContext, AutocompleteContext
 from .errors import ApplicationCommandError, CheckFailure, ApplicationCommandInvokeError
@@ -318,6 +318,9 @@ def qualified_name(self) -> str:
         else:
             return self.name
 
+    def _set_cog(self, cog):
+        self.cog = cog
+
 class SlashCommand(ApplicationCommand):
     r"""A class that implements the protocol for a slash command.
 
@@ -386,7 +389,7 @@ def __init__(self, func: Callable, *args, **kwargs) -> None:
         validate_chat_input_description(description)
         self.description: str = description
         self.parent = kwargs.get('parent')
-        self.is_subcommand: bool = self.parent is not None
+        self.attached_to_group: bool = False
 
         self.cog = None
 
@@ -476,6 +479,10 @@ def _is_typing_union(self, annotation):
     def _is_typing_optional(self, annotation):
         return self._is_typing_union(annotation) and type(None) in annotation.__args__  # type: ignore
 
+    @property
+    def is_subcommand(self) -> bool:
+        return self.parent is not None
+
     def to_dict(self) -> Dict:
         as_dict = {
             "name": self.name,
@@ -528,6 +535,8 @@ async def _invoke(self, ctx: ApplicationContext) -> None:
 
         if self.cog is not None:
             await self.callback(self.cog, ctx, **kwargs)
+        elif self.parent is not None and self.attached_to_group is True:
+            await self.callback(self.parent, ctx, **kwargs)
         else:
             await self.callback(ctx, **kwargs)
 
@@ -729,8 +738,24 @@ class SlashCommandGroup(ApplicationCommand, Option):
 
     def __new__(cls, *args, **kwargs) -> SlashCommandGroup:
         self = super().__new__(cls)
-
         self.__original_kwargs__ = kwargs.copy()
+
+        self.__initial_commands__ = []
+        for i, c in cls.__dict__.items():
+            if isinstance(c, type) and SlashCommandGroup in c.__bases__:
+                c = c(
+                    c.__name__,
+                    (
+                        inspect.cleandoc(cls.__doc__).splitlines()[0]
+                        if cls.__doc__ is not None
+                        else "No description provided"
+                    )
+                )
+            if isinstance(c, (SlashCommand, SlashCommandGroup)):
+                c.parent = self
+                c.attached_to_group = True
+                self.__initial_commands__.append(c)
+
         return self
 
     def __init__(
@@ -748,7 +773,7 @@ def __init__(
             name=name,
             description=description,
         )
-        self.subcommands: List[Union[SlashCommand, SlashCommandGroup]] = []
+        self.subcommands: List[Union[SlashCommand, SlashCommandGroup]] = self.__initial_commands__
         self.guild_ids = guild_ids
         self.parent = parent
         self.checks = []
@@ -768,6 +793,7 @@ def to_dict(self) -> Dict:
             "name": self.name,
             "description": self.description,
             "options": [c.to_dict() for c in self.subcommands],
+            "default_permission": self.default_permission,
         }
 
         if self.parent is not None:
@@ -783,7 +809,7 @@ def wrap(func) -> SlashCommand:
 
         return wrap
 
-    def command_group(self, name, description) -> SlashCommandGroup:
+    def create_subgroup(self, name, description) -> SlashCommandGroup:
         if self.parent is not None:
             # TODO: Improve this error message
             raise Exception("Subcommands can only be nested once")
@@ -792,6 +818,47 @@ def command_group(self, name, description) -> SlashCommandGroup:
         self.subcommands.append(sub_command_group)
         return sub_command_group
 
+    def subgroup(
+        self,
+        name: str,
+        description: str = None, 
+        guild_ids: Optional[List[int]] = None,
+    ) -> Callable[[Type[SlashCommandGroup]], SlashCommandGroup]:
+        """A shortcut decorator that initializes the provided subclass of :class:`.SlashCommandGroup`
+        as a subgroup.
+
+        .. versionadded:: 2.0
+
+        Parameters
+        ----------
+        name: :class:`str`
+            The name of the group to create.
+        description: Optional[:class:`str`]
+            The description of the group to create.
+        guild_ids: Optional[List[:class:`int`]]
+            A list of the IDs of each guild this group should be added to, making it a guild command.
+            This will be a global command if ``None`` is passed.
+
+        Returns
+        --------
+        Callable[[Type[SlashCommandGroup]], SlashCommandGroup]
+            The slash command group that was created.
+        """
+        def inner(cls: Type[SlashCommandGroup]) -> SlashCommandGroup:
+            group = cls(
+                name,
+                description or (
+                    inspect.cleandoc(cls.__doc__).splitlines()[0]
+                    if cls.__doc__ is not None
+                    else "No description provided"
+                ),
+                guild_ids=guild_ids,
+                parent=self,
+            )
+            self.subcommands.append(group)
+            return group
+        return inner
+
     async def _invoke(self, ctx: ApplicationContext) -> None:
         option = ctx.interaction.data["options"][0]
         command = find(lambda x: x.name == option["name"], self.subcommands)
@@ -804,6 +871,50 @@ async def invoke_autocomplete_callback(self, ctx: AutocompleteContext) -> None:
         ctx.interaction.data = option
         await command.invoke_autocomplete_callback(ctx)
 
+    def copy(self):
+        """Creates a copy of this command group.
+
+        Returns
+        --------
+        :class:`SlashCommandGroup`
+            A new instance of this command.
+        """
+        ret = self.__class__(
+            self.name,
+            self.description,
+            **self.__original_kwargs__,
+        )
+        return self._ensure_assignment_on_copy(ret)
+
+    def _ensure_assignment_on_copy(self, other):
+        other.parent = self.parent
+
+        other._before_invoke = self._before_invoke
+        other._after_invoke = self._after_invoke
+
+        if self.subcommands != other.subcommands:
+            other.subcommands = self.subcommands.copy()
+        
+        if self.checks != other.checks:
+            other.checks = self.checks.copy()
+
+        return other
+
+    def _update_copy(self, kwargs: Dict[str, Any]):
+        if kwargs:
+            kw = kwargs.copy()
+            kw.update(self.__original_kwargs__)
+            copy = self.__class__(self.callback, **kw)
+            return self._ensure_assignment_on_copy(copy)
+        else:
+            return self.copy()
+
+    def _set_cog(self, cog):
+        self.cog = cog
+        for subcommand in self.subcommands:
+            subcommand._set_cog(cog)
+        
+
 
 class ContextMenuCommand(ApplicationCommand):
     r"""A class that implements the protocol for context menu commands.

discord/ext/commands/core.py

@@ -1144,6 +1144,9 @@ async def can_run(self, ctx: Context) -> bool:
         finally:
             ctx.command = original
 
+    def _set_cog(self, cog):
+        self.cog = cog
+
 class GroupMixin(Generic[CogT]):
     """A mixin that implements common functionality for classes that behave
     similar to :class:`.Group` and are allowed to register commands.

examples/app_commands/slash_cog_groups.py

@@ -0,0 +1,42 @@
+import discord
+from discord.commands import SlashCommandGroup, Permission
+from discord.ext import commands
+
+bot = discord.Bot(debug_guild=..., owner_id=...)  # main file
+
+
+class Example(commands.Cog):
+    def __init__(self, bot):
+        self.bot = bot
+
+    greetings = SlashCommandGroup("greetings", "Various greeting from cogs!")
+
+    international_greetings = greetings.create_subgroup(
+        "international", "International greetings"
+    )
+
+    secret_greetings = SlashCommandGroup(
+        "secret_greetings",
+        "Secret greetings",
+        permissions=[
+            Permission(
+                "owner", 2, True
+            )  # Ensures the owner_id user can access this, and no one else
+        ],
+    )
+
+    @greetings.command()
+    async def hello(self, ctx):
+        await ctx.respond("Hello, this is a slash subcommand from a cog!")
+
+    @international_greetings.command()
+    async def aloha(self, ctx):
+        await ctx.respond("Aloha, a Hawaiian greeting")
+
+    @secret_greetings.command()
+    async def secret_handshake(self, ctx, member: discord.Member):
+        await ctx.respond(f"{member.mention} secret handshakes you")
+
+
+bot.add_cog(Example(bot))  # put in a setup function for cog files
+bot.run("TOKEN")  # main file