Revert "refactor: make Command.dispatch a function (#1040)"

This reverts commit b1d2787.

Author: EepyElvyra

interactions/client/bot.py

@@ -503,18 +503,17 @@ def __resolve_commands(self) -> None:
                 )
 
             data: Union[dict, List[dict]] = cmd.full_data
-            dispatcher = cmd.dispatcher
+            coro = cmd.dispatcher
 
             self.__check_command(
                 command=ApplicationCommand(**(data[0] if isinstance(data, list) else data)),
-                coro=dispatcher,
+                coro=coro,
             )
 
             if cmd.autocompletions:
                 self.__id_autocomplete.update(cmd.autocompletions)
 
-            # weird interaction with methods, where they're a read-only version of their function
-            coro = dispatcher.__func__ if hasattr(dispatcher, "__func__") else dispatcher
+            coro = coro.__func__ if hasattr(coro, "__func__") else coro
 
             coro._command_data = data
             coro._name = cmd.name
@@ -536,7 +535,7 @@ def __resolve_commands(self) -> None:
                 else:
                     self._scopes.add(cmd.scope if isinstance(cmd.scope, int) else cmd.scope.id)
 
-            self.event(dispatcher, name=f"command_{cmd.name}")
+            self.event(coro, name=f"command_{cmd.name}")
             cmd.resolved = True
 
     async def __sync(self) -> None:  # sourcery no-metrics
@@ -1595,6 +1594,7 @@ def __new__(cls, client: Client, *args, **kwargs) -> "Extension":
 
             commands = self._commands.get(cmd.name, [])
             coro = cmd.dispatcher
+            coro = coro.__func__ if hasattr(coro, "__func__") else coro
             commands.append(coro)
             self._commands[f"command_{cmd.name}"] = commands
 

interactions/client/models/command.py

@@ -702,57 +702,58 @@ def decorator(coro: Callable[..., Awaitable]) -> "Command":
 
         return decorator
 
-    async def dispatcher(
-        self,
-        ctx: "CommandContext",
-        *args,
-        sub_command_group: Optional[str] = None,
-        sub_command: Optional[str] = None,
-        **kwargs,
-    ) -> Optional[BaseResult]:
-        r"""
-        Call the command along with any subcommands
-
-        :param ctx: The context for the interaction
-        :type ctx: CommandContext
-        :param args: The args to be passed to the command
-        :type args: tuple
-        :param sub_command_group: The subcommand group being invoked, if any
-        :type sub_command_group: Optional[str]
-        :param sub_command: The subcommand being invoked, if any
-        :type sub_command: Optional[str]
-        :param kwargs: The kwargs to pass to the command
-        :type kwargs: Dict
-        :return: The result of the base command if no StopCommand is returned anywhere, else None
-        :rtype: Optional[BaseResult]
+    @property
+    def dispatcher(self) -> Callable[..., Awaitable]:
         """
-        base_coro = self.coro
-        base_res = BaseResult(
-            result=await self.__call(base_coro, ctx, *args, _name=self.name, **kwargs)
-        )
-        if base_res() is StopCommand or isinstance(base_res(), StopCommand):
-            return
-        if sub_command_group:
-            group_coro = self.coroutines[sub_command_group]
-            name = f"{sub_command_group} {sub_command}"
-            subcommand_coro = self.coroutines[name]
-            group_res = GroupResult(
-                result=await self.__call(
-                    group_coro, ctx, *args, _res=base_res, _name=sub_command_group, **kwargs
-                ),
-                parent=base_res,
+        Returns a coroutine that calls the command along with the subcommands, if any.
+
+        .. note::
+            The coroutine returned is never the same object.
+
+        :return: A coroutine that calls the command along with the subcommands, if any.
+        :rtype: Callable[..., Awaitable]
+        """
+        if not self.has_subcommands:
+            return self.__wrap_coro(self.coro)
+
+        @wraps(self.coro)
+        async def dispatch(
+            ctx: "CommandContext",
+            *args,
+            sub_command_group: Optional[str] = None,
+            sub_command: Optional[str] = None,
+            **kwargs,
+        ) -> Optional[Any]:
+            """Dispatches all of the subcommands of the command."""
+            base_coro = self.coro
+            base_res = BaseResult(
+                result=await self.__call(base_coro, ctx, *args, _name=self.name, **kwargs)
             )
-            if group_res() is StopCommand or isinstance(group_res(), StopCommand):
+            if base_res() is StopCommand or isinstance(base_res(), StopCommand):
                 return
-            return await self.__call(
-                subcommand_coro, ctx, *args, _res=group_res, _name=name, **kwargs
-            )
-        elif sub_command:
-            subcommand_coro = self.coroutines[sub_command]
-            return await self.__call(
-                subcommand_coro, ctx, *args, _res=base_res, _name=sub_command, **kwargs
-            )
-        return base_res
+            if sub_command_group:
+                group_coro = self.coroutines[sub_command_group]
+                name = f"{sub_command_group} {sub_command}"
+                subcommand_coro = self.coroutines[name]
+                group_res = GroupResult(
+                    result=await self.__call(
+                        group_coro, ctx, *args, _res=base_res, _name=sub_command_group, **kwargs
+                    ),
+                    parent=base_res,
+                )
+                if group_res() is StopCommand or isinstance(group_res(), StopCommand):
+                    return
+                return await self.__call(
+                    subcommand_coro, ctx, *args, _res=group_res, _name=name, **kwargs
+                )
+            elif sub_command:
+                subcommand_coro = self.coroutines[sub_command]
+                return await self.__call(
+                    subcommand_coro, ctx, *args, _res=base_res, _name=sub_command, **kwargs
+                )
+            return base_res
+
+        return dispatch
 
     def autocomplete(
         self, name: Optional[str] = MISSING