Changed all command dict to object

Author: eunwoo1104

discord_slash/client.py

@@ -26,6 +26,7 @@ class SlashCommand:
     :ivar auto_register: Whether to register commands automatically.
     :ivar has_listener: Whether discord client has listener add function.
     """
+
     def __init__(self,
                  client: typing.Union[discord.Client, commands.Bot],
                  auto_register: bool = False,
@@ -38,7 +39,8 @@ def __init__(self,
         self.auto_register = auto_register
         if self.auto_register:
             self._discord.loop.create_task(self.register_all_commands())
-        if not isinstance(client, commands.Bot) and not isinstance(client, commands.AutoShardedBot) and not override_type:
+        if not isinstance(client, commands.Bot) and not isinstance(client,
+                                                                   commands.AutoShardedBot) and not override_type:
             self.logger.info("Detected discord.Client! Overriding on_socket_response.")
             self._discord.on_socket_response = self.on_socket_response
             self.has_listener = False
@@ -58,12 +60,33 @@ def remove(self):
             return
         self._discord.remove_listener(self.on_socket_response)
 
+    def get_cog_commands(self, cog: commands.Cog):
+        func_list = [getattr(cog, x) for x in dir(cog)]
+        res = [x for x in func_list if
+               isinstance(x, model.CogCommandObject) or isinstance(x, model.CogSubcommandObject)]
+        for x in res:
+            if isinstance(x, model.CogCommandObject):
+                self.commands[x.name] = x
+            else:
+                if x.base in self.commands.keys():
+                    self.commands[x.base].allowed_guild_ids += x.allowed_guild_ids
+                    self.commands[x.base].has_subcommands = True
+                if x.base not in self.subcommands.keys():
+                    self.subcommands[x.base] = {}
+                if x.subcommand_group:
+                    if x.subcommand_group not in self.subcommands:
+                        self.subcommands[x.base][x.subcommand_group] = {}
+                    else:
+                        self.subcommands[x.base][x.subcommand_group][x.name] = x
+                else:
+                    self.subcommands[x.base][x.name] = x
+
     async def register_all_commands(self):
         """
         Registers all slash commands except subcommands to Discord API.\n
         If ``auto_register`` is ``True``, then this will be automatically called.
         """
-        await self._discord.wait_until_ready() # In case commands are still not registered to SlashCommand.
+        await self._discord.wait_until_ready()  # In case commands are still not registered to SlashCommand.
         self.logger.info("Registering commands...")
         for x in self.commands.keys():
             selected = self.commands[x]
@@ -129,7 +152,7 @@ def add_slash_command(self,
             "api_options": options if options else [],
             "has_subcommands": has_subcommands
         }
-        self.commands[name] = _cmd
+        self.commands[name] = model.CommandObject(name, _cmd)
         self.logger.debug(f"Added command `{name}`")
 
     def add_subcommand(self,
@@ -163,7 +186,11 @@ def add_subcommand(self,
         name = cmd.__name__ if not name else name
         name = name.lower()
         _cmd = {
+            "func": None,
+            "description": description if description else "No description.",
+            "auto_convert": {},
             "guild_ids": guild_ids,
+            "api_options": [],
             "has_subcommands": True
         }
         _sub = {
@@ -174,18 +201,20 @@ def add_subcommand(self,
             "guild_ids": guild_ids,
         }
         if base not in self.commands.keys():
-            self.commands[base] = _cmd
+            self.commands[base] = model.CommandObject(base, _cmd)
         else:
-            self.subcommands[base]["has_subcommands"] = True
+            self.subcommands[base].has_subcommands = True
+            self.subcommands[base].guild_ids += guild_ids
         if base not in self.subcommands.keys():
             self.subcommands[base] = {}
         if subcommand_group:
             if subcommand_group not in self.subcommands[base].keys():
                 self.subcommands[base][subcommand_group] = {}
-            self.subcommands[base][subcommand_group][name] = _sub
+            self.subcommands[base][subcommand_group][name] = model.SubcommandObject(_sub, base, name, subcommand_group)
         else:
-            self.subcommands[base][name] = _sub
-        self.logger.debug(f"Added subcommand `{base} {subcommand_group if subcommand_group else ''} {cmd.__name__ if not name else name}`")
+            self.subcommands[base][name] = model.SubcommandObject(_sub, base, name)
+        self.logger.debug(
+            f"Added subcommand `{base} {subcommand_group if subcommand_group else ''} {cmd.__name__ if not name else name}`")
 
     def slash(self,
               *,
@@ -259,6 +288,7 @@ async def _pick(ctx, choice1, choice2): # Command with 1 or more args.
         def wrapper(cmd):
             self.add_slash_command(cmd, name, description, auto_convert, guild_ids, options)
             return cmd
+
         return wrapper
 
     def subcommand(self,
@@ -311,6 +341,7 @@ async def _group_kick_user(ctx, user):
         def wrapper(cmd):
             self.add_subcommand(cmd, base, subcommand_group, name, description, auto_convert, guild_ids)
             return cmd
+
         return wrapper
 
     async def process_options(self, guild: discord.Guild, options: list, auto_convert: dict) -> list:
@@ -388,18 +419,21 @@ async def on_socket_response(self, msg):
             return
         to_use = msg["d"]
         if to_use["data"]["name"] in self.commands.keys():
-            selected_cmd = self.commands[to_use["data"]["name"]]
             ctx = model.SlashContext(self.req, to_use, self._discord, self.logger)
-            if selected_cmd["guild_ids"]:
-                if ctx.guild.id not in selected_cmd["guild_ids"]:
+            cmd_name = to_use["data"]["name"]
+            if cmd_name not in self.commands.keys() and cmd_name in self.subcommands.keys():
+                return await self.handle_subcommand(ctx, to_use)
+            selected_cmd = self.commands[to_use["data"]["name"]]
+            if selected_cmd.allowed_guild_ids:
+                if ctx.guild.id not in selected_cmd.allowed_guild_ids:
                     return
-            if selected_cmd["has_subcommands"]:
+            if selected_cmd.has_subcommands:
                 return await self.handle_subcommand(ctx, to_use)
-            args = await self.process_options(ctx.guild, to_use["data"]["options"], selected_cmd["auto_convert"]) \
+            args = await self.process_options(ctx.guild, to_use["data"]["options"], selected_cmd.auto_convert) \
                 if "options" in to_use["data"] else []
             self._discord.dispatch("slash_command", ctx)
             try:
-                await selected_cmd["func"](ctx, *args)
+                await selected_cmd.invoke(ctx, *args)
             except Exception as ex:
                 await self.on_slash_command_error(ctx, ex)
 
@@ -429,20 +463,20 @@ async def handle_subcommand(self, ctx: model.SlashContext, data: dict):
                     return
                 ctx.subcommand_group = sub_group
                 selected = base[sub_name][sub_group]
-                args = await self.process_options(ctx.guild, x["options"], selected["auto_convert"]) \
+                args = await self.process_options(ctx.guild, x["options"], selected.auto_convert) \
                     if "options" in x.keys() else []
                 self._discord.dispatch("slash_command", ctx)
                 try:
-                    await selected["func"](ctx, *args)
+                    await selected.invoke(ctx, *args)
                 except Exception as ex:
                     await self.on_slash_command_error(ctx, ex)
                 return
         selected = base[sub_name]
-        args = await self.process_options(ctx.guild, sub_opts, selected["auto_convert"]) \
+        args = await self.process_options(ctx.guild, sub_opts, selected.auto_convert) \
             if "options" in sub.keys() else []
         self._discord.dispatch("slash_command", ctx)
         try:
-            await selected["func"](ctx, *args)
+            await selected.invoke(ctx, *args)
         except Exception as ex:
             await self.on_slash_command_error(ctx, ex)
 

discord_slash/cog_ext.py

@@ -0,0 +1,27 @@
+import typing
+from discord.ext import commands
+from .model import CogCommandObject, CogSubcommandObject
+
+
+def cog_slash(*,
+              name: str = None,
+              description: str = None,
+              auto_convert: dict = None,
+              guild_ids: typing.List[int] = None,
+              options: typing.List[dict] = None):
+    def wrapper(cmd):
+        _cmd = {
+            "func": cmd,
+            "description": description if description else "No description.",
+            "auto_convert": auto_convert,
+            "guild_ids": guild_ids,
+            "api_options": options if options else [],
+            "has_subcommands": False
+        }
+        return CogCommandObject(name, _cmd)
+    return wrapper
+
+
+def register_cog_slash(cls):
+    func_list = [getattr(cls, x) for x in dir(cls)]
+    return [x for x in func_list if isinstance(x, CogCommandObject) or isinstance(x, CogSubcommandObject)]

discord_slash/model.py

@@ -170,38 +170,34 @@ async def delete(self, message_id: typing.Union[int, str] = "@original"):
         await self._http.delete(self._discord.user.id, self.__token, message_id)
 
 
-"""
-{
-    "type": 2,
-    "token": "A_UNIQUE_TOKEN",
-    "member": { 
-        "user": {
-            "id": 53908232506183680,
-            "username": "Mason",
-            "avatar": "a_d5efa99b3eeaa7dd43acca82f5692432",
-            "discriminator": "1337",
-            "public_flags": 131141
-        },
-        "roles": [539082325061836999],
-        "premium_since": null,
-        "permissions": "2147483647",
-        "pending": false,
-        "nick": null,
-        "mute": false,
-        "joined_at": "2017-03-13T19:19:14.040000+00:00",
-        "is_pending": false,
-        "deaf": false 
-    },
-    "id": "786008729715212338",
-    "guild_id": "290926798626357999",
-    "data": { 
-        "options": [{
-            "name": "cardname",
-            "value": "The Gitrog Monster"
-        }],
-        "name": "cardsearch",
-        "id": "771825006014889984" 
-    },
-    "channel_id": "645027906669510667" 
-}
-"""
+class CommandObject:
+    def __init__(self, name, cmd, *subcommands): # Let's reuse old command formatting.
+        self.name = name
+        self.invoke = cmd["func"]
+        self.description = cmd["description"]
+        self.auto_convert = cmd["auto_convert"]
+        self.allowed_guild_ids = cmd["guild_ids"]
+        self.options = cmd["api_options"]
+        self.has_subcommands = cmd["has_subcommands"]
+        self.subcommands = subcommands
+
+
+class SubcommandObject:
+    def __init__(self, sub, base, name, sub_group=None):
+        self.base = base
+        self.subcommand_group = sub_group
+        self.name = name
+        self.invoke = sub["func"]
+        self.description = sub["description"]
+        self.auto_convert = sub["auto_convert"]
+        self.allowed_guild_ids = sub["guild_ids"]
+
+
+class CogCommandObject(CommandObject):
+    def __init__(self, *args):
+        super().__init__(*args)
+
+
+class CogSubcommandObject(SubcommandObject):
+    def __init__(self, *args):
+        super().__init__(*args)