hikari-arc 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

arc/abc/command.py

@@ -361,7 +361,7 @@ class CommandBase(
     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:
@@ -402,12 +402,12 @@ class CommandBase(
         return None
 
     def _resolve_hooks(self) -> list[HookT[ClientT]]:
-        plugin_hooks = self.plugin._resolve_hooks() if self.plugin else []
-        return self.client._hooks + plugin_hooks + self._hooks
+        upstream_hooks = self.plugin._resolve_hooks() if self.plugin else self.client._hooks
+        return upstream_hooks + self._hooks
 
     def _resolve_post_hooks(self) -> list[PostHookT[ClientT]]:
-        plugin_hooks = self.plugin._resolve_post_hooks() if self.plugin else []
-        return self.client._post_hooks + plugin_hooks + self._post_hooks
+        upstream_hooks = self.plugin._resolve_post_hooks() if self.plugin else self.client._post_hooks
+        return upstream_hooks + self._post_hooks
 
     async def publish(self, guild: hikari.SnowflakeishOr[hikari.PartialGuild] | None = None) -> hikari.PartialCommand:
         """Publish this command to the given guild, or globally if no guild is provided.
@@ -549,10 +549,10 @@ class CommandBase(
         try:
             hooks = command._resolve_hooks()
             for hook in hooks:
-                res = hook(ctx)
-
-                if inspect.isawaitable(res):
-                    res = await res
+                if inspect.iscoroutinefunction(hook):
+                    res = await ctx._injection_ctx.call_with_async_di(hook, ctx)
+                else:
+                    res = ctx._injection_ctx.call_with_di(hook, ctx)
 
                 res = t.cast(HookResult | None, res)
 
@@ -570,9 +570,9 @@ class CommandBase(
             post_hooks = command._resolve_post_hooks()
             for hook in post_hooks:
                 if inspect.iscoroutinefunction(hook):
-                    await hook(ctx)
+                    await ctx._injection_ctx.call_with_async_di(hook, ctx)
                 else:
-                    hook(ctx)
+                    ctx._injection_ctx.call_with_di(hook, ctx)
         except Exception as e:
             await command._handle_exception(ctx, e)
         finally:
@@ -585,6 +585,9 @@ class CommandBase(
         """Handle the callback of a command. Invoke all hooks and the callback, and handle any exceptions."""
         # If hook aborted, stop invocation
 
+        injection_ctx = await self.client._create_overriding_ctx_for_command(ctx)
+        ctx._injection_ctx = injection_ctx
+
         max_concurrency = command._resolve_concurrency_limiter()
 
         if max_concurrency is not None and max_concurrency.is_exhausted(ctx):
@@ -599,7 +602,7 @@ class CommandBase(
             if await self._handle_pre_hooks(command, ctx):
                 return
 
-            await self.client.injector.call_with_async_di(command.callback, ctx, *args, **kwargs)
+            await injection_ctx.call_with_async_di(command.callback, ctx, *args, **kwargs)
 
         except Exception as e:
             ctx._has_command_failed = True

arc/abc/error_handler.py

@@ -27,12 +27,10 @@ class HasErrorHandler(abc.ABC, t.Generic[ClientT]):
     @t.overload
     def set_error_handler(
         self, callback: None = ...
-    ) -> t.Callable[[ErrorHandlerCallbackT[ClientT]], ErrorHandlerCallbackT[ClientT]]:
-        ...
+    ) -> t.Callable[[ErrorHandlerCallbackT[ClientT]], ErrorHandlerCallbackT[ClientT]]: ...
 
     @t.overload
-    def set_error_handler(self, callback: ErrorHandlerCallbackT[ClientT]) -> ErrorHandlerCallbackT[ClientT]:
-        ...
+    def set_error_handler(self, callback: ErrorHandlerCallbackT[ClientT]) -> ErrorHandlerCallbackT[ClientT]: ...
 
     def set_error_handler(
         self, callback: ErrorHandlerCallbackT[ClientT] | None = None

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

@@ -8,7 +8,7 @@ import typing as t
 
 import hikari
 
-from arc.abc.command import _CommandSettings
+from arc.abc.command import CallableCommandBase, _CommandSettings
 from arc.abc.concurrency_limiting import ConcurrencyLimiterProto, HasConcurrencyLimiter
 from arc.abc.error_handler import HasErrorHandler
 from arc.abc.hookable import Hookable
@@ -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,16 +209,19 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT], HasConcurrencyLimi
             raise TypeError(f"Unknown command type '{type(command).__name__}'.")
 
     @t.overload
-    def include(self) -> t.Callable[[CommandBase[ClientT, BuilderT]], CommandBase[ClientT, BuilderT]]:
-        ...
+    def include(
+        self,
+    ) -> t.Callable[[CallableCommandBase[ClientT, BuilderT]], CallableCommandBase[ClientT, BuilderT]]: ...
 
     @t.overload
-    def include(self, command: CommandBase[ClientT, BuilderT]) -> CommandBase[ClientT, BuilderT]:
-        ...
+    def include(self, command: CallableCommandBase[ClientT, BuilderT]) -> CallableCommandBase[ClientT, BuilderT]: ...
 
     def include(
-        self, command: CommandBase[ClientT, BuilderT] | None = None
-    ) -> CommandBase[ClientT, BuilderT] | t.Callable[[CommandBase[ClientT, BuilderT]], CommandBase[ClientT, BuilderT]]:
+        self, command: CallableCommandBase[ClientT, BuilderT] | None = None
+    ) -> (
+        CallableCommandBase[ClientT, BuilderT]
+        | t.Callable[[CallableCommandBase[ClientT, BuilderT]], CallableCommandBase[ClientT, BuilderT]]
+    ):
         """Add a command to this plugin.
 
         !!! note
@@ -235,7 +238,7 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT], HasConcurrencyLimi
             If the command is already included in this plugin.
         """
 
-        def decorator(command: CommandBase[ClientT, BuilderT]) -> CommandBase[ClientT, BuilderT]:
+        def decorator(command: CallableCommandBase[ClientT, BuilderT]) -> CallableCommandBase[ClientT, BuilderT]:
             if command.plugin is not None:
                 raise ValueError(f"Command '{command.name}' is already registered with plugin '{command.plugin.name}'.")
 
@@ -320,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
@@ -401,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,