Browse Source
Hybrid commands allow a regular command to also double as a slash command, assuming it meets the subset required to function.pull/7881/head
Rapptz
3 years ago
10 changed files with 919 additions and 28 deletions
@ -0,0 +1,458 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
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. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import ( |
|||
TYPE_CHECKING, |
|||
Any, |
|||
Callable, |
|||
ClassVar, |
|||
Dict, |
|||
List, |
|||
Type, |
|||
TypeVar, |
|||
Union, |
|||
Optional, |
|||
) |
|||
|
|||
import discord |
|||
import inspect |
|||
from discord import app_commands |
|||
from discord.utils import MISSING, maybe_coroutine, async_all |
|||
from .core import Command, Group |
|||
from .errors import CommandRegistrationError, CommandError, HybridCommandError, ConversionError |
|||
from .converter import Converter |
|||
from .cog import Cog |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self, ParamSpec, Concatenate |
|||
from ._types import ContextT, Coro, BotT |
|||
from .bot import Bot |
|||
from .context import Context |
|||
from .parameters import Parameter |
|||
from discord.app_commands.commands import Check as AppCommandCheck |
|||
|
|||
|
|||
__all__ = ( |
|||
'HybridCommand', |
|||
'HybridGroup', |
|||
'hybrid_command', |
|||
'hybrid_group', |
|||
) |
|||
|
|||
T = TypeVar('T') |
|||
CogT = TypeVar('CogT', bound='Cog') |
|||
CommandT = TypeVar('CommandT', bound='Command') |
|||
# CHT = TypeVar('CHT', bound='Check') |
|||
GroupT = TypeVar('GroupT', bound='Group') |
|||
|
|||
if TYPE_CHECKING: |
|||
P = ParamSpec('P') |
|||
P2 = ParamSpec('P2') |
|||
|
|||
CommandCallback = Union[ |
|||
Callable[Concatenate[CogT, ContextT, P], Coro[T]], |
|||
Callable[Concatenate[ContextT, P], Coro[T]], |
|||
] |
|||
else: |
|||
P = TypeVar('P') |
|||
P2 = TypeVar('P2') |
|||
|
|||
|
|||
def is_converter(converter: Any) -> bool: |
|||
return (inspect.isclass(converter) and issubclass(converter, Converter)) or isinstance(converter, Converter) |
|||
|
|||
|
|||
def make_converter_transformer(converter: Any) -> Type[app_commands.Transformer]: |
|||
async def transform(cls, interaction: discord.Interaction, value: str) -> Any: |
|||
try: |
|||
if inspect.isclass(converter) and issubclass(converter, Converter): |
|||
if inspect.ismethod(converter.convert): |
|||
return await converter.convert(interaction._baton, value) |
|||
else: |
|||
return await converter().convert(interaction._baton, value) # type: ignore |
|||
elif isinstance(converter, Converter): |
|||
return await converter.convert(interaction._baton, value) # type: ignore |
|||
except CommandError: |
|||
raise |
|||
except Exception as exc: |
|||
raise ConversionError(converter, exc) from exc # type: ignore |
|||
|
|||
return type('ConverterTransformer', (app_commands.Transformer,), {'transform': classmethod(transform)}) |
|||
|
|||
|
|||
def replace_parameters(parameters: Dict[str, Parameter], signature: inspect.Signature) -> List[inspect.Parameter]: |
|||
# Need to convert commands.Parameter back to inspect.Parameter so this will be a bit ugly |
|||
params = signature.parameters.copy() |
|||
for name, parameter in parameters.items(): |
|||
if is_converter(parameter.converter) and not hasattr(parameter.converter, '__discord_app_commands_transformer__'): |
|||
params[name] = params[name].replace(annotation=make_converter_transformer(parameter.converter)) |
|||
|
|||
return list(params.values()) |
|||
|
|||
|
|||
class HybridAppCommand(discord.app_commands.Command[CogT, P, T]): |
|||
def __init__(self, wrapped: HybridCommand[CogT, Any, T]) -> None: |
|||
signature = inspect.signature(wrapped.callback) |
|||
params = replace_parameters(wrapped.params, signature) |
|||
wrapped.callback.__signature__ = signature.replace(parameters=params) |
|||
|
|||
try: |
|||
super().__init__( |
|||
name=wrapped.name, |
|||
callback=wrapped.callback, # type: ignore # Signature doesn't match but we're overriding the invoke |
|||
description=wrapped.description or wrapped.short_doc or '…', |
|||
) |
|||
finally: |
|||
del wrapped.callback.__signature__ |
|||
|
|||
self.wrapped: HybridCommand[CogT, Any, T] = wrapped |
|||
self.binding = wrapped.cog |
|||
|
|||
def _copy_with(self, **kwargs) -> Self: |
|||
copy: Self = super()._copy_with(**kwargs) # type: ignore |
|||
copy.wrapped = self.wrapped |
|||
return copy |
|||
|
|||
async def _check_can_run(self, interaction: discord.Interaction) -> bool: |
|||
# Hybrid checks must run like so: |
|||
# - Bot global check once |
|||
# - Bot global check |
|||
# - Parent interaction check |
|||
# - Cog/group interaction check |
|||
# - Cog check |
|||
# - Local interaction checks |
|||
# - Local command checks |
|||
|
|||
bot: Bot = interaction.client # type: ignore |
|||
ctx: Context[Bot] = interaction._baton |
|||
|
|||
if not await bot.can_run(ctx, call_once=True): |
|||
return False |
|||
|
|||
if not await bot.can_run(ctx): |
|||
return False |
|||
|
|||
if self.parent is not None and self.parent is not self.binding: |
|||
# For commands with a parent which isn't the binding, i.e. |
|||
# <binding> |
|||
# <parent> |
|||
# <command> |
|||
# The parent check needs to be called first |
|||
if not await maybe_coroutine(self.parent.interaction_check, interaction): |
|||
return False |
|||
|
|||
if self.binding is not None: |
|||
try: |
|||
# Type checker does not like runtime attribute retrieval |
|||
check: AppCommandCheck = self.binding.interaction_check # type: ignore |
|||
except AttributeError: |
|||
pass |
|||
else: |
|||
ret = await maybe_coroutine(check, interaction) |
|||
if not ret: |
|||
return False |
|||
|
|||
local_check = Cog._get_overridden_method(self.binding.cog_check) |
|||
if local_check is not None: |
|||
ret = await maybe_coroutine(local_check, ctx) |
|||
if not ret: |
|||
return False |
|||
|
|||
if self.checks and not await async_all(f(interaction) for f in self.checks): # type: ignore |
|||
return False |
|||
|
|||
if self.wrapped.checks and not await async_all(f(ctx) for f in self.wrapped.checks): # type: ignore |
|||
return False |
|||
|
|||
return True |
|||
|
|||
async def _invoke_with_namespace(self, interaction: discord.Interaction, namespace: app_commands.Namespace) -> Any: |
|||
# Wrap the interaction into a Context |
|||
bot: Bot = interaction.client # type: ignore |
|||
|
|||
# Unfortunately, `get_context` has to be called for this to work. |
|||
# If someone doesn't inherit this to replace it with their custom class |
|||
# then this doesn't work. |
|||
interaction._baton = ctx = await bot.get_context(interaction) |
|||
|
|||
exc: CommandError |
|||
try: |
|||
await self.wrapped.prepare(ctx) |
|||
# This lies and just always passes a Context instead of an Interaction. |
|||
return await self._do_call(ctx, ctx.kwargs) # type: ignore |
|||
except app_commands.CommandSignatureMismatch: |
|||
raise |
|||
except app_commands.TransformerError as e: |
|||
if isinstance(e.__cause__, CommandError): |
|||
exc = e.__cause__ |
|||
else: |
|||
exc = HybridCommandError(e) |
|||
exc.__cause__ = e |
|||
except app_commands.AppCommandError as e: |
|||
exc = HybridCommandError(e) |
|||
exc.__cause__ = e |
|||
except CommandError as e: |
|||
exc = e |
|||
|
|||
await self.wrapped.dispatch_error(ctx, exc) |
|||
|
|||
|
|||
class HybridCommand(Command[CogT, P, T]): |
|||
r"""A class that is both an application command and a regular text command. |
|||
|
|||
This has the same parameters and attributes as a regular :class:`~discord.ext.commands.Command`. |
|||
However, it also doubles as an :class:`application command <discord.app_commands.Command>`. In order |
|||
for this to work, the callbacks must have the same subset that is supported by application |
|||
commands. |
|||
|
|||
These are not created manually, instead they are created via the |
|||
decorator or functional interface. |
|||
|
|||
.. versionadded:: 2.0 |
|||
""" |
|||
|
|||
__commands_is_hybrid__: ClassVar[bool] = True |
|||
|
|||
def __init__( |
|||
self, |
|||
func: CommandCallback[CogT, ContextT, P, T], |
|||
/, |
|||
**kwargs, |
|||
) -> None: |
|||
super().__init__(func, **kwargs) |
|||
self.app_command: HybridAppCommand[CogT, Any, T] = HybridAppCommand(self) |
|||
|
|||
@property |
|||
def cog(self) -> CogT: |
|||
return self._cog |
|||
|
|||
@cog.setter |
|||
def cog(self, value: CogT) -> None: |
|||
self._cog = value |
|||
self.app_command.binding = value |
|||
|
|||
async def can_run(self, ctx: Context[BotT], /) -> bool: |
|||
if ctx.interaction is None: |
|||
return await super().can_run(ctx) |
|||
else: |
|||
return await self.app_command._check_can_run(ctx.interaction) |
|||
|
|||
async def _parse_arguments(self, ctx: Context[BotT]) -> None: |
|||
interaction = ctx.interaction |
|||
if interaction is None: |
|||
return await super()._parse_arguments(ctx) |
|||
else: |
|||
ctx.kwargs = await self.app_command._transform_arguments(interaction, interaction.namespace) |
|||
|
|||
|
|||
class HybridGroup(Group[CogT, P, T]): |
|||
r"""A class that is both an application command group and a regular text group. |
|||
|
|||
This has the same parameters and attributes as a regular :class:`~discord.ext.commands.Group`. |
|||
However, it also doubles as an :class:`application command group <discord.app_commands.Group>`. |
|||
Note that application commands groups cannot have callbacks associated with them, so the callback |
|||
is only called if it's not invoked as an application command. |
|||
|
|||
These are not created manually, instead they are created via the |
|||
decorator or functional interface. |
|||
|
|||
.. versionadded:: 2.0 |
|||
""" |
|||
|
|||
__commands_is_hybrid__: ClassVar[bool] = True |
|||
|
|||
def __init__(self, *args: Any, **attrs: Any) -> None: |
|||
super().__init__(*args, **attrs) |
|||
parent = None |
|||
if self.parent is not None: |
|||
if isinstance(self.parent, HybridGroup): |
|||
parent = self.parent.app_command |
|||
else: |
|||
raise TypeError(f'HybridGroup parent must be HybridGroup not {self.parent.__class__}') |
|||
|
|||
guild_ids = attrs.pop('guild_ids', None) or getattr(self.callback, '__discord_app_commands_default_guilds__', None) |
|||
self.app_command: app_commands.Group = app_commands.Group( |
|||
name=self.name, |
|||
description=self.description or self.short_doc or '…', |
|||
guild_ids=guild_ids, |
|||
) |
|||
|
|||
# This prevents the group from re-adding the command at __init__ |
|||
self.app_command.parent = parent |
|||
|
|||
def add_command(self, command: Union[HybridGroup[CogT, ..., Any], HybridCommand[CogT, ..., Any]], /) -> None: |
|||
"""Adds a :class:`.HybridCommand` into the internal list of commands. |
|||
|
|||
This is usually not called, instead the :meth:`~.GroupMixin.command` or |
|||
:meth:`~.GroupMixin.group` shortcut decorators are used instead. |
|||
|
|||
Parameters |
|||
----------- |
|||
command: :class:`HybridCommand` |
|||
The command to add. |
|||
|
|||
Raises |
|||
------- |
|||
CommandRegistrationError |
|||
If the command or its alias is already registered by different command. |
|||
TypeError |
|||
If the command passed is not a subclass of :class:`.HybridCommand`. |
|||
""" |
|||
|
|||
if not isinstance(command, (HybridCommand, HybridGroup)): |
|||
raise TypeError('The command passed must be a subclass of HybridCommand or HybridGroup') |
|||
|
|||
if isinstance(command, HybridGroup) and self.parent is not None: |
|||
raise ValueError(f'{command.qualified_name!r} is too nested, groups can only be nested at most one level') |
|||
|
|||
self.app_command.add_command(command.app_command) |
|||
command.parent = self |
|||
|
|||
if command.name in self.all_commands: |
|||
raise CommandRegistrationError(command.name) |
|||
|
|||
self.all_commands[command.name] = command |
|||
for alias in command.aliases: |
|||
if alias in self.all_commands: |
|||
self.remove_command(command.name) |
|||
raise CommandRegistrationError(alias, alias_conflict=True) |
|||
self.all_commands[alias] = command |
|||
|
|||
def remove_command(self, name: str, /) -> Optional[Command[CogT, ..., Any]]: |
|||
cmd = super().remove_command(name) |
|||
self.app_command.remove_command(name) |
|||
return cmd |
|||
|
|||
def command( |
|||
self, |
|||
name: str = MISSING, |
|||
*args: Any, |
|||
**kwargs: Any, |
|||
) -> Callable[[CommandCallback[CogT, ContextT, P2, T]], HybridCommand[CogT, P2, T]]: |
|||
"""A shortcut decorator that invokes :func:`~discord.ext.commands.hybrid_command` and adds it to |
|||
the internal command list via :meth:`add_command`. |
|||
|
|||
Returns |
|||
-------- |
|||
Callable[..., :class:`Command`] |
|||
A decorator that converts the provided method into a Command, adds it to the bot, then returns it. |
|||
""" |
|||
|
|||
def decorator(func: CommandCallback[CogT, ContextT, P2, T]): |
|||
kwargs.setdefault('parent', self) |
|||
result = hybrid_command(name=name, *args, **kwargs)(func) |
|||
self.add_command(result) |
|||
return result |
|||
|
|||
return decorator |
|||
|
|||
def group( |
|||
self, |
|||
name: str = MISSING, |
|||
*args: Any, |
|||
**kwargs: Any, |
|||
) -> Callable[[CommandCallback[CogT, ContextT, P2, T]], HybridGroup[CogT, P2, T]]: |
|||
"""A shortcut decorator that invokes :func:`.group` and adds it to |
|||
the internal command list via :meth:`~.GroupMixin.add_command`. |
|||
|
|||
Returns |
|||
-------- |
|||
Callable[..., :class:`Group`] |
|||
A decorator that converts the provided method into a Group, adds it to the bot, then returns it. |
|||
""" |
|||
|
|||
def decorator(func: CommandCallback[CogT, ContextT, P2, T]): |
|||
kwargs.setdefault('parent', self) |
|||
result = hybrid_group(name=name, *args, **kwargs)(func) |
|||
self.add_command(result) |
|||
return result |
|||
|
|||
return decorator |
|||
|
|||
|
|||
def hybrid_command( |
|||
name: str = MISSING, |
|||
**attrs: Any, |
|||
) -> Callable[[CommandCallback[CogT, ContextT, P, T]], HybridCommand[CogT, P, T]]: |
|||
"""A decorator that transforms a function into a :class:`.HybridCommand`. |
|||
|
|||
A hybrid command is one that functions both as a regular :class:`.Command` |
|||
and one that is also a :class:`app_commands.Command <discord.app_commands.Command>`. |
|||
|
|||
The callback being attached to the command must be representable as an |
|||
application command callback. Converters are silently converted into a |
|||
:class:`~discord.app_commands.Transformer` with a |
|||
:attr:`discord.AppCommandOptionType.string` type. |
|||
|
|||
Checks and error handlers are dispatched and called as-if they were commands |
|||
similar to :class:`.Command`. This means that they take :class:`Context` as |
|||
a parameter rather than :class:`discord.Interaction`. |
|||
|
|||
All checks added using the :func:`.check` & co. decorators are added into |
|||
the function. There is no way to supply your own checks through this |
|||
decorator. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Parameters |
|||
----------- |
|||
name: :class:`str` |
|||
The name to create the command with. By default this uses the |
|||
function name unchanged. |
|||
attrs |
|||
Keyword arguments to pass into the construction of the |
|||
hybrid command. |
|||
|
|||
Raises |
|||
------- |
|||
TypeError |
|||
If the function is not a coroutine or is already a command. |
|||
""" |
|||
|
|||
def decorator(func: CommandCallback[CogT, ContextT, P, T]): |
|||
if isinstance(func, Command): |
|||
raise TypeError('Callback is already a command.') |
|||
return HybridCommand(func, name=name, **attrs) |
|||
|
|||
return decorator |
|||
|
|||
|
|||
def hybrid_group( |
|||
name: str = MISSING, |
|||
**attrs: Any, |
|||
) -> Callable[[CommandCallback[CogT, ContextT, P, T]], HybridGroup[CogT, P, T]]: |
|||
"""A decorator that transforms a function into a :class:`.HybridGroup`. |
|||
|
|||
This is similar to the :func:`~discord.ext.commands.group` decorator except it creates |
|||
a hybrid group instead. |
|||
""" |
|||
|
|||
def decorator(func: CommandCallback[CogT, ContextT, P, T]): |
|||
if isinstance(func, Command): |
|||
raise TypeError('Callback is already a command.') |
|||
return HybridGroup(func, name=name, **attrs) |
|||
|
|||
return decorator # type: ignore |
|||
Loading…
Reference in new issue