hikari-arc 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

arc/command/slash.py

@@ -6,10 +6,11 @@ import typing as t
 import attr
 import hikari
 
-from arc.abc.command import CallableCommandBase, CommandBase, SubCommandBase
-from arc.abc.option import OptionWithChoices
+from arc.abc.command import CallableCommandBase, CallableCommandProto, CommandBase, SubCommandBase, _CommandSettings
+from arc.abc.option import OptionType, OptionWithChoices
 from arc.context import AutocompleteData, AutodeferMode, Context
 from arc.errors import AutocompleteError, CommandInvokeError
+from arc.internal.options import resolve_options
 from arc.internal.sigparse import parse_command_signature
 from arc.internal.types import ClientT, CommandCallbackT, HookT, PostHookT, ResponseBuilderT, SlashCommandLike
 from arc.locale import CommandLocaleRequest, LocaleResponse
@@ -18,7 +19,7 @@ if t.TYPE_CHECKING:
     from asyncio.futures import Future
 
     from arc.abc.client import Client
-    from arc.abc.command import CallableCommandProto, CommandProto
+    from arc.abc.command import CommandProto
     from arc.abc.option import CommandOptionBase
     from arc.abc.plugin import PluginBase
 
@@ -33,64 +34,6 @@ __all__ = (
 )
 
 
-def _resolve_options(
-    local_options: t.MutableMapping[str, CommandOptionBase[ClientT, t.Any, t.Any]],
-    incoming_options: t.Sequence[hikari.CommandInteractionOption],
-    resolved: hikari.ResolvedOptionData | None,
-) -> dict[str, t.Any]:
-    """Resolve the options into kwargs for the callback.
-
-    Parameters
-    ----------
-    local_options : t.MutableMapping[str, Option[t.Any, t.Any]]
-        The options of the locally stored command.
-    incoming_options : t.Sequence[hikari.CommandInteractionOption]
-        The options of the interaction.
-    resolved : hikari.ResolvedOptionData
-        The resolved option data of the interaction.
-
-    Returns
-    -------
-    dict[str, Any]
-        The resolved options as kwargs, ready to be passed to the callback.
-    """
-    option_kwargs: dict[str, t.Any] = {}
-
-    for arg_name, opt in local_options.items():
-        inter_opt = next((o for o in incoming_options if o.name == opt.name), None)
-
-        if inter_opt is None:
-            continue
-
-        if isinstance(inter_opt.value, hikari.Snowflake) and resolved:
-            match inter_opt.type:
-                case hikari.OptionType.USER:
-                    value = resolved.members.get(inter_opt.value) or resolved.users[inter_opt.value]
-                case hikari.OptionType.ATTACHMENT:
-                    value = resolved.attachments[inter_opt.value]
-                case hikari.OptionType.CHANNEL:
-                    value = resolved.channels[inter_opt.value]
-                case hikari.OptionType.ROLE:
-                    value = resolved.roles[inter_opt.value]
-                case hikari.OptionType.MENTIONABLE:
-                    value = (
-                        resolved.members.get(inter_opt.value)
-                        or resolved.users.get(inter_opt.value)
-                        or resolved.roles[inter_opt.value]
-                    )
-                case _:
-                    raise ValueError(f"Unexpected option type '{inter_opt.type}.'")
-
-            option_kwargs[arg_name] = value
-
-        elif isinstance(inter_opt.value, hikari.Snowflake):
-            raise ValueError(f"Missing resolved option data for '{inter_opt.name}'.")
-        else:
-            option_kwargs[arg_name] = inter_opt.value
-
-    return option_kwargs
-
-
 def _choices_to_builders(
     choices: t.Sequence[hikari.api.AutocompleteChoiceBuilder] | t.Sequence[t.Any],
 ) -> t.Sequence[hikari.api.AutocompleteChoiceBuilder]:
@@ -126,6 +69,11 @@ class SlashCommand(CallableCommandBase[ClientT, hikari.api.SlashCommandBuilder])
     def qualified_name(self) -> t.Sequence[str]:
         return (self.name,)
 
+    @property
+    def display_name(self) -> str:
+        """The display name of this command."""
+        return f"/{self.name}"
+
     def _get_context(
         self, interaction: hikari.CommandInteraction, command: CallableCommandProto[ClientT]
     ) -> Context[ClientT]:
@@ -134,7 +82,9 @@ class SlashCommand(CallableCommandBase[ClientT, hikari.api.SlashCommandBuilder])
         if interaction.command_type is not hikari.CommandType.SLASH:
             raise ValueError(f"Expected slash command, got {interaction.command_type}")
 
-        return Context(self.client, command, interaction)
+        ctx = Context(self.client, command, interaction)
+        ctx._options = interaction.options
+        return ctx
 
     def _to_dict(self) -> dict[str, t.Any]:
         sorted_options = sorted(self.options.values(), key=lambda option: option.is_required, reverse=True)
@@ -164,11 +114,36 @@ class SlashCommand(CallableCommandBase[ClientT, hikari.api.SlashCommandBuilder])
             return await super().invoke(
                 interaction,
                 *args,
-                **{**kwargs, **_resolve_options(self.options, interaction.options, interaction.resolved)},
+                **{**kwargs, **resolve_options(self.options, interaction.options, interaction.resolved)},
             )
         else:
             return await super().invoke(interaction, *args, **kwargs)
 
+    def make_mention(self, *, guild: hikari.Snowflakeish | hikari.PartialGuild | None = None) -> str:
+        """Make a slash mention for this command.
+
+        Parameters
+        ----------
+        guild : hikari.SnowflakeishOr[hikari.PartialGuild] | None
+            The guild the command is registered in. If None, the global command's ID is used.
+
+        Returns
+        -------
+        str
+            The slash command mention.
+
+        Raises
+        ------
+        KeyError
+            If the command has not been published in the given guild or globally.
+        """
+        instance = self._instances.get(hikari.Snowflake(guild) if guild else None)
+
+        if instance is None:
+            raise KeyError(f"Command '{self.display_name}' has not been published in the given scope.")
+
+        return f"</{self.name}:{instance.id}>"
+
     async def _on_autocomplete(
         self, interaction: hikari.AutocompleteInteraction
     ) -> hikari.api.InteractionAutocompleteBuilder | None:
@@ -230,7 +205,7 @@ class SlashCommand(CallableCommandBase[ClientT, hikari.api.SlashCommandBuilder])
 class SlashGroup(CommandBase[ClientT, hikari.api.SlashCommandBuilder]):
     """A group for slash subcommands and subgroups."""
 
-    children: dict[str, SlashSubCommand[ClientT] | SlashSubGroup[ClientT]] = attr.field(factory=dict)
+    children: dict[str, SlashSubCommand[ClientT] | SlashSubGroup[ClientT]] = attr.field(factory=dict, init=False)
     """Subcommands and subgroups that belong to this group."""
 
     description: str = "No description provided."
@@ -249,6 +224,11 @@ class SlashGroup(CommandBase[ClientT, hikari.api.SlashCommandBuilder]):
     def qualified_name(self) -> t.Sequence[str]:
         return (self.name,)
 
+    @property
+    def display_name(self) -> str:
+        """The display name of this command."""
+        return f"/{self.name}"
+
     def _to_dict(self) -> dict[str, t.Any]:
         return {
             **super()._to_dict(),
@@ -283,13 +263,15 @@ class SlashGroup(CommandBase[ClientT, hikari.api.SlashCommandBuilder]):
         self,
         subcommand: SlashSubCommand[ClientT],
         interaction: hikari.CommandInteraction,
+        options: t.Sequence[hikari.CommandInteractionOption] | None = None,
         *args: t.Any,
         **kwargs: t.Any,
     ) -> asyncio.Future[ResponseBuilderT] | None:
         """Invoke a subcommand."""
         ctx = self._get_context(interaction, subcommand)
+        ctx._options = options
 
-        if (autodefer := subcommand._resolve_autodefer()) and autodefer.should_autodefer:
+        if (autodefer := subcommand.autodefer) and autodefer.should_autodefer:
             ctx._start_autodefer(autodefer)
 
         self._invoke_task = asyncio.create_task(self._handle_callback(subcommand, ctx, *args, **kwargs))
@@ -314,12 +296,12 @@ class SlashGroup(CommandBase[ClientT, hikari.api.SlashCommandBuilder]):
         if sub.options is None:
             if not isinstance(subcmd, SlashSubCommand):
                 raise CommandInvokeError(f"Slash group got subgroup without options: '{subcmd.name}'.")
-            return await self._invoke_subcmd(subcmd, interaction, *args, **kwargs)
+            return await self._invoke_subcmd(subcmd, interaction, None, *args, **kwargs)
 
         # Resolve options and invoke if it does
         if isinstance(subcmd, SlashSubCommand):
-            res = _resolve_options(subcmd.options, sub.options, interaction.resolved)
-            return await self._invoke_subcmd(subcmd, interaction, *args, **{**kwargs, **res})
+            res = resolve_options(subcmd.options, sub.options, interaction.resolved)
+            return await self._invoke_subcmd(subcmd, interaction, sub.options, *args, **{**kwargs, **res})
 
         # Get second-order subcommand
         subsub = next((o for o in sub.options if o.name in subcmd.children), None)
@@ -331,11 +313,11 @@ class SlashGroup(CommandBase[ClientT, hikari.api.SlashCommandBuilder]):
 
         # Invoke it if it has no options
         if subsub.options is None:
-            return await self._invoke_subcmd(subsubcmd, interaction, *args, **kwargs)
+            return await self._invoke_subcmd(subsubcmd, interaction, None, *args, **kwargs)
 
         # Resolve options and invoke if it does
-        res = _resolve_options(subsubcmd.options, subsub.options, interaction.resolved)
-        return await self._invoke_subcmd(subsubcmd, interaction, *args, **{**kwargs, **res})
+        res = resolve_options(subsubcmd.options, subsub.options, interaction.resolved)
+        return await self._invoke_subcmd(subsubcmd, interaction, subsub.options, *args, **{**kwargs, **res})
 
     async def _on_autocomplete(
         self, interaction: hikari.AutocompleteInteraction
@@ -427,7 +409,7 @@ class SlashGroup(CommandBase[ClientT, hikari.api.SlashCommandBuilder]):
         """Decorator to add a subcommand to this group."""
 
         def decorator(command: SlashSubCommand[ClientT]) -> SlashSubCommand[ClientT]:
-            command.parent = self
+            command._parent = self
             self.children[command.name] = command
             return command
 
@@ -442,8 +424,8 @@ class SlashGroup(CommandBase[ClientT, hikari.api.SlashCommandBuilder]):
         description: str = "No description provided.",
         *,
         autodefer: AutodeferMode | bool | hikari.UndefinedType = hikari.UNDEFINED,
-        name_localizations: dict[hikari.Locale, str] | None = None,
-        description_localizations: dict[hikari.Locale, str] | None = None,
+        name_localizations: t.Mapping[hikari.Locale, str] | None = None,
+        description_localizations: t.Mapping[hikari.Locale, str] | None = None,
     ) -> SlashSubGroup[ClientT]:
         """Create a subgroup and add it to this group.
 
@@ -451,24 +433,24 @@ class SlashGroup(CommandBase[ClientT, hikari.api.SlashCommandBuilder]):
         ----------
         name : str
             The name of the subgroup.
-        description : str, optional
-            The description of the subgroup, by default "No description provided."
-        autodefer : bool | AutodeferMode | hikari.UndefinedType, optional
+        description : str
+            The description of the subgroup
+        autodefer : bool | AutodeferMode | hikari.UndefinedType
             If True, all commands in this subgroup will automatically defer if it is taking longer than 2 seconds to respond.
             If not provided, then this setting will be inherited from the parent.
-        name_localizations : dict[hikari.Locale, str] | None, optional
-            Localizations for the name of the subgroup, by default None
-        description_localizations : dict[hikari.Locale, str] | None, optional
-            Localizations for the description of the subgroup, by default None
+        name_localizations : dict[hikari.Locale, str] | None
+            Localizations for the name of the subgroup
+        description_localizations : dict[hikari.Locale, str] | None
+            Localizations for the description of the subgroup
         """
         group: SlashSubGroup[ClientT] = SlashSubGroup(
             name=name,
             description=description,
-            autodefer=AutodeferMode(autodefer) if autodefer else hikari.UNDEFINED,
+            autodefer=AutodeferMode(autodefer) if isinstance(autodefer, bool) else autodefer,
             name_localizations=name_localizations or {},
             description_localizations=description_localizations or {},
         )
-        group.parent = self
+        group._parent = self
         self.children[name] = group
         return group
 
@@ -477,19 +459,17 @@ class SlashGroup(CommandBase[ClientT, hikari.api.SlashCommandBuilder]):
 class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
     """A subgroup of a slash command group."""
 
-    children: dict[str, SlashSubCommand[ClientT]] = attr.field(factory=dict)
+    children: dict[str, SlashSubCommand[ClientT]] = attr.field(factory=dict, init=False)
     """Subcommands that belong to this subgroup."""
 
-    autodefer: AutodeferMode | hikari.UndefinedType = hikari.UNDEFINED
+    _autodefer: AutodeferMode | hikari.UndefinedType = attr.field(default=hikari.UNDEFINED, alias="autodefer")
     """If True, this subcommand will automatically defer if it is taking longer than 2 seconds to respond.
     If undefined, then it will be inherited from the parent.
     """
 
-    _plugin: PluginBase[ClientT] | None = attr.field(default=None, init=False)
-
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.SUB_COMMAND_GROUP
+    def option_type(self) -> OptionType:
+        return OptionType.SUB_COMMAND_GROUP
 
     @property
     def command_type(self) -> hikari.CommandType:
@@ -497,23 +477,28 @@ class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
 
     @property
     def qualified_name(self) -> t.Sequence[str]:
-        if self.parent is None:
-            raise ValueError("Cannot get qualified name of subgroup without parent.")
-
         return (self.parent.name, self.name)
 
+    @property
+    def display_name(self) -> str:
+        return "/" + " ".join(self.qualified_name)
+
     @property
     def client(self) -> ClientT:
         """The client that includes this subgroup."""
-        if self.parent is None:
-            raise ValueError("Cannot get client of subgroup without parent.")
-
         return self.parent.client
 
     @property
     def plugin(self) -> PluginBase[ClientT] | None:
         """The plugin that includes this subgroup."""
-        return self._plugin
+        return self.parent.plugin
+
+    @property
+    def autodefer(self) -> AutodeferMode:
+        """The resolved autodefer configuration for this subcommand."""
+        autodefer = self._resolve_settings().autodefer
+        assert autodefer is not hikari.UNDEFINED
+        return autodefer
 
     def _to_dict(self) -> dict[str, t.Any]:
         return {
@@ -521,13 +506,25 @@ class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
             "options": [subcommand.to_command_option() for subcommand in self.children.values()],
         }
 
+    def _resolve_settings(self) -> _CommandSettings:
+        settings = self._parent._resolve_settings() if self._parent else _CommandSettings.default()
+
+        return settings.apply(
+            _CommandSettings(
+                autodefer=self.autodefer,
+                default_permissions=hikari.UNDEFINED,
+                is_nsfw=hikari.UNDEFINED,
+                is_dm_enabled=hikari.UNDEFINED,
+            )
+        )
+
     def _resolve_hooks(self) -> list[HookT[ClientT]]:
-        assert self.parent is not None
-        return self.parent._resolve_hooks() + self._hooks
+        assert self._parent is not None
+        return self._parent._resolve_hooks() + self._hooks
 
     def _resolve_post_hooks(self) -> list[PostHookT[ClientT]]:
-        assert self.parent is not None
-        return self.parent._resolve_post_hooks() + self._post_hooks
+        assert self._parent is not None
+        return self._parent._resolve_post_hooks() + self._post_hooks
 
     async def _handle_exception(self, ctx: Context[ClientT], exc: Exception) -> None:
         try:
@@ -536,8 +533,8 @@ class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
             else:
                 raise exc
         except Exception as e:
-            assert self.parent is not None
-            await self.parent._handle_exception(ctx, e)
+            assert self._parent is not None
+            await self._parent._handle_exception(ctx, e)
 
     def _request_option_locale(self, client: Client[t.Any], command: CommandProto) -> None:
         super()._request_option_locale(client, command)
@@ -559,7 +556,7 @@ class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
         """First-order decorator to add a subcommand to this group."""
 
         def decorator(command: SlashSubCommand[ClientT]) -> SlashSubCommand[ClientT]:
-            command.parent = self
+            command._parent = self
             self.children[command.name] = command
             return command
 
@@ -570,7 +567,9 @@ class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
 
 
 @attr.define(slots=True, kw_only=True)
-class SlashSubCommand(SubCommandBase[ClientT, SlashGroup[ClientT] | SlashSubGroup[ClientT]]):
+class SlashSubCommand(
+    SubCommandBase[ClientT, SlashGroup[ClientT] | SlashSubGroup[ClientT]], CallableCommandProto[ClientT]
+):
     """A subcommand of a slash command group."""
 
     callback: CommandCallbackT[ClientT]
@@ -579,65 +578,48 @@ class SlashSubCommand(SubCommandBase[ClientT, SlashGroup[ClientT] | SlashSubGrou
     options: t.MutableMapping[str, CommandOptionBase[ClientT, t.Any, t.Any]] = attr.field(factory=dict)
     """The options of this subcommand."""
 
-    autodefer: AutodeferMode | hikari.UndefinedType = hikari.UNDEFINED
+    _autodefer: AutodeferMode | hikari.UndefinedType = attr.field(default=hikari.UNDEFINED, alias="autodefer")
     """If True, this subcommand will automatically defer if it is taking longer than 2 seconds to respond.
     If undefined, then it will be inherited from the parent.
     """
 
     _invoke_task: asyncio.Task[t.Any] | None = attr.field(default=None, init=False)
 
-    def _resolve_hooks(self) -> list[HookT[ClientT]]:
-        assert self.parent is not None
-        return self.parent._resolve_hooks() + self._hooks
+    @property
+    def root(self) -> SlashGroup[ClientT]:
+        """The root group of this subcommand."""
+        if self._parent is None:
+            raise ValueError("Cannot get root of subcommand without parent.")
 
-    def _resolve_post_hooks(self) -> list[PostHookT[ClientT]]:
-        assert self.parent is not None
-        return self.parent._resolve_post_hooks() + self._post_hooks
+        if isinstance(self._parent, SlashSubGroup):
+            if self._parent._parent is None:
+                raise ValueError("Cannot get root of subcommand without parent.")
 
-    async def _handle_exception(self, ctx: Context[ClientT], exc: Exception) -> None:
-        try:
-            if self.error_handler:
-                await self.error_handler(ctx, exc)
-            else:
-                raise exc
-        except Exception as e:
-            assert self.parent is not None
-            await self.parent._handle_exception(ctx, e)
+            return self._parent._parent
+
+        return self._parent
 
     @property
     def qualified_name(self) -> t.Sequence[str]:
-        if self.parent is None:
-            raise ValueError("Cannot get qualified name of subcommand without parent.")
-
-        if isinstance(self.parent, SlashSubGroup):
-            if self.parent.parent is None:
-                raise ValueError("Cannot get qualified name of subcommand without parent.")
-
-            return (self.parent.parent.name, self.parent.name, self.name)
+        if isinstance(self._parent, SlashSubGroup):
+            return (self.root.name, self.parent.name, self.name)
 
         return (self.parent.name, self.name)
 
     @property
-    def root(self) -> SlashGroup[ClientT]:
-        """The root group of this subcommand."""
-        if self.parent is None:
-            raise ValueError("Cannot get root of subcommand without parent.")
-
-        if isinstance(self.parent, SlashSubGroup):
-            if self.parent.parent is None:
-                raise ValueError("Cannot get root of subcommand without parent.")
-
-            return self.parent.parent
-
-        return self.parent
+    def parent(self) -> SlashGroup[ClientT] | SlashSubGroup[ClientT]:
+        """The parent of this subcommand."""
+        if self._parent is None:
+            raise ValueError("Cannot get parent of subcommand without parent.")
+        return self._parent
 
     @property
     def command_type(self) -> hikari.CommandType:
         return hikari.CommandType.SLASH
 
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.SUB_COMMAND
+    def option_type(self) -> OptionType:
+        return OptionType.SUB_COMMAND
 
     @property
     def client(self) -> ClientT:
@@ -649,30 +631,67 @@ class SlashSubCommand(SubCommandBase[ClientT, SlashGroup[ClientT] | SlashSubGrou
         """The plugin that includes this subcommand."""
         return self.root.plugin
 
-    def _request_option_locale(self, client: Client[t.Any], command: CommandProto) -> None:
-        super()._request_option_locale(client, command)
+    @property
+    def autodefer(self) -> AutodeferMode:
+        """The resolved autodefer configuration for this subcommand."""
+        autodefer = self._resolve_settings().autodefer
+        assert autodefer is not hikari.UNDEFINED
+        return autodefer
 
-        for option in self.options.values():
-            option._request_option_locale(client, command)
+    @property
+    def display_name(self) -> str:
+        return "/" + " ".join(self.qualified_name)
+
+    def make_mention(self, guild: hikari.Snowflakeish | hikari.PartialGuild | None = None) -> str:
+        """Make a slash mention for this command.
+
+        Returns
+        -------
+        str
+            The slash command mention.
+        """
+        instance = self.root._instances.get(hikari.Snowflake(guild) if guild else None)
 
-    def _resolve_autodefer(self) -> AutodeferMode:
-        """Resolve autodefer for this subcommand."""
-        if self.autodefer is not hikari.UNDEFINED:
-            return self.autodefer
+        if instance is None:
+            raise KeyError(f"Command '{self.display_name}' has not been published in the given scope.")
 
-        if self.parent is None:
-            return AutodeferMode.OFF
+        return f"</{' '.join(self.qualified_name)}:{instance.id}>"
 
-        if isinstance(self.parent, SlashSubGroup):
-            if self.parent.autodefer is not hikari.UNDEFINED:
-                return self.parent.autodefer
+    def _resolve_settings(self) -> _CommandSettings:
+        settings = self._parent._resolve_settings() if self._parent else _CommandSettings.default()
 
-            if self.parent.parent is None:
-                return AutodeferMode.OFF
+        return settings.apply(
+            _CommandSettings(
+                autodefer=self._autodefer,
+                default_permissions=hikari.UNDEFINED,
+                is_nsfw=hikari.UNDEFINED,
+                is_dm_enabled=hikari.UNDEFINED,
+            )
+        )
+
+    def _resolve_hooks(self) -> list[HookT[ClientT]]:
+        assert self._parent is not None
+        return self._parent._resolve_hooks() + self._hooks
+
+    def _resolve_post_hooks(self) -> list[PostHookT[ClientT]]:
+        assert self._parent is not None
+        return self._parent._resolve_post_hooks() + self._post_hooks
+
+    async def _handle_exception(self, ctx: Context[ClientT], exc: Exception) -> None:
+        try:
+            if self.error_handler:
+                await self.error_handler(ctx, exc)
+            else:
+                raise exc
+        except Exception as e:
+            assert self._parent is not None
+            await self._parent._handle_exception(ctx, e)
 
-            return self.parent.parent.autodefer
+    def _request_option_locale(self, client: Client[t.Any], command: CommandProto) -> None:
+        super()._request_option_locale(client, command)
 
-        return self.parent.autodefer
+        for option in self.options.values():
+            option._request_option_locale(client, command)
 
     async def __call__(self, ctx: Context[ClientT], *args: t.Any, **kwargs: t.Any) -> None:
         """Invoke this subcommand with the given context.
@@ -702,13 +721,13 @@ def slash_command(
     name: str,
     description: str = "No description provided.",
     *,
-    guilds: t.Sequence[hikari.SnowflakeishOr[hikari.PartialGuild]] | None = None,
-    is_dm_enabled: bool = True,
-    is_nsfw: bool = False,
-    autodefer: bool | AutodeferMode = True,
-    default_permissions: hikari.UndefinedOr[hikari.Permissions] = hikari.UNDEFINED,
-    name_localizations: dict[hikari.Locale, str] | None = None,
-    description_localizations: dict[hikari.Locale, str] | None = None,
+    guilds: t.Sequence[hikari.PartialGuild | hikari.Snowflakeish] | hikari.UndefinedType = hikari.UNDEFINED,
+    is_dm_enabled: bool | hikari.UndefinedType = hikari.UNDEFINED,
+    is_nsfw: bool | hikari.UndefinedType = hikari.UNDEFINED,
+    autodefer: bool | AutodeferMode | hikari.UndefinedType = hikari.UNDEFINED,
+    default_permissions: hikari.Permissions | hikari.UndefinedType = hikari.UNDEFINED,
+    name_localizations: t.Mapping[hikari.Locale, str] | None = None,
+    description_localizations: t.Mapping[hikari.Locale, str] | None = None,
 ) -> t.Callable[[t.Callable[t.Concatenate[Context[ClientT], ...], t.Awaitable[None]]], SlashCommand[ClientT]]:
     """A decorator that creates a slash command.
 
@@ -716,49 +735,52 @@ def slash_command(
     ----------
     name : str
         The name of the slash command.
-    description : str, optional
-        The description of the command, by default "No description provided."
-    guilds : t.Sequence[hikari.SnowflakeishOr[hikari.PartialGuild]] | None, optional
-        The guilds this command should be enabled in, if left as None, the command is global, by default None
-    is_dm_enabled : bool, optional
-        If True, the command is usable in direct messages, by default True
-    is_nsfw : bool, optional
-        If True, the command is only usable in NSFW channels, by default False
-    autodefer : bool | AutodeferMode, optional
-        If True, this command will be automatically deferred if it takes longer than 2 seconds to respond, by default True
-    default_permissions : hikari.UndefinedOr[hikari.Permissions], optional
-        The default permissions required to use this command, these can be overriden by guild admins, by default hikari.UNDEFINED
-    name_localizations : dict[hikari.Locale, str] | None, optional
-        Localizations for the name of this command, by default None
-    description_localizations : dict[hikari.Locale, str] | None, optional
-        Localizations for the description of this command, by default None
+    description : str
+        The description of the command
+    guilds : t.Sequence[hikari.PartialGuild | hikari.Snowflakeish] | hikari.UndefinedType
+        The guilds this command should be enabled in, if left as undefined, the command is global
+    is_dm_enabled : bool | hikari.UndefinedType
+        If True, the command is usable in direct messages
+    is_nsfw : bool | hikari.UndefinedType
+        If True, the command is only usable in NSFW channels
+    autodefer : bool | AutodeferMode | hikari.UndefinedType
+        If True, this command will be automatically deferred if it takes longer than 2 seconds to respond
+    default_permissions : hikari.Permissions | hikari.UndefinedType
+        The default permissions required to use this command, these can be overriden by guild admins
+    name_localizations : dict[hikari.Locale, str] | None
+        Localizations for the name of this command
+    description_localizations : dict[hikari.Locale, str] | None
+        Localizations for the description of this command
 
     Returns
     -------
     t.Callable[[t.Callable[t.Concatenate[Context[ClientT], ...], t.Awaitable[None]]], SlashCommand[ClientT]]
         The decorated slash command.
 
+    !!! note
+        Parameters left as `hikari.UNDEFINED` will be inherited from the parent plugin or client.
+
     Usage
     -----
     ```py
     @client.include
-    @arc.slash_command(name="hi", description="Say hi!")
+    @arc.slash_command("hi", "Say hi!")
     async def hi_slash(
         ctx: arc.GatewayContext,
-        user: arc.Option[hikari.User, arc.UserParams(description="The user to say hi to.")]
+        user: arc.Option[hikari.User, arc.UserParams("The user to say hi to.")]
     ) -> None:
         await ctx.respond(f"Hey {user.mention}!")
     ```
     """
 
     def decorator(func: t.Callable[t.Concatenate[Context[ClientT], ...], t.Awaitable[None]]) -> SlashCommand[ClientT]:
-        guild_ids = [hikari.Snowflake(guild) for guild in guilds] if guilds else []
+        guild_ids = tuple(hikari.Snowflake(i) for i in guilds) if guilds is not hikari.UNDEFINED else hikari.UNDEFINED
         options = parse_command_signature(func)
 
         return SlashCommand(
             callback=func,
             options=options,
-            autodefer=AutodeferMode(autodefer),
+            autodefer=AutodeferMode(autodefer) if isinstance(autodefer, bool) else autodefer,
             name=name,
             description=description,
             name_localizations=name_localizations or {},
@@ -777,8 +799,8 @@ def slash_subcommand(
     description: str = "No description provided.",
     *,
     autodefer: bool | AutodeferMode | hikari.UndefinedType = hikari.UNDEFINED,
-    name_localizations: dict[hikari.Locale, str] | None = None,
-    description_localizations: dict[hikari.Locale, str] | None = None,
+    name_localizations: t.Mapping[hikari.Locale, str] | None = None,
+    description_localizations: t.Mapping[hikari.Locale, str] | None = None,
 ) -> t.Callable[[t.Callable[t.Concatenate[Context[ClientT], ...], t.Awaitable[None]]], SlashSubCommand[ClientT]]:
     """A decorator that creates a slash sub command. It should be included in a slash command group.
 
@@ -786,21 +808,24 @@ def slash_subcommand(
     ----------
     name : str
         The name of the slash command.
-    description : str, optional
-        The description of the command, by default "No description provided."
-    autodefer : bool | AutodeferMode | hikari.UndefinedType, optional
-        If True, this command will be automatically deferred if it takes longer than 2 seconds to respond, by default True
+    description : str
+        The description of the command
+    autodefer : bool | AutodeferMode | hikari.UndefinedType
+        If True, this command will be automatically deferred if it takes longer than 2 seconds to respond
         If undefined, then this setting will be be inherited from the parent
-    name_localizations : dict[hikari.Locale, str] | None, optional
-        Localizations for the name of this command, by default None
-    description_localizations : dict[hikari.Locale, str] | None, optional
-        Localizations for the description of this command, by default None
+    name_localizations : dict[hikari.Locale, str] | None
+        Localizations for the name of this command
+    description_localizations : dict[hikari.Locale, str] | None
+        Localizations for the description of this command
 
     Returns
     -------
     t.Callable[[t.Callable[t.Concatenate[Context[ClientT], ...], t.Awaitable[None]]], SlashCommand[ClientT]]
         The decorated slash command.
 
+    !!! note
+        Parameters left as `hikari.UNDEFINED` will be inherited from the parent group, plugin or client.
+
     Usage
     -----
     ```py
@@ -825,7 +850,7 @@ def slash_subcommand(
             callback=func,
             options=options,
             name=name,
-            autodefer=AutodeferMode(autodefer) if autodefer else hikari.UNDEFINED,
+            autodefer=AutodeferMode(autodefer) if isinstance(autodefer, bool) else autodefer,
             description=description,
             name_localizations=name_localizations or {},
             description_localizations=description_localizations or {},