def on_command_error(self, error, ctx):
ignored = (commands.NoPrivateMessage, commands.DisabledCommand, commands.CheckFailure,
commands.CommandNotFound, commands.UserInputError, discord.HTTPException)
error = getattr(error, 'original', error)
if isinstance(error, ignored):
return
if ctx.message.server:
fmt = 'Channel: {0} (ID: {0.id})\nGuild: {1} (ID: {1.id})'
else:
fmt = 'Channel: {0} (ID: {0.id})'
exc = traceback.format_exception(type(error), error, error.__traceback__, chain=False)
description = '```py\n%s\n```' % ''.join(exc)
time = datetime.datetime.utcnow()
name = ctx.command.qualified_name
author = '{0} (ID: {0.id})'.format(ctx.message.author)
location = fmt.format(ctx.message.channel, ctx.message.server)
message = '{0} at {1}: Called by: {2} in {3}. More info: {4}'.format(name, time, author, location, description)
self.bot.logs['discord'].critical(message)
python类CheckFailure()的实例源码
def has_permission(ctx: commands.Context) -> bool:
""" Checks if a user is an administrator or if has the role
that grants elevated permissions.
:param ctx: The context to check the command in.
:type ctx: commands.Context
:return: True if the command succeeds, else raises an exception.
:raises: commands.CheckFailure: If the check fails.
message : "no permissions"
"""
if isinstance(ctx.bot, PomodoroBot) and \
ctx.bot.has_permission(ctx.message.author):
return True
raise commands.CheckFailure(message="no permissions")
def is_admin(ctx: commands.Context) -> bool:
""" Checks if the author of the command is the administrator / owner
of the bot.
:param ctx: The context to check the command in.
:type ctx: commands.Context
:return: True if the command succeeds, else raises an exception.
:raises: commands.CheckFailure: If the check fails.
message : "not admin"
"""
if isinstance(ctx.bot, PomodoroBot) and \
ctx.bot.is_admin(ctx.message.author):
return True
raise commands.CheckFailure(message="not admin")
def channel_has_timer(ctx: commands.Context) -> bool:
""" Checks if a channel has a valid timer set.
:param ctx: The context to check the command in
:type ctx: commands.Context
:return: True if the command succeeds, else raises an exception.
:raises: commands.CheckFailure: If the check fails.
message : "timer not found"
"""
if isinstance(ctx.bot, PomodoroBot):
channel = ctx.bot.spoof(ctx.message.author, lib.get_channel(ctx))
if ctx.bot.get_interface(channel).timer is not None:
return True
raise commands.CheckFailure(message="timer not found")
def unlocked_or_allowed(ctx: commands.Context) -> bool:
""" Checks if a timer is unlocked, or if the author of the command
has permissions to execute such command on a locked timer.
:param ctx: The context to check the command in
:type ctx: commands.Context
:return: True if the command succeeds, else raises an exception.
:raises: commands.CheckFailure: If the check fails.
message : "timer locked"
"""
if isinstance(ctx.bot, PomodoroBot) and \
ctx.bot.is_locked(lib.get_channel(ctx)) and \
not ctx.bot.has_permission(ctx.message.author):
raise commands.CheckFailure(message="timer locked")
return True
def on_command_error(ctx, error):
if isinstance(error, commands.CommandNotFound):
return
# if isinstance(error, commands.CommandInvokeError):
# return print(error)
errors = {
commands.DisabledCommand: 'Command has been disabled.',
commands.MissingPermissions: 'Invoker is missing permissions to run this command.',
commands.BotMissingPermissions: 'Bot is missing permissions to run this command.',
commands.CheckFailure: 'You are not allowed to run this command.'
}
for type, text in errors.items():
if isinstance(error, type):
return await ctx.send(errors[type])
# argument error
if isinstance(error, commands.UserInputError):
bot.formatter.context = ctx
bot.formatter.command = ctx.command
return await ctx.send(f'Invalid argument(s) provided.\n```{bot.formatter.get_command_signature()}```')
await ctx.send(f'An error occured in `{ctx.command.name}` invoked by {ctx.message.author}:\n```{error}```')
#traceback.print_exception(type(exception), exception, exception.__traceback__, file=sys.stderr)
# blacklist check
# check is user is blacklister, or if it's a bot
def on_command_error(self, ctx, error):
ignored = (commands.NoPrivateMessage, commands.DisabledCommand, commands.CheckFailure,
commands.CommandNotFound, commands.UserInputError, discord.Forbidden)
error = getattr(error, 'original', error)
if isinstance(error, ignored):
return
e = discord.Embed(title='Command Error', colour=0xcc3366)
e.add_field(name='Name', value=ctx.command.qualified_name)
e.add_field(name='Author', value=f'{ctx.author} (ID: {ctx.author.id})')
fmt = f'Channel: {ctx.channel} (ID: {ctx.channel.id})'
if ctx.guild:
fmt = f'{fmt}\nGuild: {ctx.guild} (ID: {ctx.guild.id})'
e.add_field(name='Location', value=fmt, inline=False)
exc = ''.join(traceback.format_exception(type(error), error, error.__traceback__, chain=False))
e.description = f'```py\n{exc}\n```'
e.timestamp = datetime.datetime.utcnow()
ch = self.bot.get_channel(LOGGING_CHANNEL)
await ch.send(embed=e)
def on_command_error(self, ctx, error):
"""Command error handler"""
manager = MessageManager(self.bot, ctx.author, ctx.channel, ctx.prefix, [ctx.message])
if isinstance(error, commands.CommandNotFound):
pass
elif isinstance(error, commands.MissingRequiredArgument):
pass
elif isinstance(error, commands.NotOwner):
pass
elif isinstance(error, commands.NoPrivateMessage):
await manager.say("You can't use that command in a private message", mention=False)
elif isinstance(error, commands.CheckFailure):
await manager.say("You don't have the required permissions to do that")
elif isinstance(error, commands.CommandOnCooldown):
await manager.say(error)
elif isinstance(error, commands.CommandInvokeError):
if isinstance(error.original, discord.errors.Forbidden):
pass
else:
raise error
else:
raise error
await manager.clear()
def define_error(self, ctx, err):
if isinstance(err, commands.DisabledCommand) or isinstance(err, commands.CheckFailure):
return
await ctx.send('An error has occurred.')
def on_command_error(self, ctx, error):
if isinstance(error, commands.CheckFailure) and await self.is_owner(ctx.author):
# There is actually a race here. When this command is invoked the
# first time, it's wrapped in a context manager that automatically
# starts and closes a DB session.
#
# The issue is that this event is dispatched, which means during the
# first invoke, it creates a task for this and goes on with its day.
# The problem is that it doesn't wait for this event, meaning it might
# accidentally close the session before or during this command's
# reinvoke.
#
# This solution is dirty but since I'm only doing it once here
# it's fine. Besides it works anyway.
while ctx.session:
await asyncio.sleep(0)
try:
async with ctx.acquire():
await ctx.reinvoke()
except Exception as exc:
await ctx.command.dispatch_error(ctx, exc)
return
# command_counter['failed'] += 0 sets the 'failed' key. We don't want that.
if not isinstance(error, commands.CommandNotFound):
self.command_counter['failed'] += 1
cause = error.__cause__
if isinstance(error, errors.ChiakiException):
await ctx.send(str(error))
elif type(error) is commands.BadArgument:
await ctx.send(str(cause or error))
elif isinstance(error, commands.NoPrivateMessage):
await ctx.send('This command cannot be used in private messages.')
elif isinstance(error, commands.MissingRequiredArgument):
await ctx.send(f'This command ({ctx.command}) needs another parameter ({error.param})')
elif isinstance(error, commands.CommandInvokeError):
print(f'In {ctx.command.qualified_name}:', file=sys.stderr)
traceback.print_tb(error.original.__traceback__)
print(f'{error.__class__.__name__}: {error}'.format(error), file=sys.stderr)
def on_command_error(self, exception, ctx):
if isinstance(exception, CheckFailure):
print("{0} does not have permission to run `{1}`".format(ctx.message.author, ctx.command.name))
elif isinstance(exception, CommandNotFound):
# This is handled in CustomCommands
pass
else:
pprint(exception)
await self.on_error("on_command_error", exception, ctx)
def on_command_error(ctx, error):
if isinstance(error, commands.NoPrivateMessage):
await edit(ctx, content='\N{HEAVY EXCLAMATION MARK SYMBOL} Only usable on Servers', ttl=5)
elif isinstance(error, commands.CheckFailure):
await edit(ctx, content='\N{HEAVY EXCLAMATION MARK SYMBOL} No Permissions to use this command', ttl=5)
elif isinstance(error, commands.CommandInvokeError):
log.error('In {0.command.qualified_name}:\n{1}'.format(ctx, ''.join(traceback.format_list(traceback.extract_tb(error.original.__traceback__)))))
log.error('{0.__class__.__name__}: {0}'.format(error.original))
# Increase use count and log to logger
def p_error(error, ctx):
if isinstance(error, commands.BadArgument):
await bot.say("That\'s not a number...")
if isinstance(error, commands.CheckFailure):
await bot.say("Insufficent permissions")
def on_command_error(exception, context):
if type(exception) == commands.CommandOnCooldown:
await bot.send_message(context.message.channel,
"!{} is on cooldown for {:0.2f} seconds.".format(
context.command, exception.retry_after))
elif type(exception) == commands.CommandNotFound:
cmd = context.message.content.split()[0][1:]
try:
closest = get_close_matches(cmd.lower(), list(bot.commands))[0]
except IndexError:
await bot.send_message(context.message.channel,
"!{} is not a known command."
.format(cmd))
else:
await bot.send_message(context.message.channel,
"!{} is not a command, did you mean !{}?"
.format(cmd, closest))
elif type(exception) == commands.CheckFailure:
await bot.send_message(context.message.channel,
"You failed to meet a requirement for that "
"command.")
elif type(exception) == commands.MissingRequiredArgument:
await bot.send_message(context.message.channel,
"You are missing a required argument for that "
"command.")
else:
await bot.send_message(context.message.channel,
"Unhandled command error ({})"
.format(exception))
print('Ignoring exception in command {}'.format(context.command),
file=sys.stderr)
traceback.print_exception(type(exception), exception,
exception.__traceback__, file=sys.stderr)
def on_command_error(self, error, ctx: commands.Context):
log = lib.get_author_name(ctx)
send = None
if isinstance(error, commands.CheckFailure):
if str(error) == "timer not found":
send = "No timer found for this channel."
log += " tried to interact with a nonexistent timer."
elif str(error) == "timer locked":
send = "You are not allowed to modify this timer."
log += " tried to modify a locked timer without permissions."
elif str(error) == "no permissions" or str(error) == "not admin":
send = "You do not have permission to do this!"
log += (" tried to execute a command and failed, " +
"lacked permissions.")
else:
send = "Timers are not allowed in this channel."
log += " tried to start a timer in a non-whitelisted channel."
elif isinstance(error, commands.CommandNotFound):
send = "Command not found: `" + ctx.invoked_with + "`."
log += " tried to execute a nonexistent command: `{}`."\
.format(ctx.invoked_with)
alt = None
for name, command in self.bot.commands.items():
if ctx.invoked_with == name:
alt = name
elif isinstance(command, commands.GroupMixin):
for sub_name, sub_command in command.commands.items():
if ctx.invoked_with == sub_name:
alt = name + " " + sub_name
if alt is not None:
send += " Did you mean `" + alt + "`?"
elif isinstance(error, commands.CommandInvokeError):
lib.log_cmd_stacktrace(error)
return
else:
log = str(error)
lib.log(log, channel_id=lib.get_channel_id(ctx), level=logging.WARN)
await self.bot.safe_send(lib.get_channel(ctx), send,
delete_after=self.bot.ans_lifespan)
def on_command_error(error, ctx):
if isinstance(error, commands.CommandNotFound):
return
if isinstance(error, commands.DisabledCommand):
return
try:
if isinstance(error.original, discord.Forbidden):
return
elif isinstance(error.original, discord.HTTPException) and 'empty message' in str(error.original):
return
elif isinstance(error.original, aiohttp.ClientOSError):
return
except AttributeError:
pass
if isinstance(error, commands.BadArgument):
fmt = "Please provide a valid argument to pass to the command: {}".format(error)
await bot.send_message(ctx.message.channel, fmt)
elif isinstance(error, commands.CheckFailure):
fmt = "You can't tell me what to do!"
await bot.send_message(ctx.message.channel, fmt)
elif isinstance(error, commands.CommandOnCooldown):
m, s = divmod(error.retry_after, 60)
fmt = "This command is on cooldown! Hold your horses! >:c\nTry again in {} minutes and {} seconds" \
.format(round(m), round(s))
await bot.send_message(ctx.message.channel, fmt)
elif isinstance(error, commands.NoPrivateMessage):
fmt = "This command cannot be used in a private message"
await bot.send_message(ctx.message.channel, fmt)
elif isinstance(error, commands.MissingRequiredArgument):
await bot.send_message(ctx.message.channel, error)
else:
now = datetime.datetime.now()
with open("error_log", 'a') as f:
print("In server '{0.message.server}' at {1}\nFull command: `{0.message.content}`".format(ctx, str(now)),
file=f)
try:
traceback.print_tb(error.original.__traceback__, file=f)
print('{0.__class__.__name__}: {0}'.format(error.original), file=f)
except:
traceback.print_tb(error.__traceback__, file=f)
print('{0.__class__.__name__}: {0}'.format(error), file=f)
def on_command_error(ctx, error):
if ctx.message in thinker.messages:
await thinker.stop_thinking(ctx.message)
try:
if isinstance(error, commands.CommandNotFound):
cmd = ctx.message.content[1:].split(" ")[0]
if cmd in deprecated_commands:
await ctx.send(f"You shouldn't use `?{cmd}` anymore. It's *deprecated*. Try `?{deprecated_commands[cmd]}` instead.")
return
elif cmd == "" or cmd.startswith("?") or cmd.startswith("!"):
return # These were probably not meant to be commands
if cmd.lower() in bot.commands:
new_message = ctx.message
new_message.content = "?" + cmd.lower() + ctx.message.content[len(cmd) + 1:]
await bot.process_commands(new_message)
elif await invalid_command_reporting(ctx):
await ctx.send(f"?? Ya I dunno what a '{cmd}' is, but it ain't a command. Try `?help` fer a list of things that ARE commands.")
elif isinstance(error, commands.CheckFailure):
print("(suppressed)")
return # The user does not have permissions
elif isinstance(error, commands.MissingRequiredArgument):
await ctx.send(embed=await bot.formatter.format_as_embed(ctx, ctx.command))
elif isinstance(error, commands.BadArgument):
signature = await get_cmd_signature(ctx)
await ctx.send((
"Thats the wrong type of argument for that command.\n\n"
f"Ya gotta do it like this:\n`{signature}`\n\n"
f"Try `?help {ctx.command}` for a more detailed description of the command"))
elif isinstance(error, commands.CommandInvokeError) and isinstance(error.original, discord.errors.Forbidden):
await print_missing_perms(ctx, error)
elif isinstance(error, commands.CommandInvokeError) and isinstance(error.original, discord.errors.HTTPException):
await ctx.send("Looks like there was a problem with discord just then. Try again in a bit.")
elif isinstance(error, commands.CommandInvokeError) and isinstance(error.original, UserError):
await ctx.send(error.original.message)
else:
await ctx.send("Uh-oh, sumthin dun gone wrong ??")
trace_string = report_error(ctx.message, error, skip_lines=4)
if settings.debug:
await ctx.send(f"```{trace_string}```")
except discord.errors.Forbidden:
await ctx.author.send("Looks like I don't have permission to talk in that channel, sorry")
def on_command_error(error, ctx):
language = prefs.getPref(ctx.message.server, "language")
if isinstance(error, commands.NoPrivateMessage):
await bot.send_message(ctx.message.author, _(':x: This command cannot be used in private messages.', language))
elif isinstance(error, commands.DisabledCommand):
await bot.send_message(ctx.message.author, _(':x: Sorry. This command is disabled and cannot be used.', language))
elif isinstance(error, commands.CommandInvokeError):
print('In {0.command.qualified_name}:'.format(ctx), file=sys.stderr)
traceback.print_tb(error.original.__traceback__)
print('{0.__class__.__name__}: {0}'.format(error.original), file=sys.stderr)
myperms = ctx.message.channel.permissions_for(ctx.message.server.me)
can_send = myperms.add_reactions and myperms.create_instant_invite
if can_send:
error_report = _("Send an error report?", language)
else:
error_report = _("Sadly, I need the `add_reactions` and `create_instant_invite` permissions to be able to send an error report.", language)
msg = await comm.message_user(ctx.message, _(":x: An error (`{error}`) happened while executing `{command}`, here is the traceback: ```\n{tb}\n```\n{error_report}", language).format(**{
"command" : ctx.command.qualified_name,
"error" : error.original.__class__.__name__,
"tb" : "\n".join(traceback.format_tb(error.original.__traceback__, 4)),
"error_report": error_report
}))
if can_send:
yes = "\N{THUMBS UP SIGN}"
no = "\N{THUMBS DOWN SIGN}"
await bot.add_reaction(msg, yes)
await bot.add_reaction(msg, no)
res = await bot.wait_for_reaction(emoji=[yes, no], user=ctx.message.author, message=msg, timeout=120)
if res:
reaction, user = res
emoji = reaction.emoji
if emoji == yes:
msg = await comm.message_user(ctx.message, _(":anger_right: Creating an invite for the error report...", language))
support_channel = discord.utils.find(lambda c: str(c.id) == '273930986314792960', discord.utils.find(lambda s: str(s.id) == '195260081036591104', bot.servers).channels)
invite = await bot.create_invite(ctx.message.channel, max_uses=5)
invite = invite.url
await bot.edit_message(msg, _(":anger_right: Sending error report...", language))
await bot.send_message(support_channel, _(":hammer: {date} :hammer:").format(date=int(time.time())))
await bot.send_message(support_channel, await comm.paste(_("{cause}\n\n{tb}").format(cause=error.original.__class__.__name__,
tb="\n".join(traceback.format_tb(error.original.__traceback__))), "py"))
await bot.send_message(support_channel, invite)
await bot.edit_message(msg, _(":ok: Error report sent, thanks. :)", language))
return
await comm.message_user(ctx.message, _("OK, I won't send an error report.", language))
elif isinstance(error, commands.MissingRequiredArgument):
await comm.message_user(ctx.message, _(":x: Missing a required argument. ", language) + (("Help: \n```\n" + ctx.command.help + "\n```") if ctx.command.help else ""))
elif isinstance(error, commands.BadArgument):
await comm.message_user(ctx.message, _(":x: Bad argument provided. ", language) + (("Help: \n```\n" + ctx.command.help + "\n```") if ctx.command.help else ""))
# elif isinstance(error, commands.CheckFailure):
# await comm.message_user(ctx.message, _(":x: You are not an admin/owner, you don't have enough exp to use this command, or you are banned from the channel, so you can't use this command. ", language) + (("Help: \n```\n" + ctx.command.help + "\n```") if ctx.command.help else ""))
def on_command_error(ctx, error):
"""The event triggered when an error is raised while invoking a command.
ctx : Context
error : Exception"""
if hasattr(ctx.command, 'on_error'):
return
cog = ctx.cog
if cog:
attr = f'_{cog.__class__.__name__}__error'
if hasattr(cog, attr):
return
error = getattr(error, 'original', error)
ignored = (commands.CommandNotFound, commands.UserInputError)
if isinstance(error, ignored):
return
handler = {
discord.Forbidden: '**I do not have the required permissions to run this command.**',
commands.DisabledCommand: f'{ctx.command} has been disabled.',
commands.NoPrivateMessage: f'{ctx.command} can not be used in Private Messages.',
commands.CheckFailure: '**You aren\'t allowed to use this command!**',
ExplicitCheckFailure: f'This command can only be used in a **NSFW** channel.',
InvalidChannelCheck: f'{ctx.command} can only be used in a server',
BotPermissionsCheck: 'For **any** of the moderation commands, the bot must be given\n'
'Manage Messages, Manage Nicknames, Kick Members and Ban Members'
}
try:
message = handler[type(error)]
except KeyError:
pass
else:
return await ctx.send(message)
embed = discord.Embed(title=f'Command Exception', color=discord.Color.red())
embed.set_footer(text='Occured on')
embed.timestamp = datetime.datetime.utcnow()
exc = ''.join(traceback.format_exception(type(error), error, error.__traceback__, chain=False))
exc = exc.replace('`', '\u200b`')
embed.description = f'```py\n{exc}\n```'
embed.add_field(name='Command', value=ctx.command.qualified_name)
embed.add_field(name='Invoker', value=ctx.author)
embed.add_field(name='Location', value=f'Guild: {ctx.guild}\nChannel: {ctx.channel}')
embed.add_field(name='Message', value=ctx.message.content)
await ctx.bot.get_channel(368477860387880960).send(embed=embed)
