Implement application command permissions v2

discord/audit_logs.py

@@ -238,6 +238,7 @@ class AuditLogChanges:
             "location_type",
             _enum_transformer(enums.ScheduledEventLocationType),
         ),
+        "command_id": ("command_id", _transform_snowflake),
     }
 
     def __init__(

discord/bot.py

@@ -256,7 +256,8 @@ def _check_command(cmd: ApplicationCommand, match: Dict) -> bool:
             else:
                 as_dict = cmd.to_dict()
                 to_check = {
-                    "default_permission": None,
+                    "dm_permission": None,
+                    "default_member_permissions": None,
                     "name": None,
                     "description": None,
                     "name_localizations": None,
@@ -572,7 +573,6 @@ async def sync_commands(
         register_guild_commands: bool = True,
         check_guilds: Optional[List[int]] = [],
         delete_exiting: bool = True,
-        _register_permissions: bool = True,  # TODO: Remove for perms v2
     ) -> None:
         """|coro|
 
@@ -645,12 +645,6 @@ async def sync_commands(
                     guild_commands, guild_id=guild_id, method=method, force=force, delete_existing=delete_exiting
                 )
 
-        # TODO: 2.1: Remove this and favor permissions v2
-        # Global Command Permissions
-
-        if not _register_permissions:
-            return
-
         global_permissions: List = []
 
         for i in registered_commands:
@@ -664,12 +658,7 @@ async def sync_commands(
                 cmd.id = i["id"]
                 self._application_commands[cmd.id] = cmd
 
-                # Permissions (Roles will be converted to IDs just before Upsert for Global Commands)
-                global_permissions.append({"id": i["id"], "permissions": cmd.permissions})
-
         for guild_id, commands in registered_guild_commands.items():
-            guild_permissions: List = []
-
             for i in commands:
                 cmd = find(
                     lambda cmd: cmd.name == i["name"]
@@ -684,105 +673,6 @@ async def sync_commands(
                 cmd.id = i["id"]
                 self._application_commands[cmd.id] = cmd
 
-                # Permissions
-                permissions = [
-                    perm.to_dict()
-                    for perm in cmd.permissions
-                    if perm.guild_id is None
-                    or (perm.guild_id == guild_id and cmd.guild_ids is not None and perm.guild_id in cmd.guild_ids)
-                ]
-                guild_permissions.append({"id": i["id"], "permissions": permissions})
-
-            for global_command in global_permissions:
-                permissions = [
-                    perm.to_dict()
-                    for perm in global_command["permissions"]
-                    if perm.guild_id is None
-                    or (perm.guild_id == guild_id and cmd.guild_ids is not None and perm.guild_id in cmd.guild_ids)
-                ]
-                guild_permissions.append({"id": global_command["id"], "permissions": permissions})
-
-            # Collect & Upsert Permissions for Each Guild
-            # Command Permissions for this Guild
-            guild_cmd_perms: List = []
-
-            # Loop through Commands Permissions available for this Guild
-            for item in guild_permissions:
-                new_cmd_perm = {"id": item["id"], "permissions": []}
-
-                # Replace Role / Owner Names with IDs
-                for permission in item["permissions"]:
-                    if isinstance(permission["id"], str):
-                        # Replace Role Names
-                        if permission["type"] == 1:
-                            role = get(
-                                self._bot.get_guild(guild_id).roles,
-                                name=permission["id"],
-                            )
-
-                            # If not missing
-                            if role is not None:
-                                new_cmd_perm["permissions"].append(
-                                    {
-                                        "id": role.id,
-                                        "type": 1,
-                                        "permission": permission["permission"],
-                                    }
-                                )
-                            else:
-                                raise RuntimeError(
-                                    "No Role ID found in Guild ({guild_id}) for Role ({role})".format(
-                                        guild_id=guild_id, role=permission["id"]
-                                    )
-                                )
-                        # Add owner IDs
-                        elif permission["type"] == 2 and permission["id"] == "owner":
-                            app = await self.application_info()  # type: ignore
-                            if app.team:
-                                for m in app.team.members:
-                                    new_cmd_perm["permissions"].append(
-                                        {
-                                            "id": m.id,
-                                            "type": 2,
-                                            "permission": permission["permission"],
-                                        }
-                                    )
-                            else:
-                                new_cmd_perm["permissions"].append(
-                                    {
-                                        "id": app.owner.id,
-                                        "type": 2,
-                                        "permission": permission["permission"],
-                                    }
-                                )
-                    # Add the rest
-                    else:
-                        new_cmd_perm["permissions"].append(permission)
-
-                # Make sure we don't have over 10 overwrites
-                if len(new_cmd_perm["permissions"]) > 10:
-                    raise RuntimeError(
-                        "Command '{name}' has more than 10 permission overrides in guild ({guild_id}).".format(
-                            name=self._application_commands[new_cmd_perm["id"]].name,
-                            guild_id=guild_id,
-                        )
-                    )
-                # Append to guild_cmd_perms
-                guild_cmd_perms.append(new_cmd_perm)
-
-            # Upsert
-            try:
-                await self._bot.http.bulk_upsert_command_permissions(self._bot.user.id, guild_id, guild_cmd_perms)
-            except Forbidden:
-                raise RuntimeError(
-                    f"Failed to add command permissions to guild {guild_id}",
-                    file=sys.stderr,
-                )
-            except HTTPException:
-                _log.warning(
-                    "Command Permissions V2 not yet implemented, permissions will not be set for your commands."
-                )
-
     async def process_application_commands(self, interaction: Interaction, auto_sync: bool = None) -> None:
         """|coro|
 

discord/commands/core.py

@@ -67,7 +67,6 @@
 from ..utils import async_all, find, get_or_fetch, utcnow
 from .context import ApplicationContext, AutocompleteContext
 from .options import Option, OptionChoice
-from .permissions import CommandPermission
 
 __all__ = (
     "_BaseCommand",
@@ -88,6 +87,7 @@
     from typing_extensions import Concatenate, ParamSpec
 
     from ..cog import Cog
+    from .. import Permissions
 
 T = TypeVar("T")
 CogT = TypeVar("CogT", bound="Cog")
@@ -201,6 +201,12 @@ def __init__(self, func: Callable, **kwargs) -> None:
         self.guild_ids: Optional[List[int]] = kwargs.get("guild_ids", None)
         self.parent = kwargs.get("parent")
 
+        # Permissions
+        self.default_member_permissions: Optional["Permissions"] = getattr(
+            func, "__default_member_permissions__", kwargs.get("default_member_permissions", None)
+        )
+        self.guild_only: Optional[bool] = getattr(func, "__guild_only__", kwargs.get("guild_only", None))
+
     def __repr__(self) -> str:
         return f"<discord.commands.{self.__class__.__name__} name={self.name}>"
 
@@ -573,16 +579,11 @@ class SlashCommand(ApplicationCommand):
     parent: Optional[:class:`SlashCommandGroup`]
         The parent group that this command belongs to. ``None`` if there
         isn't one.
-    default_permission: :class:`bool`
-        Whether the command is enabled by default when it is added to a guild.
-    permissions: List[:class:`CommandPermission`]
-        The permissions for this command.
-
-        .. note::
-
-            If this is not empty then default_permissions will be set to False.
-
-    cog: Optional[:class:`.Cog`]
+    guild_only: :class:`bool`
+        Whether the command should only be usable inside a guild.
+    default_member_permissions: :class:`~discord.Permissions`
+        The default permissions a member needs to be able to run the command.
+    cog: Optional[:class:`Cog`]
         The cog that this command belongs to. ``None`` if there isn't one.
     checks: List[Callable[[:class:`.ApplicationContext`], :class:`bool`]]
         A list of predicates that verifies if the command could be executed
@@ -647,14 +648,6 @@ def __init__(self, func: Callable, *args, **kwargs) -> None:
         self._before_invoke = None
         self._after_invoke = None
 
-        # Permissions
-        self.default_permission = kwargs.get("default_permission", True)
-        self.permissions: List[CommandPermission] = getattr(func, "__app_cmd_perms__", []) + kwargs.get(
-            "permissions", []
-        )
-        if self.permissions and self.default_permission:
-            self.default_permission = False
-
     def _parse_options(self, params) -> List[Option]:
         if list(params.items())[0][0] == "self":
             temp = list(params.items())
@@ -761,7 +754,6 @@ def to_dict(self) -> Dict:
             "name": self.name,
             "description": self.description,
             "options": [o.to_dict() for o in self.options],
-            "default_permission": self.default_permission,
         }
         if self.name_localizations is not None:
             as_dict["name_localizations"] = self.name_localizations
@@ -770,6 +762,12 @@ def to_dict(self) -> Dict:
         if self.is_subcommand:
             as_dict["type"] = SlashCommandOptionType.sub_command.value
 
+        if self.guild_only is not None:
+            as_dict["guild_only"] = self.guild_only
+
+        if self.default_member_permissions is not None:
+            as_dict["default_member_permissions"] = self.default_member_permissions.value
+
         return as_dict
 
     async def _invoke(self, ctx: ApplicationContext) -> None:
@@ -917,6 +915,10 @@ class SlashCommandGroup(ApplicationCommand):
     parent: Optional[:class:`SlashCommandGroup`]
         The parent group that this group belongs to. ``None`` if there
         isn't one.
+    guild_only: :class:`bool`
+        Whether the command should only be usable inside a guild.
+    default_member_permissions: :class:`~discord.Permissions`
+        The default permissions a member needs to be able to run the command.
     subcommands: List[Union[:class:`SlashCommand`, :class:`SlashCommandGroup`]]
         The list of all subcommands under this group.
     cog: Optional[:class:`.Cog`]
@@ -979,10 +981,9 @@ def __init__(
         self.id = None
 
         # Permissions
-        self.default_permission = kwargs.get("default_permission", True)
-        self.permissions: List[CommandPermission] = kwargs.get("permissions", [])
-        if self.permissions and self.default_permission:
-            self.default_permission = False
+        self.default_member_permissions: Optional["Permissions"] = kwargs.get("default_member_permissions", None)
+        self.guild_only: Optional[bool] = kwargs.get("guild_only", None)
+
         self.name_localizations: Optional[Dict[str, str]] = kwargs.get("name_localizations", None)
         self.description_localizations: Optional[Dict[str, str]] = kwargs.get("description_localizations", None)
 
@@ -995,7 +996,6 @@ 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.name_localizations is not None:
             as_dict["name_localizations"] = self.name_localizations
@@ -1005,6 +1005,12 @@ def to_dict(self) -> Dict:
         if self.parent is not None:
             as_dict["type"] = self.input_type.value
 
+        if self.guild_only is not None:
+            as_dict["guild_only"] = self.guild_only
+
+        if self.default_member_permissions is not None:
+            as_dict["default_member_permissions"] = self.default_member_permissions.value
+
         return as_dict
 
     def command(self, **kwargs) -> Callable[[Callable], SlashCommand]:
@@ -1183,15 +1189,11 @@ class ContextMenuCommand(ApplicationCommand):
         The coroutine that is executed when the command is called.
     guild_ids: Optional[List[:class:`int`]]
         The ids of the guilds where this command will be registered.
-    default_permission: :class:`bool`
-        Whether the command is enabled by default when it is added to a guild.
-    permissions: List[:class:`.CommandPermission`]
-        The permissions for this command.
-
-        .. note::
-            If this is not empty then default_permissions will be set to ``False``.
-
-    cog: Optional[:class:`.Cog`]
+    guild_only: :class:`bool`
+        Whether the command should only be usable inside a guild.
+    default_member_permissions: :class:`~discord.Permissions`
+        The default permissions a member needs to be able to run the command.
+    cog: Optional[:class:`Cog`]
         The cog that this command belongs to. ``None`` if there isn't one.
     checks: List[Callable[[:class:`.ApplicationContext`], :class:`bool`]]
         A list of predicates that verifies if the command could be executed
@@ -1236,13 +1238,6 @@ def __init__(self, func: Callable, *args, **kwargs) -> None:
 
         self.validate_parameters()
 
-        self.default_permission = kwargs.get("default_permission", True)
-        self.permissions: List[CommandPermission] = getattr(func, "__app_cmd_perms__", []) + kwargs.get(
-            "permissions", []
-        )
-        if self.permissions and self.default_permission:
-            self.default_permission = False
-
         # Context Menu commands can't have parents
         self.parent = None
 
@@ -1283,9 +1278,14 @@ def to_dict(self) -> Dict[str, Union[str, int]]:
             "name": self.name,
             "description": self.description,
             "type": self.type,
-            "default_permission": self.default_permission,
         }
 
+        if self.guild_only is not None:
+            as_dict["guild_only"] = self.guild_only
+
+        if self.default_member_permissions is not None:
+            as_dict["default_member_permissions"] = self.default_member_permissions.value
+
         if self.name_localizations is not None:
             as_dict["name_localizations"] = self.name_localizations
 
@@ -1619,42 +1619,42 @@ def validate_chat_input_name(name: Any, locale: Optional[str] = None):
     # Must meet the regex ^[-_\w\d\u0901-\u097D\u0E00-\u0E7F]{1,32}$
     if locale is not None and locale not in valid_locales:
         raise ValidationError(
-            f"Locale '{locale}' is not a valid locale, "
-            f"see {docs}/reference#locales for list of supported locales."
+            f"Locale '{locale}' is not a valid locale, " f"see {docs}/reference#locales for list of supported locales."
         )
     error = None
-    if not isinstance(name, str):
+    if not isinstance(name, str) or not re.match(r"^[\w-]{1,32}$", name):
         error = TypeError(f"Command names and options must be of type str. Received \"{name}\"")
     elif not re.match(r"^[-_\w\d\u0901-\u097D\u0E00-\u0E7F]{1,32}$", name):
         error = ValidationError(
             r"Command names and options must follow the regex \"^[-_\w\d\u0901-\u097D\u0E00-\u0E7F]{1,32}$\". For more information, see "
             f"{docs}/interactions/application-commands#application-command-object-application-command-naming. "
-            f"Received \"{name}\""
+            f'Received "{name}"'
         )
     elif not 1 <= len(name) <= 32:
-        error = ValidationError(f"Command names and options must be 1-32 characters long. Received \"{name}\"")
+        error = ValidationError(f'Command names and options must be 1-32 characters long. Received "{name}"')
     elif not name.lower() == name:  # Can't use islower() as it fails if none of the chars can be lower. See #512.
-        error = ValidationError(f"Command names and options must be lowercase. Received \"{name}\"")
+        error = ValidationError(f'Command names and options must be lowercase. Received "{name}"')
 
     if error:
         if locale:
-            error.args = (error.args[0]+f" in locale {locale}",)
+            error.args = (f"{error.args[0]} in locale {locale}",)
         raise error
 
 
 def validate_chat_input_description(description: Any, locale: Optional[str] = None):
     if locale is not None and locale not in valid_locales:
         raise ValidationError(
-            f"Locale '{locale}' is not a valid locale, "
-            f"see {docs}/reference#locales for list of supported locales."
+            f"Locale '{locale}' is not a valid locale, " f"see {docs}/reference#locales for list of supported locales."
         )
     error = None
     if not isinstance(description, str):
-        error = TypeError(f"Command and option description must be of type str. Received \"{description}\"")
+        error = TypeError(f'Command and option description must be of type str. Received "{description}"')
     elif not 1 <= len(description) <= 100:
-        error = ValidationError(f"Command and option description must be 1-100 characters long. Received \"{description}\"")
+        error = ValidationError(
+            f'Command and option description must be 1-100 characters long. Received "{description}"'
+        )
 
     if error:
         if locale:
-            error.args = (error.args[0]+f" in locale {locale}",)
+            error.args = (f"{error.args[0]} in locale {locale}",)
         raise error