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

arc/client.py

@@ -146,7 +146,7 @@ class GatewayClientBase(Client[GatewayBotT]):
             The event type to subscribe to.
 
             `EventT` must be a subclass of `hikari.events.base_events.Event`.
-        callback : t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]
+        callback : t.Callable[EventT], t.Awaitable[None]]
             The callback to call when the event is dispatched.
         """
         self.app.event_manager.subscribe(event_type, callback)  # pyright: ignore reportGeneralTypeIssues
@@ -158,7 +158,7 @@ class GatewayClientBase(Client[GatewayBotT]):
         ----------
         event_type : type[EventT]
             The event type to unsubscribe from.
-        callback : t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]
+        callback : t.Callable[[EventT], t.Awaitable[None]]
             The callback to unsubscribe.
         """
         self.app.event_manager.unsubscribe(event_type, callback)  # pyright: ignore reportGeneralTypeIssues
@@ -178,7 +178,7 @@ class GatewayClientBase(Client[GatewayBotT]):
 
         Returns
         -------
-        t.Callable[t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]], t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]]
+        t.Callable[t.Callable[[EventT], t.Awaitable[None]]], t.Callable[[EventT], t.Awaitable[None]]]
             A decorator for a coroutine function that passes it to
             `EventManager.subscribe` before returning the function
             reference.

arc/command/message.py

@@ -8,12 +8,12 @@ import hikari
 from arc.abc.command import CallableCommandBase
 from arc.context import AutodeferMode, Context
 from arc.errors import CommandInvokeError
-from arc.internal.types import ClientT, MessageContextCallbackT, ResponseBuilderT
+from arc.internal.types import ClientT, MessageCommandCallbackT, ResponseBuilderT
 
 if t.TYPE_CHECKING:
     import asyncio
 
-    from ..abc import CallableCommandProto
+    from arc.abc import CallableCommandProto
 
 __all__ = ("MessageCommand", "message_command")
 
@@ -69,7 +69,7 @@ def message_command(
     autodefer: bool | AutodeferMode | hikari.UndefinedType = hikari.UNDEFINED,
     default_permissions: hikari.Permissions | hikari.UndefinedType = hikari.UNDEFINED,
     name_localizations: t.Mapping[hikari.Locale, str] | None = None,
-) -> t.Callable[[MessageContextCallbackT[ClientT]], MessageCommand[ClientT]]:
+) -> t.Callable[[MessageCommandCallbackT[ClientT]], MessageCommand[ClientT]]:
     """A decorator that creates a context-menu command on a message.
 
     Parameters
@@ -105,7 +105,7 @@ def message_command(
     ```
     """
 
-    def decorator(callback: MessageContextCallbackT[ClientT]) -> MessageCommand[ClientT]:
+    def decorator(callback: MessageCommandCallbackT[ClientT]) -> MessageCommand[ClientT]:
         guild_ids = tuple(hikari.Snowflake(i) for i in guilds) if guilds is not hikari.UNDEFINED else hikari.UNDEFINED
 
         return MessageCommand(

arc/command/option/attachment.py

@@ -5,7 +5,7 @@ import typing as t
 import attr
 import hikari
 
-from arc.abc.option import CommandOptionBase, OptionParams
+from arc.abc.option import CommandOptionBase, OptionParams, OptionType
 from arc.internal.types import ClientT
 
 if t.TYPE_CHECKING:
@@ -46,8 +46,8 @@ class AttachmentOption(CommandOptionBase[hikari.Attachment, ClientT, AttachmentP
     """
 
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.ATTACHMENT
+    def option_type(self) -> OptionType:
+        return OptionType.ATTACHMENT
 
     @classmethod
     def _from_params(cls, *, name: str, is_required: bool, params: AttachmentParams, **kwargs: t.Any) -> te.Self:

arc/command/option/bool.py

@@ -3,9 +3,8 @@ from __future__ import annotations
 import typing as t
 
 import attr
-import hikari
 
-from arc.abc.option import CommandOptionBase, OptionParams
+from arc.abc.option import CommandOptionBase, OptionParams, OptionType
 from arc.internal.types import ClientT
 
 if t.TYPE_CHECKING:
@@ -46,8 +45,8 @@ class BoolOption(CommandOptionBase[bool, ClientT, BoolParams]):
     """
 
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.BOOLEAN
+    def option_type(self) -> OptionType:
+        return OptionType.BOOLEAN
 
     @classmethod
     def _from_params(cls, *, name: str, is_required: bool, params: BoolParams, **kwargs: t.Any) -> te.Self:

arc/command/option/channel.py

@@ -5,7 +5,7 @@ import typing as t
 import attr
 import hikari
 
-from arc.abc.option import CommandOptionBase, OptionParams
+from arc.abc.option import CommandOptionBase, OptionParams, OptionType
 from arc.internal.types import ClientT
 
 if t.TYPE_CHECKING:
@@ -57,8 +57,8 @@ class ChannelOption(CommandOptionBase[hikari.PartialChannel, ClientT, ChannelPar
     """The channel types that the option can be."""
 
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.CHANNEL
+    def option_type(self) -> OptionType:
+        return OptionType.CHANNEL
 
     @classmethod
     def _from_params(cls, *, name: str, is_required: bool, params: ChannelParams, **kwargs: t.Any) -> te.Self:

arc/command/option/float.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 import typing as t
 
 import attr
-import hikari
 
-from arc.abc.option import OptionWithChoices, OptionWithChoicesParams
+from arc.abc.option import OptionType, OptionWithChoices, OptionWithChoicesParams
 from arc.internal.types import ClientT
 
 if t.TYPE_CHECKING:
+    import hikari
     import typing_extensions as te
 
     from ...internal.types import AutocompleteCallbackT
@@ -97,8 +97,8 @@ class FloatOption(OptionWithChoices[float, ClientT, FloatParams[ClientT]]):
     """The maximum value of the option."""
 
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.FLOAT
+    def option_type(self) -> OptionType:
+        return OptionType.FLOAT
 
     @classmethod
     def _from_params(cls, *, name: str, is_required: bool, params: FloatParams[ClientT], **kwargs: t.Any) -> te.Self:

arc/command/option/int.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 import typing as t
 
 import attr
-import hikari
 
-from arc.abc.option import OptionWithChoices, OptionWithChoicesParams
+from arc.abc.option import OptionType, OptionWithChoices, OptionWithChoicesParams
 from arc.internal.types import ClientT
 
 if t.TYPE_CHECKING:
+    import hikari
     import typing_extensions as te
 
     from ...internal.types import AutocompleteCallbackT
@@ -97,8 +97,8 @@ class IntOption(OptionWithChoices[int, ClientT, IntParams[ClientT]]):
     """The maximum value of the option."""
 
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.INTEGER
+    def option_type(self) -> OptionType:
+        return OptionType.INTEGER
 
     @classmethod
     def _from_params(cls, *, name: str, is_required: bool, params: IntParams[ClientT], **kwargs: t.Any) -> te.Self:

arc/command/option/mentionable.py

@@ -5,7 +5,7 @@ import typing as t
 import attr
 import hikari
 
-from arc.abc.option import CommandOptionBase, OptionParams
+from arc.abc.option import CommandOptionBase, OptionParams, OptionType
 from arc.internal.types import ClientT
 
 if t.TYPE_CHECKING:
@@ -47,8 +47,8 @@ class MentionableOption(CommandOptionBase[hikari.Role | hikari.User, ClientT, Me
     """
 
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.MENTIONABLE
+    def option_type(self) -> OptionType:
+        return OptionType.MENTIONABLE
 
     @classmethod
     def _from_params(cls, *, name: str, is_required: bool, params: MentionableParams, **kwargs: t.Any) -> te.Self:

arc/command/option/role.py

@@ -5,7 +5,7 @@ import typing as t
 import attr
 import hikari
 
-from arc.abc.option import CommandOptionBase, OptionParams
+from arc.abc.option import CommandOptionBase, OptionParams, OptionType
 from arc.internal.types import ClientT
 
 if t.TYPE_CHECKING:
@@ -46,8 +46,8 @@ class RoleOption(CommandOptionBase[hikari.Role, ClientT, RoleParams]):
     """
 
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.ROLE
+    def option_type(self) -> OptionType:
+        return OptionType.ROLE
 
     @classmethod
     def _from_params(cls, *, name: str, is_required: bool, params: RoleParams, **kwargs: t.Any) -> te.Self:

arc/command/option/str.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 import typing as t
 
 import attr
-import hikari
 
-from arc.abc.option import OptionWithChoices, OptionWithChoicesParams
+from arc.abc.option import OptionType, OptionWithChoices, OptionWithChoicesParams
 from arc.internal.types import ClientT
 
 if t.TYPE_CHECKING:
+    import hikari
     import typing_extensions as te
 
     from arc.internal.types import AutocompleteCallbackT
@@ -98,8 +98,8 @@ class StrOption(OptionWithChoices[str, ClientT, StrParams[ClientT]]):
     """The maximum length of the option."""
 
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.STRING
+    def option_type(self) -> OptionType:
+        return OptionType.STRING
 
     @classmethod
     def _from_params(cls, *, name: str, is_required: bool, params: StrParams[ClientT], **kwargs: t.Any) -> te.Self:

arc/command/option/user.py

@@ -5,7 +5,7 @@ import typing as t
 import attr
 import hikari
 
-from arc.abc.option import CommandOptionBase, OptionParams
+from arc.abc.option import CommandOptionBase, OptionParams, OptionType
 from arc.internal.types import ClientT
 
 if t.TYPE_CHECKING:
@@ -47,8 +47,8 @@ class UserOption(CommandOptionBase[hikari.User, ClientT, UserParams]):
     """
 
     @property
-    def option_type(self) -> hikari.OptionType:
-        return hikari.OptionType.USER
+    def option_type(self) -> OptionType:
+        return OptionType.USER
 
     @classmethod
     def _from_params(cls, *, name: str, is_required: bool, params: UserParams, **kwargs: t.Any) -> te.Self:

arc/command/slash.py

@@ -7,9 +7,10 @@ import attr
 import hikari
 
 from arc.abc.command import CallableCommandBase, CallableCommandProto, CommandBase, SubCommandBase, _CommandSettings
-from arc.abc.option import OptionWithChoices
+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
@@ -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:
@@ -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,11 +263,13 @@ 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.autodefer) and autodefer.should_autodefer:
             ctx._start_autodefer(autodefer)
@@ -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
@@ -486,8 +468,8 @@ class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
     """
 
     @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,6 +479,10 @@ class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
     def qualified_name(self) -> t.Sequence[str]:
         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."""
@@ -599,49 +585,6 @@ class SlashSubCommand(
 
     _invoke_task: asyncio.Task[t.Any] | None = attr.field(default=None, init=False)
 
-    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
-
-    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)
-
-    @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)
-
-        return (self._parent.name, self.name)
-
     @property
     def root(self) -> SlashGroup[ClientT]:
         """The root group of this subcommand."""
@@ -656,18 +599,27 @@ class SlashSubCommand(
 
         return self._parent
 
+    @property
+    def qualified_name(self) -> t.Sequence[str]:
+        if isinstance(self._parent, SlashSubGroup):
+            return (self.root.name, self.parent.name, self.name)
+
+        return (self.parent.name, self.name)
+
     @property
     def parent(self) -> SlashGroup[ClientT] | SlashSubGroup[ClientT]:
         """The parent of this subcommand."""
-        return self.parent
+        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:
@@ -686,6 +638,55 @@ class SlashSubCommand(
         assert autodefer is not hikari.UNDEFINED
         return autodefer
 
+    @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)
+
+        if instance is None:
+            raise KeyError(f"Command '{self.display_name}' has not been published in the given scope.")
+
+        return f"</{' '.join(self.qualified_name)}:{instance.id}>"
+
+    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
+
+    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)
+
     def _request_option_locale(self, client: Client[t.Any], command: CommandProto) -> None:
         super()._request_option_locale(client, command)
 

arc/command/user.py

@@ -14,7 +14,7 @@ if t.TYPE_CHECKING:
     import asyncio
 
     from arc.abc.command import CallableCommandProto
-    from arc.internal.types import UserContextCallbackT
+    from arc.internal.types import UserCommandCallbackT
 
 __all__ = ("UserCommand", "user_command")
 
@@ -72,7 +72,7 @@ def user_command(
     autodefer: bool | AutodeferMode | hikari.UndefinedType = hikari.UNDEFINED,
     default_permissions: hikari.Permissions | hikari.UndefinedType = hikari.UNDEFINED,
     name_localizations: t.Mapping[hikari.Locale, str] | None = None,
-) -> t.Callable[[UserContextCallbackT[ClientT]], UserCommand[ClientT]]:
+) -> t.Callable[[UserCommandCallbackT[ClientT]], UserCommand[ClientT]]:
     """A decorator that creates a context-menu command on a user.
 
     Parameters
@@ -106,7 +106,7 @@ def user_command(
     ```
     """
 
-    def decorator(callback: UserContextCallbackT[ClientT]) -> UserCommand[ClientT]:
+    def decorator(callback: UserCommandCallbackT[ClientT]) -> UserCommand[ClientT]:
         guild_ids = tuple(hikari.Snowflake(i) for i in guilds) if guilds is not hikari.UNDEFINED else hikari.UNDEFINED
 
         return UserCommand(