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

arc/errors.py

@@ -1,16 +1,12 @@
+from __future__ import annotations
+
 import typing as t
 
-import hikari
+if t.TYPE_CHECKING:
+    import hikari
 
-__all__ = (
-    "ArcError",
-    "AutocompleteError",
-    "CommandInvokeError",
-    "ExtensionError",
-    "ExtensionLoadError",
-    "ExtensionUnloadError",
-    "NoResponseIssuedError",
-)
+    from arc.abc.command import CommandProto
+    from arc.abc.limiter import LimiterProto
 
 
 class ArcError(Exception):
@@ -109,6 +105,52 @@ class ResponseAlreadyIssuedError(InteractionResponseError):
     """
 
 
+class UnderCooldownError(ArcError):
+    """Raised when a built-in ratelimiter is acquired while it is exhausted, and the
+    `wait` parameter is set to `False`.
+
+    Attributes
+    ----------
+    limiter : arc.abc.limiter.LimiterProto
+        The limiter that was rate limited.
+    retry_after : float
+        The amount of time in seconds until the command is off cooldown.
+    """
+
+    def __init__(self, limiter: LimiterProto[t.Any], retry_after: float, *args: t.Any) -> None:
+        self.retry_after = retry_after
+        self.limiter = limiter
+        super().__init__(*args)
+
+
+class CommandPublishFailedError(ArcError):
+    """Raised when a command could not be published to Discord.
+
+    Attributes
+    ----------
+    command : arc.abc.command.CommandProto
+        The command that failed to publish.
+    """
+
+    def __init__(self, command: CommandProto, *args: t.Any) -> None:
+        self.command = command
+        super().__init__(*args)
+
+
+class GuildCommandPublishFailedError(ArcError):
+    """Raised when a set of commands could not be published to a guild.
+
+    Attributes
+    ----------
+    guild_id : hikari.Snowflake
+        The guild that commands could not be published to.
+    """
+
+    def __init__(self, guild_id: hikari.Snowflake, *args: t.Any) -> None:
+        self.guild_id = guild_id
+        super().__init__(*args)
+
+
 # MIT License
 #
 # Copyright (c) 2023-present hypergonial

arc/events.py

@@ -17,7 +17,11 @@ class ArcEvent(hikari.Event):
 
 
 class CommandErrorEvent(ArcEvent, t.Generic[GatewayClientT]):
-    """Event dispatched when a command raises an exception that is not handled by any error handlers."""
+    """Event dispatched when a command raises an exception that is not handled by any error handlers.
+
+    !!! warning
+        Creating any listeners for this event will disable the client error handler completely.
+    """
 
     def __init__(self, client: GatewayClientT, context: Context[GatewayClientT], exception: Exception) -> None:
         self._context = context

arc/extension.py

@@ -91,3 +91,26 @@ def unloader(
         return decorator(callback)
 
     return decorator
+
+
+# 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/internal/about.py

@@ -5,7 +5,7 @@ __author_email__: t.Final[str] = "46067571+hypergonial@users.noreply.github.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] = "0.4.0"
+__version__: t.Final[str] = "0.6.0"
 
 # MIT License
 #

arc/internal/deprecation.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import typing as t
 from warnings import warn
 
 from arc.internal.version import CURRENT_VERSION, Version
@@ -8,7 +7,7 @@ from arc.internal.version import CURRENT_VERSION, Version
 __all__ = ("warn_deprecate",)
 
 
-def warn_deprecate(*, what: str, when: Version, use_instead: t.Optional[str] = None) -> None:
+def warn_deprecate(*, what: str, when: Version, use_instead: str | None = None) -> None:
     """Warn about a deprecation.
 
     Parameters
@@ -17,8 +16,8 @@ def warn_deprecate(*, what: str, when: Version, use_instead: t.Optional[str] = N
         The name of the object that is being deprecated.
     when : Version
         The version in which the object will be removed.
-    use_instead : Optional[str], optional
-        The object's name that should be used instead, by default None
+    use_instead : str | None
+        The object's name that should be used instead
     """
     if when < CURRENT_VERSION:
         raise DeprecationWarning(

arc/internal/options.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import typing as t
+
+import hikari
+
+from arc.abc.option import OptionType
+
+if t.TYPE_CHECKING:
+    from arc.abc.option import CommandOptionBase
+    from arc.internal.types import ClientT
+
+
+OPTIONTYPE_TO_TYPE: dict[OptionType, type[t.Any]] = {
+    OptionType.STRING: str,
+    OptionType.INTEGER: int,
+    OptionType.BOOLEAN: bool,
+    OptionType.USER: hikari.PartialUser,
+    OptionType.CHANNEL: hikari.PartialChannel,
+    OptionType.ROLE: hikari.Role,
+    OptionType.MENTIONABLE: hikari.Unique,
+    OptionType.FLOAT: float,
+    OptionType.ATTACHMENT: hikari.Attachment,
+}
+"""Used for runtime type checking in Context.get_option, not much else at the moment."""
+
+
+def resolve_snowflake_value(
+    value: hikari.Snowflake, opt_type: hikari.OptionType | int, resolved: hikari.ResolvedOptionData
+) -> t.Any:
+    """Resolve a snowflake value into a resolved option.
+
+    Parameters
+    ----------
+    value : hikari.Snowflake
+        The snowflake value to resolve.
+    opt_type : hikari.OptionType | int
+        The type of the option.
+    resolved : hikari.ResolvedOptionData
+        The resolved option data of the interaction.
+
+    Returns
+    -------
+    Any
+        The resolved snowflake value.
+
+    Raises
+    ------
+    ValueError
+        If the option type is not a valid option type.
+    """
+    match opt_type:
+        case hikari.OptionType.USER:
+            out = resolved.members.get(value) or resolved.users[value]
+        case hikari.OptionType.ATTACHMENT:
+            out = resolved.attachments[value]
+        case hikari.OptionType.CHANNEL:
+            out = resolved.channels[value]
+        case hikari.OptionType.ROLE:
+            out = resolved.roles[value]
+        case hikari.OptionType.MENTIONABLE:
+            out = resolved.members.get(value) or resolved.users.get(value) or resolved.roles[value]
+        case _:
+            raise ValueError(f"Unexpected option type '{opt_type}.'")
+
+    return out
+
+
+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:
+            option_kwargs[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
+
+    return option_kwargs

arc/internal/sigparse.py

@@ -41,6 +41,7 @@ TYPE_TO_OPTION_MAPPING: dict[t.Type[t.Any], t.Type[CommandOptionBase[t.Any, t.An
     int: IntOption,
     str: StrOption,
     float: FloatOption,
+    hikari.Role: RoleOption,
     hikari.User | hikari.Role: MentionableOption,
     t.Union[hikari.User, hikari.Role]: MentionableOption,
     hikari.Attachment: AttachmentOption,
@@ -51,11 +52,14 @@ TYPE_TO_OPTION_MAPPING: dict[t.Type[t.Any], t.Type[CommandOptionBase[t.Any, t.An
     hikari.GuildNewsChannel: ChannelOption,
     hikari.GuildPrivateThread: ChannelOption,
     hikari.GuildPublicThread: ChannelOption,
+    hikari.GuildNewsThread: ChannelOption,
     hikari.GuildForumChannel: ChannelOption,
+    hikari.GuildThreadChannel: ChannelOption,
     hikari.DMChannel: ChannelOption,
     hikari.GroupDMChannel: ChannelOption,
     hikari.GuildStageChannel: ChannelOption,
     hikari.PartialChannel: ChannelOption,
+    hikari.InteractionChannel: ChannelOption,
     hikari.TextableChannel: ChannelOption,
     hikari.GuildChannel: ChannelOption,
     hikari.PrivateChannel: ChannelOption,
@@ -83,6 +87,7 @@ CHANNEL_TYPES_MAPPING: dict[t.Type[hikari.PartialChannel], hikari.ChannelType |
     hikari.GuildNewsChannel: hikari.ChannelType.GUILD_NEWS,
     hikari.GuildPrivateThread: hikari.ChannelType.GUILD_PRIVATE_THREAD,
     hikari.GuildPublicThread: hikari.ChannelType.GUILD_PUBLIC_THREAD,
+    hikari.GuildNewsThread: hikari.ChannelType.GUILD_NEWS_THREAD,
     hikari.GuildForumChannel: hikari.ChannelType.GUILD_FORUM,
     hikari.DMChannel: hikari.ChannelType.DM,
     hikari.GroupDMChannel: hikari.ChannelType.GROUP_DM,
@@ -105,6 +110,19 @@ CHANNEL_TYPES_MAPPING: dict[t.Type[hikari.PartialChannel], hikari.ChannelType |
         hikari.ChannelType.GROUP_DM,
         hikari.ChannelType.GUILD_STAGE,
     },
+    hikari.InteractionChannel: {
+        hikari.ChannelType.GUILD_TEXT,
+        hikari.ChannelType.GUILD_VOICE,
+        hikari.ChannelType.GUILD_CATEGORY,
+        hikari.ChannelType.GUILD_NEWS,
+        hikari.ChannelType.GUILD_FORUM,
+        hikari.ChannelType.GUILD_NEWS_THREAD,
+        hikari.ChannelType.GUILD_PUBLIC_THREAD,
+        hikari.ChannelType.GUILD_PRIVATE_THREAD,
+        hikari.ChannelType.DM,
+        hikari.ChannelType.GROUP_DM,
+        hikari.ChannelType.GUILD_STAGE,
+    },
     hikari.TextableChannel: {
         hikari.ChannelType.GUILD_TEXT,
         hikari.ChannelType.GUILD_VOICE,
@@ -366,7 +384,7 @@ def parse_command_signature(  # noqa: C901
     return options
 
 
-def parse_event_signature(func: t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]) -> list[type[EventT]]:
+def parse_event_signature(func: t.Callable[[EventT], t.Awaitable[None]]) -> list[type[EventT]]:
     """Parse an event callback function's signature and return the event type, ignore other type hints."""
     hints = t.get_type_hints(func)
 

arc/internal/sync.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 import itertools
 import logging
-import pprint
 import typing as t
 from collections import defaultdict
 from contextlib import suppress
 
 import hikari
 
+from arc.errors import GuildCommandPublishFailedError
+
 if t.TYPE_CHECKING:
     from arc.abc.client import Client
     from arc.abc.command import CommandBase
@@ -154,7 +155,7 @@ def _get_all_commands(
     ] = 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()
+        client._slash_commands.values(), client._message_commands.values(), client._user_commands.values()
     ):
         if command.guilds:
             for guild_id in command.guilds:
@@ -204,7 +205,7 @@ async def _sync_global_commands(client: Client[AppT], commands: CommandMapping)
 
     upstream = await client.app.rest.fetch_application_commands(client.application)
 
-    published: set[str] = set()
+    published: dict[hikari.CommandType, set[str]] = defaultdict(set)
 
     for existing in upstream:
         # Ignore unsupported command types
@@ -224,11 +225,11 @@ async def _sync_global_commands(client: Client[AppT], commands: CommandMapping)
             commands[existing.type][existing.name]._register_instance(existing)
             unchanged += 1
 
-        published.add(existing.name)
+        published[existing.type].add(existing.name)
 
     for mapping in commands.values():
         for existing in mapping.values():
-            if existing.name in published:
+            if existing.name in published[existing.command_type]:
                 continue
 
             await existing.publish()
@@ -263,7 +264,7 @@ async def _sync_commands_for_guild(
 
     upstream = await client.app.rest.fetch_application_commands(client.application, guild)
 
-    built: set[str] = set()
+    built: dict[hikari.CommandType, set[str]] = defaultdict(set)
 
     builders: list[hikari.api.CommandBuilder] = []
 
@@ -285,16 +286,19 @@ async def _sync_commands_for_guild(
             builders.append(_rebuild_hikari_command(existing))
             unchanged += 1
 
-        built.add(existing.name)
+        built[existing.type].add(existing.name)
 
     for mapping in commands.values():
         for existing in mapping.values():
-            if existing.name in built:
+            if existing.name in built[existing.command_type]:
                 continue
             builders.append(existing._build())
             created += 1
 
-    created = await client.app.rest.set_application_commands(client.application, builders, guild)
+    try:
+        created = await client.app.rest.set_application_commands(client.application, builders, guild)
+    except Exception as e:
+        raise GuildCommandPublishFailedError(guild_id, e, f"Failed to register commands in guild {guild_id}.") from e
 
     for existing in created:
         with suppress(KeyError):
@@ -325,7 +329,6 @@ async def _sync_commands(client: Client[AppT]) -> None:
 
     commands = _get_all_commands(client)
     _process_localizations(client, commands)
-    pprint.PrettyPrinter(indent=4).pprint(commands)
 
     global_commands = commands.pop(None, None)
 

arc/internal/types.py

@@ -6,7 +6,7 @@ if t.TYPE_CHECKING:
     import hikari
 
     from arc.abc import Client, Hookable, HookResult, OptionParams
-    from arc.client import GatewayClient, RESTClient
+    from arc.client import GatewayClientBase, RESTClientBase
     from arc.command import SlashCommand, SlashGroup
     from arc.context import AutocompleteData, Context
     from arc.locale import CommandLocaleRequest, CustomLocaleRequest, LocaleResponse, OptionLocaleRequest
@@ -16,25 +16,22 @@ if t.TYPE_CHECKING:
 AppT = t.TypeVar("AppT", bound="hikari.RESTAware")
 ChoiceT = t.TypeVar("ChoiceT", bound="int | float | str")
 ClientT = t.TypeVar("ClientT", bound="Client[t.Any]")
-GatewayClientT = t.TypeVar("GatewayClientT", bound="GatewayClient")
-RESTClientT = t.TypeVar("RESTClientT", bound="RESTClient")
+GatewayBotT = t.TypeVar("GatewayBotT", bound="hikari.GatewayBotAware")
+RESTBotT = t.TypeVar("RESTBotT", bound="hikari.RESTBotAware")
+GatewayClientT = t.TypeVar("GatewayClientT", bound="GatewayClientBase[t.Any]")
+RESTClientT = t.TypeVar("RESTClientT", bound="RESTClientBase[t.Any]")
 EventT = t.TypeVar("EventT", bound="hikari.Event")
 BuilderT = t.TypeVar("BuilderT", bound="hikari.api.SlashCommandBuilder | hikari.api.ContextMenuCommandBuilder")
 ParamsT = t.TypeVar("ParamsT", bound="OptionParams[t.Any]")
 HookableT = t.TypeVar("HookableT", bound="Hookable[t.Any]")
-P = t.ParamSpec("P")
 
 # Type aliases
-EventCallbackT: t.TypeAlias = "t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]"
-ErrorHandlerCallbackT: t.TypeAlias = (
-    "t.Callable[t.Concatenate[Context[ClientT], Exception, ...], t.Coroutine[t.Any, t.Any, None]]"
-)
+EventCallbackT: t.TypeAlias = "t.Callable[[EventT], t.Awaitable[None]]"
+ErrorHandlerCallbackT: t.TypeAlias = "t.Callable[[Context[ClientT], Exception], t.Awaitable[None]]"
 SlashCommandLike: t.TypeAlias = "SlashCommand[ClientT] | SlashGroup[ClientT]"
 CommandCallbackT: t.TypeAlias = "t.Callable[t.Concatenate[Context[ClientT], ...], t.Awaitable[None]]"
-MessageContextCallbackT: t.TypeAlias = (
-    "t.Callable[t.Concatenate[Context[ClientT], hikari.Message, ...], t.Awaitable[None]]"
-)
-UserContextCallbackT: t.TypeAlias = "t.Callable[t.Concatenate[Context[ClientT], hikari.User, ...], 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]]]"
 ResponseBuilderT: t.TypeAlias = (
     "hikari.api.InteractionMessageBuilder | hikari.api.InteractionDeferredBuilder | hikari.api.InteractionModalBuilder"
@@ -42,6 +39,28 @@ ResponseBuilderT: t.TypeAlias = (
 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]]"
 LifeCycleHookT: t.TypeAlias = "t.Callable[[ClientT], t.Awaitable[None]]"
-CommandLocaleRequestT: t.TypeAlias = "t.Callable[t.Concatenate[CommandLocaleRequest, ...], LocaleResponse]"
-OptionLocaleRequestT: t.TypeAlias = "t.Callable[t.Concatenate[OptionLocaleRequest, ...], LocaleResponse]"
-CustomLocaleRequestT: t.TypeAlias = "t.Callable[t.Concatenate[CustomLocaleRequest, ...], str]"
+CommandLocaleRequestT: t.TypeAlias = "t.Callable[[CommandLocaleRequest], LocaleResponse]"
+OptionLocaleRequestT: t.TypeAlias = "t.Callable[[OptionLocaleRequest], LocaleResponse]"
+CustomLocaleRequestT: t.TypeAlias = "t.Callable[[CustomLocaleRequest], str]"
+
+# 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/locale.py

@@ -23,6 +23,7 @@ __all__ = (
 )
 
 
+@t.final
 class LocaleRequestType(enum.IntEnum):
     """The type of locale request."""
 
@@ -64,6 +65,7 @@ class LocaleRequest(abc.ABC):
         return self._command.qualified_name
 
 
+@t.final
 @attr.define(slots=True)
 class LocaleResponse:
     """The response to a command or option locale request."""
@@ -75,6 +77,7 @@ class LocaleResponse:
     """The localized description of the command or option."""
 
 
+@t.final
 @attr.define(slots=True)
 class CommandLocaleRequest(LocaleRequest):
     """A request to localize a command."""
@@ -98,6 +101,7 @@ class CommandLocaleRequest(LocaleRequest):
         return self._description
 
 
+@t.final
 @attr.define(slots=True)
 class OptionLocaleRequest(LocaleRequest):
     """A request to localize a command option."""
@@ -127,6 +131,7 @@ class OptionLocaleRequest(LocaleRequest):
         return self._description
 
 
+@t.final
 @attr.define(slots=True)
 class CustomLocaleRequest(LocaleRequest):
     """A custom locale request made by the user."""
@@ -148,3 +153,26 @@ class CustomLocaleRequest(LocaleRequest):
     def key(self) -> str:
         """The key that is to be localized."""
         return self._key
+
+
+# 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/plugin.py

@@ -2,12 +2,14 @@ from __future__ import annotations
 
 import typing as t
 
+import hikari
+
 from arc.abc.plugin import PluginBase
 from arc.internal.sigparse import parse_event_signature
 from arc.internal.types import EventCallbackT, EventT, GatewayClientT, RESTClientT
 
 if t.TYPE_CHECKING:
-    import hikari
+    from arc.context.base import AutodeferMode
 
 __all__ = ("RESTPluginBase", "GatewayPluginBase")
 
@@ -23,6 +25,22 @@ class RESTPluginBase(PluginBase[RESTClientT]):
     ----------
     name : str
         The name of this plugin. This must be unique across all plugins.
+    default_enabled_guilds : t.Sequence[hikari.Snowflake] | hikari.UndefinedType
+        The default guilds to enable commands in
+    autodefer : bool | AutodeferMode
+        If True, all commands in this plugin will automatically defer if it is taking longer than 2 seconds to respond.
+        This can be overridden on a per-command basis.
+    is_dm_enabled : bool | hikari.UndefinedType
+        Whether commands in this plugin are enabled in DMs
+        This can be overridden on a per-command basis.
+    default_permissions : hikari.Permissions | hikari.UndefinedType
+        The default permissions for this plugin
+        This can be overridden on a per-command basis.
+    is_nsfw : bool | hikari.UndefinedType
+        Whether this plugin is only usable in NSFW channels
+
+    !!! note
+        Parameters left as `hikari.UNDEFINED` will be inherited from the parent client.
 
     Usage
     -----
@@ -53,6 +71,22 @@ class GatewayPluginBase(PluginBase[GatewayClientT]):
     ----------
     name : str
         The name of this plugin. This must be unique across all plugins.
+    default_enabled_guilds : t.Sequence[hikari.Snowflake] | hikari.UndefinedType
+        The default guilds to enable commands in
+    autodefer : bool | AutodeferMode
+        If True, all commands in this plugin will automatically defer if it is taking longer than 2 seconds to respond.
+        This can be overridden on a per-command basis.
+    is_dm_enabled : bool | hikari.UndefinedType
+        Whether commands in this plugin are enabled in DMs
+        This can be overridden on a per-command basis.
+    default_permissions : hikari.Permissions | hikari.UndefinedType
+        The default permissions for this plugin
+        This can be overridden on a per-command basis.
+    is_nsfw : bool | hikari.UndefinedType
+        Whether this plugin is only usable in NSFW channels
+
+    !!! note
+        Parameters left as `hikari.UNDEFINED` will be inherited from the parent client.
 
     Usage
     -----
@@ -70,8 +104,25 @@ class GatewayPluginBase(PluginBase[GatewayClientT]):
     ```
     """
 
-    def __init__(self, name: str) -> None:
-        super().__init__(name)
+    def __init__(
+        self,
+        name: str,
+        *,
+        default_enabled_guilds: t.Sequence[hikari.Snowflakeish | hikari.PartialGuild]
+        | hikari.UndefinedType = hikari.UNDEFINED,
+        autodefer: bool | AutodeferMode | hikari.UndefinedType = hikari.UNDEFINED,
+        is_dm_enabled: bool | hikari.UndefinedType = hikari.UNDEFINED,
+        default_permissions: hikari.Permissions | hikari.UndefinedType = hikari.UNDEFINED,
+        is_nsfw: bool | hikari.UndefinedType = hikari.UNDEFINED,
+    ) -> None:
+        super().__init__(
+            name=name,
+            default_enabled_guilds=default_enabled_guilds,
+            autodefer=autodefer,
+            is_dm_enabled=is_dm_enabled,
+            default_permissions=default_permissions,
+            is_nsfw=is_nsfw,
+        )
         self._listeners: dict[type[hikari.Event], set[EventCallbackT[t.Any]]] = {}
 
     @property
@@ -89,7 +140,7 @@ class GatewayPluginBase(PluginBase[GatewayClientT]):
         ----------
         event : type[hikari.Event]
             The event to subscribe to.
-        callback : Callable[[EventT], Awaitable[None]]
+        callback : t.Callable[[EventT], t.Awaitable[None]]
             The callback to call when the event is dispatched.
         """
         if event not in self.listeners:
@@ -107,7 +158,7 @@ class GatewayPluginBase(PluginBase[GatewayClientT]):
         ----------
         event : type[hikari.Event]
             The event to unsubscribe from.
-        callback : Callable[[EventT], Awaitable[None]]
+        callback : t.Callable[[EventT], t.Awaitable[None]]
             The callback to unsubscribe.
         """
         if event not in self.listeners: