Merge pull request #126 from eunwoo1104/anothercat/prevent-uneeded-requests-autoregister

 Prevent unneeded requests while using sync_commands

Author: eunwoo1104

discord_slash/client.py

@@ -296,24 +296,62 @@ async def sync_all_commands(self, delete_from_unused_guilds=False):
         Matches commands registered on Discord to commands registered here.
         Deletes any commands on Discord but not here, and registers any not on Discord.
         This is done with a `put` request.
+        A PUT request will only be made if there are changes detected.
         If ``sync_commands`` is ``True``, then this will be automatically called.
 
         :param delete_from_unused_guilds: If the bot should make a request to set no commands for guilds that haven't got any commands registered in :class:``SlashCommand``
         """
         cmds = await self.to_dict()
         self.logger.info("Syncing commands...")
-        other_guilds = [x.id for x in self._discord.guilds if x.id not in cmds["guild"]]
-        # This is an extremely bad way to do this, because slash cmds can be in guilds the bot isn't in
-        # But it's the only way until discord makes an endpoint to request all the guild with cmds registered.
+        cmds_formatted = {None: cmds['global']}
+        for guild in cmds['guild']:
+            cmds_formatted[guild] = cmds['guild'][guild]
+                
+        for scope in cmds_formatted:
+            new_cmds = cmds_formatted[scope]
+            existing_cmds = await self.req.get_all_commands(guild_id = scope)
+            existing_by_name = {}
+            to_send=[]
+            changed = False
+            for cmd in existing_cmds:
+                existing_by_name[cmd["name"]] = model.CommandData(**cmd)
+
+            if len(new_cmds) != len(existing_cmds): 
+                changed = True
+
+            for command in new_cmds:
+                cmd_name = command["name"]
+                if cmd_name in existing_by_name:
+                    cmd_data = model.CommandData(**command)
+                    existing_cmd = existing_by_name[cmd_name]
+                    if cmd_data != existing_cmd:
+                        changed=True
+                        to_send.append(command)
+                    else:
+                        command_with_id = command
+                        command_with_id["id"] = existing_cmd.id
+                        to_send.append(command_with_id)
+                else:
+                    changed=True
+                    to_send.append(command)
 
-        await self.req.put_slash_commands(slash_commands=cmds["global"], guild_id=None)
+            
+            if changed:
+                self.logger.debug(f"Detected changes on {scope if scope is not None else 'global'}, updating them")
+                await self.req.put_slash_commands(slash_commands=to_send, guild_id=scope)
+            else:
+                self.logger.debug(f"Detected no changes on {scope if scope is not None else 'global'}, skipping")
 
-        for x in cmds["guild"]:
-            await self.req.put_slash_commands(slash_commands=cmds["guild"][x], guild_id=x)
         if delete_from_unused_guilds:
-            for x in other_guilds:
+            other_guilds = [guild.id for guild in self._discord.guilds if guild.id not in cmds["guild"]]
+            # This is an extremly bad way to do this, because slash cmds can be in guilds the bot isn't in
+            # But it's the only way until discord makes an endpoint to request all the guild with cmds registered.
+            
+            for guild in other_guilds:
                 with suppress(discord.Forbidden):
-                    await self.req.put_slash_commands(slash_commands=[], guild_id=x)
+                    existing = self.req.get_all_commands(guild_id = guild)
+                    if len(existing) != 0:
+                        await self.req.put_slash_commands(slash_commands=[], guild_id=guild)
 
         self.logger.info("Completed syncing all commands!")
 

discord_slash/error.py

@@ -55,7 +55,14 @@ class IncorrectType(SlashCommandError):
     Type passed was incorrect
     """
 
+
+class IncorrectCommandData(SlashCommandError):
+    """
+    Incorrect data was passed to a slash command data object
+    """
+    
+
 class AlreadyResponded(SlashCommandError):
     """
     The interaction was already responded to
-    """
+    """

discord_slash/model.py

@@ -6,6 +6,96 @@
 from . import http
 from . import error
 
+class ChoiceData:
+    """
+    Command choice data object
+
+    :ivar name: Name of the choice, this is what the user will see
+    :ivar value: Values of the choice, this is what discord will return to you
+    """
+    def __init__(self, name, value):
+        self.name = name
+        self.value = value
+
+    def __eq__(self, other):
+        return isinstance(other, ChoiceData) and self.__dict__ == other.__dict__
+
+
+class OptionData:
+    """
+    Command option data object
+
+    :ivar name: Name of the option.
+    :ivar description: Description of the option.
+    :ivar required: If the option is required.
+    :ivar choices: A list of :class:`ChoiceData`, cannot be present on subcommand groups
+    :ivar options: List of :class:`OptionData`, this will be present if it's a subcommand group
+    """
+    def __init__(
+        self, name, description, required=False, choices=None, options=None, **kwargs
+    ):
+        self.name = name
+        self.description = description
+        self.type = kwargs.get("type")
+        if self.type is None:
+            raise error.IncorrectCommandData("type is required for options")
+        self.required = required
+        if choices is not None:
+            self.choices = []
+            for choice in choices:
+                self.choices.append(ChoiceData(**choice))
+        else:
+            self.choices = None
+
+        if self.type in (1, 2):
+            self.options = []
+            if options is not None:
+                for option in options:
+                    self.options.append(OptionData(**option))
+            elif self.type == 2:
+                raise error.IncorrectCommandData(
+                    "Options are required for subcommands / subcommand groups"
+                )
+
+    def __eq__(self, other):
+        return isinstance(other, OptionData) and self.__dict__ == other.__dict__
+
+
+class CommandData:
+    """
+    Slash command data object
+
+    :ivar name: Name of the command.
+    :ivar description: Description of the command.
+    :ivar options: List of :class:`OptionData`.
+    :ivar id: Command id, this is received from discord so may not be present
+    """
+
+    def __init__(
+        self, name, description, options = [], id=None, application_id = None, version = None, **kwargs
+    ):
+        self.name = name
+        self.description = description
+        self.id = id
+        self.application_id = application_id
+        self.version = version
+        if options is not None:
+            self.options = []
+            for option in options:
+                self.options.append(OptionData(**option))
+        else:
+            self.options = None
+
+    def __eq__(self, other):
+        if isinstance(other, CommandData):
+            return (
+                self.name == other.name
+                and self.description == other.description
+                and self.options == other.options
+            )
+        else:
+            return False
+
 
 class CommandObject:
     """