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

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
@@ -518,7 +519,7 @@ class SlashSubGroup(SubCommandBase[ClientT, SlashGroup[ClientT]]):
 
         return settings.apply(
             _CommandSettings(
-                autodefer=self.autodefer,
+                autodefer=self._autodefer,
                 default_permissions=hikari.UNDEFINED,
                 is_nsfw=hikari.UNDEFINED,
                 is_dm_enabled=hikari.UNDEFINED,
@@ -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)
@@ -746,7 +745,7 @@ def slash_command(
     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]]:
+) -> t.Callable[[CommandCallbackT[ClientT]], SlashCommand[ClientT]]:
     """A decorator that creates a slash command.
 
     Parameters
@@ -791,7 +790,7 @@ def slash_command(
     ```
     """
 
-    def decorator(func: t.Callable[t.Concatenate[Context[ClientT], ...], t.Awaitable[None]]) -> SlashCommand[ClientT]:
+    def decorator(func: CommandCallbackT[ClientT]) -> SlashCommand[ClientT]:
         guild_ids = tuple(hikari.Snowflake(i) for i in guilds) if guilds is not hikari.UNDEFINED else hikari.UNDEFINED
         options = parse_command_signature(func)
 
@@ -819,7 +818,7 @@ def slash_subcommand(
     autodefer: bool | AutodeferMode | 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]]], SlashSubCommand[ClientT]]:
+) -> t.Callable[[CommandCallbackT[ClientT]], SlashSubCommand[ClientT]]:
     """A decorator that creates a slash sub command. It should be included in a slash command group.
 
     Parameters
@@ -859,9 +858,7 @@ def slash_subcommand(
     ```
     """
 
-    def decorator(
-        func: t.Callable[t.Concatenate[Context[ClientT], ...], t.Awaitable[None]],
-    ) -> SlashSubCommand[ClientT]:
+    def decorator(func: CommandCallbackT[ClientT]) -> SlashSubCommand[ClientT]:
         options = parse_command_signature(func)
 
         return SlashSubCommand(

arc/context/base.py

@@ -7,6 +7,7 @@ import logging
 import typing as t
 from contextlib import suppress
 
+import alluka
 import attr
 import hikari
 
@@ -23,6 +24,9 @@ __all__ = ("Context", "InteractionResponse", "AutodeferMode")
 
 logger = logging.getLogger(__name__)
 
+T = t.TypeVar("T")
+DefaultT = t.TypeVar("DefaultT")
+
 
 @t.final
 class AutodeferMode(enum.IntEnum):
@@ -162,14 +166,14 @@ class InteractionResponse:
 
     async def edit(
         self,
-        content: t.Any | hikari.UndefinedType = hikari.UNDEFINED,
+        content: t.Any | hikari.UndefinedType | None = hikari.UNDEFINED,
         *,
-        component: hikari.api.ComponentBuilder | hikari.UndefinedType = hikari.UNDEFINED,
-        components: t.Sequence[hikari.api.ComponentBuilder] | hikari.UndefinedType = hikari.UNDEFINED,
-        attachment: hikari.Resourceish | hikari.UndefinedType = hikari.UNDEFINED,
-        attachments: t.Sequence[hikari.Resourceish] | hikari.UndefinedType = hikari.UNDEFINED,
-        embed: hikari.Embed | hikari.UndefinedType = hikari.UNDEFINED,
-        embeds: t.Sequence[hikari.Embed] | hikari.UndefinedType = hikari.UNDEFINED,
+        component: hikari.api.ComponentBuilder | hikari.UndefinedType | None = hikari.UNDEFINED,
+        components: t.Sequence[hikari.api.ComponentBuilder] | hikari.UndefinedType | None = hikari.UNDEFINED,
+        attachment: hikari.Resourceish | hikari.UndefinedType | None = hikari.UNDEFINED,
+        attachments: t.Sequence[hikari.Resourceish] | hikari.UndefinedType | None = hikari.UNDEFINED,
+        embed: hikari.Embed | hikari.UndefinedType | None = hikari.UNDEFINED,
+        embeds: t.Sequence[hikari.Embed] | hikari.UndefinedType | None = hikari.UNDEFINED,
         mentions_everyone: bool | hikari.UndefinedType = hikari.UNDEFINED,
         user_mentions: t.Sequence[hikari.Snowflakeish | hikari.PartialUser]
         | bool
@@ -254,6 +258,7 @@ class Context(t.Generic[ClientT]):
         "_created_at",
         "_has_command_failed",
         "_options",
+        "_injection_ctx",
     )
 
     def __init__(
@@ -261,6 +266,7 @@ class Context(t.Generic[ClientT]):
     ) -> None:
         self._client = client
         self._command = command
+        self._injection_ctx = alluka.OverridingContext.from_client(client.injector)
         self._interaction: hikari.CommandInteraction = interaction
         self._options: t.Sequence[hikari.CommandInteractionOption] | None = None
         self._responses: t.MutableSequence[InteractionResponse] = []
@@ -413,40 +419,39 @@ class Context(t.Generic[ClientT]):
         return self._interaction.get_channel()
 
     @t.overload
-    def get_option(self, name: str, opt_type: t.Literal[OptionType.ATTACHMENT]) -> hikari.Attachment | None:
-        ...
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.COLOR]) -> hikari.Color | None: ...
 
     @t.overload
-    def get_option(self, name: str, opt_type: t.Literal[OptionType.MENTIONABLE]) -> hikari.User | hikari.Role | None:
-        ...
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.MEMBER]) -> hikari.Member | None: ...
 
     @t.overload
-    def get_option(self, name: str, opt_type: t.Literal[OptionType.USER]) -> hikari.User | None:
-        ...
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.ATTACHMENT]) -> hikari.Attachment | None: ...
 
     @t.overload
-    def get_option(self, name: str, opt_type: t.Literal[OptionType.ROLE]) -> hikari.Role | None:
-        ...
+    def get_option(
+        self, name: str, opt_type: t.Literal[OptionType.MENTIONABLE]
+    ) -> hikari.User | hikari.Role | None: ...
 
     @t.overload
-    def get_option(self, name: str, opt_type: t.Literal[OptionType.CHANNEL]) -> hikari.PartialChannel | None:
-        ...
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.USER]) -> hikari.User | None: ...
 
     @t.overload
-    def get_option(self, name: str, opt_type: t.Literal[OptionType.STRING]) -> str | None:
-        ...
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.ROLE]) -> hikari.Role | None: ...
 
     @t.overload
-    def get_option(self, name: str, opt_type: t.Literal[OptionType.BOOLEAN]) -> bool | None:
-        ...
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.CHANNEL]) -> hikari.PartialChannel | None: ...
 
     @t.overload
-    def get_option(self, name: str, opt_type: t.Literal[OptionType.FLOAT]) -> float | None:
-        ...
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.STRING]) -> str | None: ...
 
     @t.overload
-    def get_option(self, name: str, opt_type: t.Literal[OptionType.INTEGER]) -> int | None:
-        ...
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.BOOLEAN]) -> bool | None: ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.FLOAT]) -> float | None: ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.INTEGER]) -> int | None: ...
 
     def get_option(self, name: str, opt_type: OptionType) -> t.Any | None:
         """Get the value of an option by name.
@@ -530,6 +535,40 @@ class Context(t.Generic[ClientT]):
         request = CustomLocaleRequest(self.command, locale, self, key)
         return self._client._custom_locale_provider(request).format(**kwargs)
 
+    @t.overload
+    def get_type_dependency(self, type_: type[T]) -> T: ...
+
+    @t.overload
+    def get_type_dependency(self, type_: type[T], *, default: DefaultT) -> T | DefaultT: ...
+
+    def get_type_dependency(
+        self, type_: type[T], *, default: DefaultT | hikari.UndefinedType = hikari.UNDEFINED
+    ) -> T | DefaultT:
+        """Get a type dependency for the current context.
+
+        Parameters
+        ----------
+        type_ : type[T]
+            The type of the dependency.
+        default : DefaultT
+            The default value to return if the dependency does not exist.
+            If not provided, this will raise an exception if the dependency does not exist.
+
+        Returns
+        -------
+        T | DefaultT
+            The instance of the dependency, if it exists, otherwise `default`.
+
+        Raises
+        ------
+        KeyError
+            If the dependency does not exist and `default` was not provided.
+        """
+        if default is hikari.UNDEFINED:
+            return self._injection_ctx.get_type_dependency(type_)
+        else:
+            return self._injection_ctx.get_type_dependency(type_, default=default)
+
     async def get_last_response(self) -> InteractionResponse:
         """Get the last response issued to the interaction this context is proxying.
 
@@ -652,14 +691,12 @@ class Context(t.Generic[ClientT]):
             return response
 
     @t.overload
-    async def respond_with_builder(self, builder: hikari.api.InteractionModalBuilder) -> None:
-        ...
+    async def respond_with_builder(self, builder: hikari.api.InteractionModalBuilder) -> None: ...
 
     @t.overload
     async def respond_with_builder(
         self, builder: hikari.api.InteractionMessageBuilder | hikari.api.InteractionDeferredBuilder
-    ) -> InteractionResponse:
-        ...
+    ) -> InteractionResponse: ...
 
     async def respond_with_builder(self, builder: ResponseBuilderT) -> InteractionResponse | None:
         """Respond to the interaction with a builder. This method will try to turn the builder into a valid

arc/errors.py

@@ -7,6 +7,7 @@ if t.TYPE_CHECKING:
 
     from arc.abc.concurrency_limiting import ConcurrencyLimiterProto
     from arc.abc.limiter import LimiterProto
+    from arc.abc.option import ConverterOption
 
 
 class ArcError(Exception):
@@ -162,6 +163,23 @@ class GuildCommandPublishFailedError(CommandPublishFailedError):
         super().__init__(*args)
 
 
+class OptionConverterFailureError(ArcError):
+    """Raised when an option converter fails to convert a value.
+
+    Attributes
+    ----------
+    option : arc.abc.option.ConverterOption
+        The option that failed to convert the value.
+    value : t.Any
+        The value that failed to be converted.
+    """
+
+    def __init__(self, option: ConverterOption[t.Any, t.Any, t.Any, t.Any], value: t.Any, *args: t.Any) -> None:
+        self.option = option
+        self.value = value
+        super().__init__(*args)
+
+
 # MIT License
 #
 # Copyright (c) 2023-present hypergonial

arc/extension.py

@@ -8,13 +8,11 @@ if t.TYPE_CHECKING:
 
 
 @t.overload
-def loader() -> t.Callable[[t.Callable[[ClientT], None]], t.Callable[[ClientT], None]]:
-    ...
+def loader() -> t.Callable[[t.Callable[[ClientT], None]], t.Callable[[ClientT], None]]: ...
 
 
 @t.overload
-def loader(callback: t.Callable[[ClientT], None]) -> t.Callable[[ClientT], None]:
-    ...
+def loader(callback: t.Callable[[ClientT], None]) -> t.Callable[[ClientT], None]: ...
 
 
 def loader(
@@ -51,13 +49,11 @@ def loader(
 
 
 @t.overload
-def unloader() -> t.Callable[[t.Callable[[ClientT], None]], t.Callable[[ClientT], None]]:
-    ...
+def unloader() -> t.Callable[[t.Callable[[ClientT], None]], t.Callable[[ClientT], None]]: ...
 
 
 @t.overload
-def unloader(callback: t.Callable[[ClientT], None]) -> t.Callable[[ClientT], None]:
-    ...
+def unloader(callback: t.Callable[[ClientT], None]) -> t.Callable[[ClientT], None]: ...
 
 
 def unloader(

arc/internal/about.py

@@ -1,11 +1,11 @@
 import typing as t
 
 __author__: t.Final[str] = "hypergonial"
-__author_email__: t.Final[str] = "46067571+hypergonial@users.noreply.github.com"
+__author_email__: t.Final[str] = "git@hypergonial.com"
 __maintainer__: t.Final[str] = "hypergonial"
 __license__: t.Final[str] = "MIT"
 __url__: t.Final[str] = "https://github.com/hypergonial/hikari-arc"
-__version__: t.Final[str] = "1.2.0"
+__version__: t.Final[str] = "1.3.0"
 
 # MIT License
 #

arc/internal/options.py

@@ -4,7 +4,7 @@ import typing as t
 
 import hikari
 
-from arc.abc.option import OptionType
+from arc.abc.option import ConverterOption, OptionType
 
 if t.TYPE_CHECKING:
     from arc.abc.option import CommandOptionBase
@@ -21,6 +21,8 @@ OPTIONTYPE_TO_TYPE: dict[OptionType, type[t.Any]] = {
     OptionType.MENTIONABLE: hikari.Unique,
     OptionType.FLOAT: float,
     OptionType.ATTACHMENT: hikari.Attachment,
+    OptionType.COLOR: hikari.Color,
+    OptionType.MEMBER: hikari.Member,
 }
 """Used for runtime type checking in Context.get_option, not much else at the moment."""
 
@@ -89,18 +91,21 @@ def resolve_options(
     """
     option_kwargs: dict[str, t.Any] = {}
 
-    for arg_name, opt in local_options.items():
+    for opt in local_options.values():
         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:
-            option_kwargs[arg_name] = resolve_snowflake_value(inter_opt.value, inter_opt.type, resolved)
+            option_kwargs[opt.arg_name] = resolve_snowflake_value(inter_opt.value, inter_opt.type, resolved)
 
         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
+            option_kwargs[opt.arg_name] = inter_opt.value
+
+        if isinstance(opt, ConverterOption):
+            option_kwargs[opt.arg_name] = opt._convert_value(option_kwargs[opt.arg_name])  # pyright: ignore
 
     return option_kwargs

arc/internal/sigparse.py

@@ -15,10 +15,14 @@ from arc.command.option import (
     BoolParams,
     ChannelOption,
     ChannelParams,
+    ColorOption,
+    ColorParams,
     FloatOption,
     FloatParams,
     IntOption,
     IntParams,
+    MemberOption,
+    MemberParams,
     MentionableOption,
     MentionableParams,
     RoleOption,
@@ -46,6 +50,9 @@ TYPE_TO_OPTION_MAPPING: dict[type[t.Any], type[CommandOptionBase[t.Any, t.Any, t
     float: FloatOption,
     hikari.Role: RoleOption,
     hikari.Attachment: AttachmentOption,
+    hikari.Member: MemberOption,
+    hikari.InteractionMember: MemberOption,
+    hikari.Color: ColorOption,
     hikari.User: UserOption,
 }
 
@@ -59,6 +66,8 @@ OPT_TO_PARAMS_MAPPING: dict[type[CommandOptionBase[t.Any, t.Any, t.Any]], type[t
     MentionableOption: MentionableParams,
     RoleOption: RoleParams,
     AttachmentOption: AttachmentParams,
+    MemberOption: MemberParams,
+    ColorOption: ColorParams,
 }
 
 BASE_CHANNEL_TYPE_MAP: dict[type[hikari.PartialChannel], hikari.ChannelType] = {
@@ -305,15 +314,20 @@ def parse_command_signature(  # noqa: C901
         # If it's a union of channel types, we need to parse all channel types
         if union is not None and any(arg in CHANNEL_TYPES_MAPPING for arg in t.get_args(union)):
             channel_types = _parse_channel_union_type_hint(union)
-            options[arg_name] = ChannelOption._from_params(
-                name=params.name or arg_name, is_required=not is_optional, params=params, channel_types=channel_types
+            options[params.name or arg_name] = ChannelOption._from_params(
+                name=params.name or arg_name,
+                arg_name=arg_name,
+                is_required=not is_optional,
+                params=params,
+                channel_types=channel_types,
             )
             continue
 
         # If it's a single channel type, just pass the channel type
         elif type_ in CHANNEL_TYPES_MAPPING:
-            options[arg_name] = ChannelOption._from_params(
+            options[params.name or arg_name] = ChannelOption._from_params(
                 name=params.name or arg_name,
+                arg_name=arg_name,
                 is_required=not is_optional,
                 params=params,
                 channel_types=_channels_to_channel_types([type_]),
@@ -321,8 +335,8 @@ def parse_command_signature(  # noqa: C901
             continue
 
         # Otherwise just build the option
-        options[arg_name] = opt_type._from_params(
-            name=params.name or arg_name, is_required=not is_optional, params=params
+        options[params.name or arg_name] = opt_type._from_params(
+            name=params.name or arg_name, arg_name=arg_name, is_required=not is_optional, params=params
         )
 
     return options

arc/internal/sync.py

@@ -127,9 +127,9 @@ def _get_all_commands(
         A mapping of guilds to command types to command names to commands that should be registered.
     """
     # The big daddy of all mappings
-    mapping: dict[
-        hikari.Snowflake | None, dict[hikari.CommandType, dict[str, CommandBase[t.Any, t.Any]]]
-    ] = defaultdict(lambda: defaultdict(lambda: defaultdict(dict)))  # type: ignore
+    mapping: dict[hikari.Snowflake | None, dict[hikari.CommandType, dict[str, CommandBase[t.Any, t.Any]]]] = (
+        defaultdict(lambda: defaultdict(lambda: defaultdict(dict)))  # type: ignore
+    )
 
     for command in itertools.chain(
         client._slash_commands.values(), client._message_commands.values(), client._user_commands.values()

arc/internal/types.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import typing as t
 
 if t.TYPE_CHECKING:
+    import alluka
     import hikari
 
     from arc.abc import Client, Hookable, HookResult, OptionParams
@@ -34,12 +35,13 @@ SlashCommandLike: t.TypeAlias = "SlashCommand[ClientT] | SlashGroup[ClientT]"
 CommandCallbackT: t.TypeAlias = "t.Callable[t.Concatenate[Context[ClientT], ...], t.Awaitable[None]]"
 MessageCommandCallbackT: t.TypeAlias = "t.Callable[[Context[ClientT], hikari.Message], t.Awaitable[None]]"
 UserCommandCallbackT: t.TypeAlias = "t.Callable[[Context[ClientT], hikari.User], t.Awaitable[None]]"
-AutocompleteCallbackT: t.TypeAlias = "t.Callable[[AutocompleteData[ClientT, ChoiceT]], t.Awaitable[t.Sequence[ChoiceT]]] | t.Callable[[AutocompleteData[ClientT, ChoiceT]], t.Awaitable[t.Sequence[hikari.api.AutocompleteChoiceBuilder]]]"
+AutocompleteCallbackT: t.TypeAlias = "t.Callable[[AutocompleteData[ClientT, ChoiceT]], t.Awaitable[t.Sequence[ChoiceT]]] | t.Callable[[AutocompleteData[ClientT, ChoiceT]], t.Awaitable[t.Mapping[str, ChoiceT]]] | t.Callable[[AutocompleteData[ClientT, ChoiceT]], t.Awaitable[t.Sequence[hikari.api.AutocompleteChoiceBuilder]]]"
 ResponseBuilderT: t.TypeAlias = (
     "hikari.api.InteractionMessageBuilder | hikari.api.InteractionDeferredBuilder | hikari.api.InteractionModalBuilder"
 )
 HookT: t.TypeAlias = "t.Callable[[Context[ClientT]], t.Awaitable[HookResult]] | t.Callable[[Context[ClientT]], HookResult] | t.Callable[[Context[ClientT]], None] | t.Callable[[Context[ClientT]], t.Awaitable[None]]"
 PostHookT: t.TypeAlias = "t.Callable[[Context[ClientT]], None] | t.Callable[[Context[ClientT]], t.Awaitable[None]]"
+InjectionHookT: t.TypeAlias = "t.Callable[[Context[ClientT], alluka.OverridingContext], None] | t.Callable[[Context[ClientT], alluka.OverridingContext], t.Awaitable[None]]"
 LifeCycleHookT: t.TypeAlias = "t.Callable[[ClientT], t.Awaitable[None]]"
 CommandLocaleRequestT: t.TypeAlias = "t.Callable[[CommandLocaleRequest], LocaleResponse]"
 OptionLocaleRequestT: t.TypeAlias = "t.Callable[[OptionLocaleRequest], LocaleResponse]"

arc/utils/concurrency_limiter.py

@@ -166,7 +166,7 @@ class ConcurrencyLimiter(t.Generic[KeyT]):
         This will block until a slot is available.
         """
         key = self._get_key(item)
-        bucket = self._buckets.setdefault(key, _Bucket.for_limiter(key, self))
+        bucket = self._buckets.setdefault(key, _Bucket.for_limiter(key, self))  # pyright: ignore reportUnknowMemberType
         await bucket.semaphore.acquire()
 
     def release(self, item: KeyT) -> None:
@@ -243,9 +243,14 @@ class CommandConcurrencyLimiter(ConcurrencyLimiter[Context[ClientT]], Concurrenc
         return super().__call__(item)
 
 
-def global_concurrency() -> CommandConcurrencyLimiter[t.Any]:
+def global_concurrency(limit: int) -> CommandConcurrencyLimiter[t.Any]:
     """Limit a command to a certain amount of concurrent instances globally.
 
+    Parameters
+    ----------
+    limit : int
+        The maximum amount of concurrently running command instances.
+
     Returns
     -------
     CommandConcurrencyLimiter[t.Any]
@@ -254,10 +259,10 @@ def global_concurrency() -> CommandConcurrencyLimiter[t.Any]:
     Examples
     --------
     ```py
-    @arc.with_concurrency_limit(arc.global_concurrency())
+    @arc.with_concurrency_limit(arc.global_concurrency(1))
     ```
     """
-    return CommandConcurrencyLimiter(1, get_key_with=lambda _: "amongus")
+    return CommandConcurrencyLimiter(limit, get_key_with=lambda _: "amongus")
 
 
 def guild_concurrency(limit: int) -> CommandConcurrencyLimiter[t.Any]:

arc/utils/ratelimiter.py

@@ -184,7 +184,7 @@ class RateLimiter(t.Generic[KeyT]):
 
         key = self.get_key(item)
         # Get existing or insert new bucket
-        bucket = self._buckets.setdefault(key, _Bucket.for_limiter(key, self))
+        bucket = self._buckets.setdefault(key, _Bucket.for_limiter(key, self))  # pyright: ignore reportUnknowMemberType
 
         if bucket.is_exhausted and not wait:
             raise RateLimiterExhaustedError(

{hikari_arc-1.2.0.dist-info → hikari_arc-1.3.0.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: hikari-arc
-Version: 1.2.0
+Version: 1.3.0
 Summary: A command handler for hikari with a focus on type-safety and correctness.
 Home-page: https://github.com/hypergonial/hikari-arc
 Author: hypergonial
-Author-email: 46067571+hypergonial@users.noreply.github.com
+Author-email: git@hypergonial.com
 Maintainer: hypergonial
 License: MIT
 Classifier: Development Status :: 5 - Production/Stable
@@ -24,27 +24,27 @@ Requires-Python: >=3.10.0,<3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: hikari >=2.0.0.dev122
-Requires-Dist: alluka >=0.1.4
+Requires-Dist: alluka <0.4,>=0.3.0
 Requires-Dist: attrs >=23.1
 Requires-Dist: colorama ; sys_platform=="win32"
 Provides-Extra: cron
-Requires-Dist: croniter ==2.0.1 ; extra == 'cron'
-Requires-Dist: types-croniter ==2.0.0.20240106 ; extra == 'cron'
+Requires-Dist: croniter ==2.0.5 ; extra == 'cron'
+Requires-Dist: types-croniter ==2.0.0.20240423 ; extra == 'cron'
 Provides-Extra: dev
-Requires-Dist: ruff ==0.1.14 ; extra == 'dev'
-Requires-Dist: pyright ==1.1.348 ; extra == 'dev'
-Requires-Dist: nox ==2023.4.22 ; extra == 'dev'
-Requires-Dist: typing-extensions ==4.9.0 ; extra == 'dev'
-Requires-Dist: pytest ==7.4.4 ; extra == 'dev'
-Requires-Dist: pytest-asyncio ==0.23.3 ; extra == 'dev'
-Requires-Dist: slotscheck ==0.17.1 ; extra == 'dev'
+Requires-Dist: ruff ==0.4.4 ; extra == 'dev'
+Requires-Dist: pyright ==1.1.362 ; extra == 'dev'
+Requires-Dist: nox ==2024.4.15 ; extra == 'dev'
+Requires-Dist: typing-extensions ==4.11.0 ; extra == 'dev'
+Requires-Dist: pytest ==8.2.0 ; extra == 'dev'
+Requires-Dist: pytest-asyncio ==0.23.6 ; extra == 'dev'
+Requires-Dist: slotscheck ==0.19.0 ; extra == 'dev'
 Provides-Extra: docs
-Requires-Dist: mkdocs-material[imaging] ~=9.5.5 ; extra == 'docs'
-Requires-Dist: mkdocs ~=1.5.3 ; extra == 'docs'
-Requires-Dist: mkdocstrings-python ~=1.8.0 ; extra == 'docs'
-Requires-Dist: black ~=23.12.1 ; extra == 'docs'
+Requires-Dist: mkdocs-material[imaging] ~=9.5.21 ; extra == 'docs'
+Requires-Dist: mkdocs ~=1.6.0 ; extra == 'docs'
+Requires-Dist: mkdocstrings-python ~=1.10.0 ; extra == 'docs'
+Requires-Dist: black ~=24.4.2 ; extra == 'docs'
 Requires-Dist: griffe-inherited-docstrings ~=1.0.0 ; extra == 'docs'
-Requires-Dist: mkdocs-glightbox ~=0.3.7 ; extra == 'docs'
+Requires-Dist: mkdocs-glightbox ~=0.4.0 ; extra == 'docs'
 Provides-Extra: rest
 Requires-Dist: hikari[server] >=2.0.0.dev122 ; extra == 'rest'