hikari-arc 1.2.1__py3-none-any.whl → 1.3.1__py3-none-any.whl

arc/abc/option.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import abc
 import enum
 import typing as t
-from typing import Any
 
 import attr
 import hikari
@@ -24,10 +23,12 @@ __all__ = (
     "OptionWithChoicesParams",
     "OptionBase",
     "CommandOptionBase",
+    "ConverterOption",
     "OptionType",
 )
 
 T = t.TypeVar("T")
+OriginT = t.TypeVar("OriginT")
 
 Option = t.Annotated
 """Alias for typing.Annotated.
@@ -49,8 +50,9 @@ arc.Option[int, arc.IntParams(...)]
 class OptionType(enum.IntEnum):
     """The type of a command option.
 
-    This is practically identical to `hikari.OptionType` at the moment.
-    It may however be used in the future to define custom option types.
+    This includes all hikari option types along with some custom ones.
+
+    Custom arc-specific options start with 10k.
     """
 
     SUB_COMMAND = 1
@@ -92,6 +94,14 @@ class OptionType(enum.IntEnum):
     ATTACHMENT = 11
     """Denotes a command option where the value will be an attachment."""
 
+    # Custom optiontypes are 10k+
+
+    MEMBER = 10001
+    """Denotes a command option where the value will be resolved to a member."""
+
+    COLOR = 10002
+    """Denotes a command option where the value will be a color."""
+
     @classmethod
     def from_hikari(cls, option_type: hikari.OptionType) -> OptionType:
         """Convert a hikari.OptionType to an OptionType."""
@@ -99,10 +109,13 @@ class OptionType(enum.IntEnum):
 
     def to_hikari(self) -> hikari.OptionType:
         """Convert an OptionType to a hikari.OptionType."""
-        # TODO: Map custom option types to their respective hikari.OptionType
-        return hikari.OptionType(self.value)
+        if self.value < 10000:
+            return hikari.OptionType(self.value)
 
-    # TODO: When adding custom convertible option types, add them with an offset of 1000 or so
+        if self is OptionType.MEMBER:
+            return hikari.OptionType.USER
+        else:
+            return hikari.OptionType.STRING
 
 
 class OptionParams(t.Generic[T]):
@@ -273,15 +286,22 @@ class CommandOptionBase(OptionBase[T], t.Generic[T, ClientT, ParamsT]):
     is_required: bool = True
     """Whether the option is required."""
 
+    arg_name: str
+    """The name of the parameter this option represents.
+    This is going to be the same as `name` unless `name` was overriden.
+    """
+
     @classmethod
     @abc.abstractmethod
-    def _from_params(cls, *, name: str, is_required: bool, params: ParamsT, **kwargs: t.Any) -> te.Self:
+    def _from_params(cls, *, name: str, arg_name: str, is_required: bool, params: ParamsT, **kwargs: t.Any) -> te.Self:
         """Construct a new Option instance from the given parameters object.
 
         Parameters
         ----------
         name : str
             The name of the option
+        arg_name : str
+            The name of the parameter this option represents
         is_required : bool
             Whether the option is required
         params : ParamsT
@@ -290,10 +310,19 @@ class CommandOptionBase(OptionBase[T], t.Generic[T, ClientT, ParamsT]):
             Any additional keyword arguments to pass to the constructor
         """
 
-    def _to_dict(self) -> dict[str, Any]:
+    def _to_dict(self) -> dict[str, t.Any]:
         return {**super()._to_dict(), "is_required": self.is_required}
 
 
+@attr.define(slots=True, kw_only=True)
+class ConverterOption(CommandOptionBase[T, ClientT, ParamsT], t.Generic[T, ClientT, ParamsT, OriginT]):
+    """An option with a built-in converter."""
+
+    @abc.abstractmethod
+    def _convert_value(self, value: OriginT) -> T:
+        """Convert the value to the desired type."""
+
+
 @attr.define(slots=True, kw_only=True)
 class OptionWithChoices(CommandOptionBase[ChoiceT, ClientT, ParamsT]):
     """An option that can have choices or be autocompleted."""

arc/abc/plugin.py

@@ -155,7 +155,7 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT], HasConcurrencyLimi
     async def _handle_exception(self, ctx: Context[ClientT], exc: Exception) -> None:
         try:
             if self.error_handler is not None:
-                await self.error_handler(ctx, exc)
+                await ctx._injection_ctx.call_with_async_di(self.error_handler, ctx, exc)
             else:
                 raise exc
         except Exception as exc:
@@ -209,12 +209,12 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT], HasConcurrencyLimi
             raise TypeError(f"Unknown command type '{type(command).__name__}'.")
 
     @t.overload
-    def include(self) -> t.Callable[[CallableCommandBase[ClientT, BuilderT]], CallableCommandBase[ClientT, BuilderT]]:
-        ...
+    def include(
+        self,
+    ) -> t.Callable[[CallableCommandBase[ClientT, BuilderT]], CallableCommandBase[ClientT, BuilderT]]: ...
 
     @t.overload
-    def include(self, command: CallableCommandBase[ClientT, BuilderT]) -> CallableCommandBase[ClientT, BuilderT]:
-        ...
+    def include(self, command: CallableCommandBase[ClientT, BuilderT]) -> CallableCommandBase[ClientT, BuilderT]: ...
 
     def include(
         self, command: CallableCommandBase[ClientT, BuilderT] | None = None
@@ -323,12 +323,10 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT], HasConcurrencyLimi
         return group
 
     @t.overload
-    def inject_dependencies(self, func: t.Callable[P, T]) -> t.Callable[P, T]:
-        ...
+    def inject_dependencies(self, func: t.Callable[P, T]) -> t.Callable[P, T]: ...
 
     @t.overload
-    def inject_dependencies(self) -> t.Callable[[t.Callable[P, T]], t.Callable[P, T]]:
-        ...
+    def inject_dependencies(self) -> t.Callable[[t.Callable[P, T]], t.Callable[P, T]]: ...
 
     def inject_dependencies(
         self, func: t.Callable[P, T] | None = None
@@ -404,26 +402,24 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT], HasConcurrencyLimi
     @t.overload
     def walk_commands(
         self, command_type: t.Literal[hikari.CommandType.USER], *, callable_only: bool = False
-    ) -> t.Iterator[UserCommand[ClientT]]:
-        ...
+    ) -> t.Iterator[UserCommand[ClientT]]: ...
 
     @t.overload
     def walk_commands(
         self, command_type: t.Literal[hikari.CommandType.MESSAGE], *, callable_only: bool = False
-    ) -> t.Iterator[MessageCommand[ClientT]]:
-        ...
+    ) -> t.Iterator[MessageCommand[ClientT]]: ...
 
     @t.overload
     def walk_commands(
         self, command_type: t.Literal[hikari.CommandType.SLASH], *, callable_only: t.Literal[False]
-    ) -> t.Iterator[SlashCommand[ClientT] | SlashSubCommand[ClientT] | SlashGroup[ClientT] | SlashSubGroup[ClientT]]:
-        ...
+    ) -> t.Iterator[
+        SlashCommand[ClientT] | SlashSubCommand[ClientT] | SlashGroup[ClientT] | SlashSubGroup[ClientT]
+    ]: ...
 
     @t.overload
     def walk_commands(
         self, command_type: t.Literal[hikari.CommandType.SLASH], *, callable_only: t.Literal[True]
-    ) -> t.Iterator[SlashCommand[ClientT] | SlashSubCommand[ClientT]]:
-        ...
+    ) -> t.Iterator[SlashCommand[ClientT] | SlashSubCommand[ClientT]]: ...
 
     def walk_commands(  # noqa: C901
         self, command_type: hikari.CommandType, *, callable_only: bool = False

arc/client.py

@@ -18,8 +18,7 @@ if t.TYPE_CHECKING:
     import typing_extensions as te
 
     from arc import AutodeferMode
-
-    from .internal.types import EventCallbackT, EventT, ResponseBuilderT
+    from arc.internal.types import EventCallbackT, EventT, ResponseBuilderT
 
 __all__ = (
     "GatewayClientBase",

arc/command/__init__.py

@@ -6,10 +6,16 @@ from .option import (
     BoolParams,
     ChannelOption,
     ChannelParams,
+    ColorOption,
+    ColorParams,
+    ColourOption,
+    ColourParams,
     FloatOption,
     FloatParams,
     IntOption,
     IntParams,
+    MemberOption,
+    MemberParams,
     MentionableOption,
     MentionableParams,
     RoleOption,
@@ -56,6 +62,12 @@ __all__ = (
     "MentionableParams",
     "AttachmentOption",
     "AttachmentParams",
+    "MemberOption",
+    "MemberParams",
+    "ColorOption",
+    "ColorParams",
+    "ColourOption",
+    "ColourParams",
     "UserCommand",
     "user_command",
     "MessageCommand",

arc/command/option/__init__.py

@@ -1,6 +1,7 @@
 from .attachment import AttachmentOption, AttachmentParams
 from .bool import BoolOption, BoolParams
 from .channel import ChannelOption, ChannelParams
+from .custom import ColorOption, ColorParams, ColourOption, ColourParams, MemberOption, MemberParams
 from .float import FloatOption, FloatParams
 from .int import IntOption, IntParams
 from .mentionable import MentionableOption, MentionableParams
@@ -27,6 +28,12 @@ __all__ = (
     "MentionableParams",
     "AttachmentOption",
     "AttachmentParams",
+    "MemberOption",
+    "MemberParams",
+    "ColorOption",
+    "ColorParams",
+    "ColourOption",
+    "ColourParams",
 )
 
 # MIT License

arc/command/option/attachment.py

@@ -52,9 +52,12 @@ class AttachmentOption(CommandOptionBase[hikari.Attachment, ClientT, AttachmentP
         return OptionType.ATTACHMENT
 
     @classmethod
-    def _from_params(cls, *, name: str, is_required: bool, params: AttachmentParams, **kwargs: t.Any) -> te.Self:
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: AttachmentParams, **kwargs: t.Any
+    ) -> te.Self:
         return cls(
             name=name,
+            arg_name=arg_name,
             description=params.description,
             is_required=is_required,
             name_localizations=params.name_localizations,

arc/command/option/bool.py

@@ -51,9 +51,12 @@ class BoolOption(CommandOptionBase[bool, ClientT, BoolParams]):
         return OptionType.BOOLEAN
 
     @classmethod
-    def _from_params(cls, *, name: str, is_required: bool, params: BoolParams, **kwargs: t.Any) -> te.Self:
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: BoolParams, **kwargs: t.Any
+    ) -> te.Self:
         return cls(
             name=name,
+            arg_name=arg_name,
             description=params.description,
             is_required=is_required,
             name_localizations=params.name_localizations,

arc/command/option/channel.py

@@ -63,10 +63,13 @@ class ChannelOption(CommandOptionBase[hikari.PartialChannel, ClientT, ChannelPar
         return OptionType.CHANNEL
 
     @classmethod
-    def _from_params(cls, *, name: str, is_required: bool, params: ChannelParams, **kwargs: t.Any) -> te.Self:
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: ChannelParams, **kwargs: t.Any
+    ) -> te.Self:
         channel_types = kwargs.pop("channel_types")
         return cls(
             name=name,
+            arg_name=arg_name,
             description=params.description,
             is_required=is_required,
             name_localizations=params.name_localizations,

arc/command/option/custom/__init__.py

@@ -0,0 +1,4 @@
+from .color import ColorOption, ColorParams, ColourOption, ColourParams
+from .member import MemberOption, MemberParams
+
+__all__ = ("ColorOption", "ColorParams", "ColourOption", "ColourParams", "MemberOption", "MemberParams")

arc/command/option/custom/color.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import typing as t
+
+import attr
+import hikari
+
+from arc.abc.option import ConverterOption, OptionParams, OptionType
+from arc.errors import OptionConverterFailureError
+from arc.internal.types import ClientT
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+
+__all__ = ("ColorOption", "ColorParams", "ColourOption", "ColourParams")
+
+
+@t.final
+class ColorParams(OptionParams[hikari.Color]):
+    """The parameters for a color option.
+
+    Parameters
+    ----------
+    description : str
+        The description of the option
+
+    Other Parameters
+    ----------------
+    name : str
+        The name of the option. If not provided, the name of the parameter will be used.
+    name_localizations : Mapping[hikari.Locale, str] | None
+        The name of the option in different locales
+    description_localizations : Mapping[hikari.Locale, str] | None
+        The description of the option in different locales
+    """
+
+    __slots__ = ()
+
+
+@attr.define(slots=True, kw_only=True)
+class ColorOption(ConverterOption[hikari.Color, ClientT, ColorParams, str]):
+    """A slash command option that represents a color.
+
+    ??? hint
+        To add an option of this type to your command, add an argument to your command function with the following type hint:
+        ```py
+        opt_name: arc.Option[hikari.Color, ColorParams(...)]
+        ```
+    """
+
+    @property
+    def option_type(self) -> OptionType:
+        return OptionType.COLOR
+
+    def _convert_value(self, value: str) -> hikari.Color:
+        try:
+            return hikari.Color.of(value)
+        except ValueError as exc:
+            raise OptionConverterFailureError(
+                self, value, f"Option '{self.name}' expected a valid color, got {value!r}."
+            ) from exc
+
+    @classmethod
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: ColorParams, **kwargs: t.Any
+    ) -> te.Self:
+        return cls(
+            name=name,
+            arg_name=arg_name,
+            description=params.description,
+            is_required=is_required,
+            name_localizations=params.name_localizations,
+            description_localizations=params.description_localizations,
+            **kwargs,
+        )
+
+
+# God save the queen
+ColourParams = ColorParams
+"""An alias for `ColorParams`."""
+
+ColourOption = ColorOption
+"""An alias for `ColorOption`."""
+
+# MIT License
+#
+# Copyright (c) 2023-present hypergonial
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.

arc/command/option/custom/member.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import typing as t
+
+import attr
+import hikari
+
+from arc.abc.option import ConverterOption, OptionParams, OptionType
+from arc.errors import OptionConverterFailureError
+from arc.internal.types import ClientT
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+
+__all__ = ("MemberOption", "MemberParams")
+
+
+@t.final
+class MemberParams(OptionParams[hikari.InteractionMember]):
+    """The parameters for a member option.
+
+    Parameters
+    ----------
+    description : str
+        The description of the option
+
+    Other Parameters
+    ----------------
+    name : str
+        The name of the option. If not provided, the name of the parameter will be used.
+    name_localizations : Mapping[hikari.Locale, str] | None
+        The name of the option in different locales
+    description_localizations : Mapping[hikari.Locale, str] | None
+        The description of the option in different locales
+    """
+
+    __slots__ = ()
+
+
+@attr.define(slots=True, kw_only=True)
+class MemberOption(ConverterOption[hikari.InteractionMember, ClientT, MemberParams, hikari.User]):
+    """A slash command option that represents a member.
+
+    ??? hint
+        To add an option of this type to your command, add an argument to your command function with the following type hint:
+        ```py
+        opt_name: arc.Option[hikari.Member, MemberParams(...)]
+        ```
+    """
+
+    @property
+    def option_type(self) -> OptionType:
+        return OptionType.MEMBER
+
+    def _convert_value(self, value: hikari.User) -> hikari.InteractionMember:
+        if isinstance(value, hikari.InteractionMember):
+            return value
+        raise OptionConverterFailureError(
+            self, value, f"Option '{self.name}' expected an InteractionMember, got {value!r}."
+        )
+
+    @classmethod
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: MemberParams, **kwargs: t.Any
+    ) -> te.Self:
+        return cls(
+            name=name,
+            arg_name=arg_name,
+            description=params.description,
+            is_required=is_required,
+            name_localizations=params.name_localizations,
+            description_localizations=params.description_localizations,
+            **kwargs,
+        )
+
+
+# MIT License
+#
+# Copyright (c) 2023-present hypergonial
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.

arc/command/option/float.py

@@ -103,9 +103,12 @@ class FloatOption(OptionWithChoices[float, ClientT, FloatParams[ClientT]]):
         return OptionType.FLOAT
 
     @classmethod
-    def _from_params(cls, *, name: str, is_required: bool, params: FloatParams[ClientT], **kwargs: t.Any) -> te.Self:
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: FloatParams[ClientT], **kwargs: t.Any
+    ) -> te.Self:
         return cls(
             name=name,
+            arg_name=arg_name,
             description=params.description,
             is_required=is_required,
             min=params.min,

arc/command/option/int.py

@@ -103,9 +103,12 @@ class IntOption(OptionWithChoices[int, ClientT, IntParams[ClientT]]):
         return OptionType.INTEGER
 
     @classmethod
-    def _from_params(cls, *, name: str, is_required: bool, params: IntParams[ClientT], **kwargs: t.Any) -> te.Self:
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: IntParams[ClientT], **kwargs: t.Any
+    ) -> te.Self:
         return cls(
             name=name,
+            arg_name=arg_name,
             description=params.description,
             is_required=is_required,
             min=params.min,

arc/command/option/mentionable.py

@@ -53,9 +53,12 @@ class MentionableOption(CommandOptionBase[hikari.Role | hikari.User, ClientT, Me
         return OptionType.MENTIONABLE
 
     @classmethod
-    def _from_params(cls, *, name: str, is_required: bool, params: MentionableParams, **kwargs: t.Any) -> te.Self:
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: MentionableParams, **kwargs: t.Any
+    ) -> te.Self:
         return cls(
             name=name,
+            arg_name=arg_name,
             description=params.description,
             is_required=is_required,
             name_localizations=params.name_localizations,

arc/command/option/role.py

@@ -52,9 +52,12 @@ class RoleOption(CommandOptionBase[hikari.Role, ClientT, RoleParams]):
         return OptionType.ROLE
 
     @classmethod
-    def _from_params(cls, *, name: str, is_required: bool, params: RoleParams, **kwargs: t.Any) -> te.Self:
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: RoleParams, **kwargs: t.Any
+    ) -> te.Self:
         return cls(
             name=name,
+            arg_name=arg_name,
             description=params.description,
             is_required=is_required,
             name_localizations=params.name_localizations,

arc/command/option/str.py

@@ -104,9 +104,12 @@ class StrOption(OptionWithChoices[str, ClientT, StrParams[ClientT]]):
         return OptionType.STRING
 
     @classmethod
-    def _from_params(cls, *, name: str, is_required: bool, params: StrParams[ClientT], **kwargs: t.Any) -> te.Self:
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: StrParams[ClientT], **kwargs: t.Any
+    ) -> te.Self:
         return cls(
             name=name,
+            arg_name=arg_name,
             description=params.description,
             is_required=is_required,
             min_length=params.min_length,

arc/command/option/user.py

@@ -53,9 +53,12 @@ class UserOption(CommandOptionBase[hikari.User, ClientT, UserParams]):
         return OptionType.USER
 
     @classmethod
-    def _from_params(cls, *, name: str, is_required: bool, params: UserParams, **kwargs: t.Any) -> te.Self:
+    def _from_params(
+        cls, *, name: str, arg_name: str, is_required: bool, params: UserParams, **kwargs: t.Any
+    ) -> te.Self:
         return cls(
             name=name,
+            arg_name=arg_name,
             description=params.description,
             is_required=is_required,
             name_localizations=params.name_localizations,

arc/command/slash.py

@@ -36,9 +36,12 @@ __all__ = (
 
 
 def _choices_to_builders(
-    choices: t.Sequence[hikari.api.AutocompleteChoiceBuilder] | t.Sequence[t.Any],
+    choices: t.Sequence[hikari.api.AutocompleteChoiceBuilder] | t.Sequence[t.Any] | t.Mapping[str, t.Any],
 ) -> t.Sequence[hikari.api.AutocompleteChoiceBuilder]:
     """Convert a sequence of choices to a sequence of choice builders."""
+    if isinstance(choices, t.Mapping):
+        return [hikari.impl.AutocompleteChoiceBuilder(str(k), v) for k, v in choices.items()]
+
     return [
         (
             hikari.impl.AutocompleteChoiceBuilder(str(e), e)
@@ -403,12 +406,10 @@ class SlashGroup(CommandBase[ClientT, hikari.api.SlashCommandBuilder]):
             sub._request_option_locale(self._client, self)
 
     @t.overload
-    def include(self) -> t.Callable[[SlashSubCommand[ClientT]], SlashSubCommand[ClientT]]:
-        ...
+    def include(self) -> t.Callable[[SlashSubCommand[ClientT]], SlashSubCommand[ClientT]]: ...
 
     @t.overload
-    def include(self, command: SlashSubCommand[ClientT]) -> SlashSubCommand[ClientT]:
-        ...
+    def include(self, command: SlashSubCommand[ClientT]) -> SlashSubCommand[ClientT]: ...
 
     def include(
         self, command: SlashSubCommand[ClientT] | None = None
@@ -540,12 +541,12 @@ class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
     async def _handle_exception(self, ctx: Context[ClientT], exc: Exception) -> None:
         try:
             if self.error_handler:
-                await self.error_handler(ctx, exc)
+                await ctx._injection_ctx.call_with_async_di(self.error_handler, ctx, exc)
             else:
                 raise exc
-        except Exception as e:
+        except Exception as exc:
             assert self._parent is not None
-            await self._parent._handle_exception(ctx, e)
+            await ctx._injection_ctx.call_with_async_di(self._parent._handle_exception, ctx, exc)
 
     def _request_option_locale(self, client: Client[t.Any], command: CommandProto) -> None:
         super()._request_option_locale(client, command)
@@ -554,12 +555,10 @@ class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
             subcommand._request_option_locale(client, command)
 
     @t.overload
-    def include(self) -> t.Callable[[SlashSubCommand[ClientT]], SlashSubCommand[ClientT]]:
-        ...
+    def include(self) -> t.Callable[[SlashSubCommand[ClientT]], SlashSubCommand[ClientT]]: ...
 
     @t.overload
-    def include(self, command: SlashSubCommand[ClientT]) -> SlashSubCommand[ClientT]:
-        ...
+    def include(self, command: SlashSubCommand[ClientT]) -> SlashSubCommand[ClientT]: ...
 
     def include(
         self, command: SlashSubCommand[ClientT] | None = None
@@ -700,7 +699,7 @@ class SlashSubCommand(
                 raise exc
         except Exception as e:
             assert self._parent is not None
-            await self._parent._handle_exception(ctx, e)
+            await self._handle_exception(ctx, e)
 
     def _request_option_locale(self, client: Client[t.Any], command: CommandProto) -> None:
         super()._request_option_locale(client, command)