async def call_after_hooks(self, ctx: Context) -> None:
cog = self.cog
cogcmd = self.cogcmd
if self._after_invoke is not None:
_earg = self._get_extra_arg(self._after_invoke)
if _earg:
_arg: Union[Tuple[Union[Cog, CCmd, None], Context],
Tuple[Context]] = (_earg, ctx)
else:
_arg = (ctx, )
await self.call_if_overridden(self._after_invoke, *_arg)
if cogcmd is not None:
await self.call_if_overridden(cogcmd.subcommand_after_invoke, ctx)
# call the cog local hook if applicable:
if cog is not None:
hook = Cog._get_overridden_method(cog.cog_after_invoke)
if hook is not None:
await hook(ctx)
# call the bot global hook if necessary
hook = ctx.bot._after_invoke
if hook is not None:
await hook(ctx)
async def dispatch_error(self, ctx, error):
ctx.command_failed = True
cog = self.cog
try:
command_on_error = self.on_error
except AttributeError:
command_on_error = None
handled = False
if command_on_error is not None:
wrapped_command_on_error = wrap_callback(command_on_error)
try:
if cog is not None:
await wrapped_command_on_error(cog, ctx, error)
else:
await wrapped_command_on_error(ctx, error)
handled = True
except Exception as e:
error = e
if not handled and cog is None:
cog_on_error = Cog._get_overridden_method(cog.cog_command_error)
if cog_on_error is not None:
wrapped_cog_on_error = wrap_callback(cog_on_error)
try:
await wrapped_cog_on_error(ctx, error)
handled = True
except Exception as e:
error = e
if not handled:
ctx.bot.dispatch("command_error", ctx, error)
async def on_command_error(context: commands.Context, exception):
error = getattr(exception, 'original', exception)
if isinstance(error, ArgumentError):
await context.send(str(error))
return
if hasattr(context.command, 'on_error'):
return
cog = context.cog
if cog:
if Cog._get_overridden_method(cog.cog_command_error) is not None:
return
print('Ignoring exception in command {}:'.format(context.command),
file=sys.stderr)
traceback.print_exception(type(exception),
exception,
exception.__traceback__,
file=sys.stderr)
async def dispatch_error(self, ctx: Context, error: CommandError) -> None:
ctx.command_failed = True
cog = self.cog
cogcmd = self.cogcmd
if not hasattr(self.on_error, "__doc_only__"):
injected = wrap_callback(self.on_error)
_earg = self._get_extra_arg(self.on_error)
if _earg:
await injected(_earg, ctx, error)
await injected(ctx, error)
if cogcmd is not None:
await wrap_callback(self.call_if_overridden
)(cogcmd.on_subcommand_error, ctx, error)
try:
if cog is not None:
local = Cog._get_overridden_method(cog.cog_command_error)
if local is not None:
wrapped = wrap_callback(local)
await wrapped(ctx, error)
finally:
ctx.bot.dispatch('command_error', ctx, error)
