async def run_command(command: plugins.Command, message: discord.Message,
*cmd_args):
try:
await command.function(message, *cmd_args)
except AssertionError as e:
# user error
await message.channel.send(
str(e) or plugins.format_help(command, message.guild))
except:
# uncaught error
log.error(traceback.format_exc())
await message.channel.send("whoops, an unknown error occurred")
async def parse_command(command: plugins.Command, cmd_args: list,
message: discord.Message):
""" Try finding a command """
cmd_args = cmd_args[command.depth:]
send_help = False
# If the last argument ends with the help argument, skip parsing and display help
if len(cmd_args) > 1 and cmd_args[-1] in config.help_arg or (
command.disabled_pm
and isinstance(message.channel, discord.abc.PrivateChannel)):
complete = False
args, kwargs = [], {}
send_help = True
else:
# Parse the command and return the parsed arguments
args, kwargs, complete = await parse_command_args(
command, cmd_args, message)
# If command parsing failed, display help for the command or the error message
if not complete:
log_message(message) # Log the command
if command.disabled_pm and isinstance(message.channel,
discord.abc.PrivateChannel):
await client.say(
message,
"This command can not be executed in a private message.")
else:
if command.error and len(cmd_args) > 1 and not send_help:
await client.say(message, command.error)
else:
if len(cmd_args) == 1:
send_help = True
await client.say(
message,
plugins.format_help(
command,
message.guild,
no_subcommand=False if send_help else True))
command = None
return command, args, kwargs
async def execute_command(command: plugins.Command, message: discord.Message,
*args, **kwargs):
""" Execute a command and send any AttributeError exceptions. """
app_info = await client.application_info()
try:
await command.function(message, *args, **kwargs)
except AssertionError as e:
await client.say(
message,
str(e) or command.error
or plugins.format_help(command, message.server))
except:
traceback.print_exc()
if plugins.is_owner(message.author) and config.owner_error:
await client.say(message,
utils.format_code(traceback.format_exc()))
else:
await client.say(
message,
"An error occurred while executing this command. If the error persists, "
"please send a PM to {}.".format(app_info.owner))
async def help_(message: discord.Message, command: str.lower = None, *args):
""" Display commands or their usage and description. """
command_prefix = config.server_command_prefix(message.server)
# Display the specific command
if command:
if command.startswith(command_prefix):
command = command[len(command_prefix):]
cmd = plugins.get_command(command)
if not cmd:
return
# Get the specific command with arguments and send the help
cmd = plugins.get_sub_command(cmd, *args)
await client.say(message, plugins.format_help(cmd, message.server))
# Display every command
else:
commands = []
for plugin in plugins.all_values():
# Only go through plugins with actual commands
if not getattr(plugin, "__commands", False):
continue
# Add all commands that the user can use
for cmd in plugin.__commands:
if not cmd.hidden and plugins.can_use_command(
cmd, message.author, message.channel):
commands.append(cmd.name_prefix(message.server).split()[0])
commands = ", ".join(sorted(commands))
m = "**Commands**: ```{0}```Use `{1}help <command>`, `{1}<command> {2}` or " \
"`{1}<command> {3}` for command specific help.".format(
commands, command_prefix, *config.help_arg)
await client.say(message, m)
async def on_message(message: discord.Message):
""" What to do on any message received.
The bot will handle all commands in plugins and send on_message to plugins using it. """
# Make sure the client is ready before processing commands
await client.wait_until_ready()
start_time = datetime.utcnow()
# We don't care about channels we can't write in as the bot usually sends feedback
if message.server and message.server.owner and not message.server.me.permissions_in(
message.channel).send_messages:
return
# Don't accept commands from bot accounts
if message.author.bot:
return
# Find server specific settings
command_prefix = config.server_command_prefix(message.server)
case_sensitive = config.server_case_sensitive_commands(message.server)
# Split content into arguments by space (surround with quotes for spaces)
cmd_args = utils.split(message.content)
# Get command name
if cmd_args[0].startswith(command_prefix) and len(
cmd_args[0]) > len(command_prefix):
cmd = cmd_args[0][len(command_prefix):]
else:
return
# Try finding a command object
command = plugins.get_command(cmd, case_sensitive)
if not command:
return
# Check that the author is allowed to use the command
if not plugins.can_use_command(command, message):
return
# Parse the command with the user's arguments
try:
command = plugins.get_sub_command(command, *cmd_args[1:],
case_sensitive)
parsed_command, args, kwargs = await parse_command(
command, cmd_args, message)
except AssertionError as e: # Return any feedback given from the command via AssertionError, or the command help
await client.send_message(
message.channel,
str(e) or plugins.format_help(
command, message.server, no_subcommand=True))
log_message(message)
return
if not parsed_command:
return
# Log the command executed and execute said command
log_message(message)
client.loop.create_task(
execute_command(parsed_command, message, *args, **kwargs))
# Manually dispatch an event for when commands are requested
client.dispatch("command_requested", message, parsed_command, *args,
**kwargs)
# Log time spent parsing the command
stop_time = datetime.utcnow()
time_elapsed = (stop_time - start_time).total_seconds() / 1000
logging.debug("Time spent parsing command: {elapsed:.6f}ms".format(
elapsed=time_elapsed))
async def on_message(message: discord.Message):
""" What to do on any message received.
The bot will handle all commands in plugins and send on_message to plugins using it. """
# Make sure the client is ready before processing commands
await client.wait_until_ready()
start_time = datetime.utcnow()
# Make a local copy of the message since some attributes are changed and they shouldn't be overridden
# in plugin based on_message events
original_message = message
message = copy(message)
# We don't care about channels we can't write in as the bot usually sends feedback
if message.guild and message.guild.owner and not message.guild.me.permissions_in(
message.channel).send_messages:
return
# Don't accept commands from bot accounts
if message.author.bot:
return
# Find guild specific settings
command_prefix = config.guild_command_prefix(message.guild)
case_sensitive = config.guild_case_sensitive_commands(message.guild)
# Check that the message is a command
if not message.content.startswith(command_prefix):
return
# Remove the prefix and make sure that a command was actually specified
message.content = message.content[len(command_prefix):]
if not message.content or message.content.startswith(" "):
return
# Split content into arguments by space (surround with quotes for spaces)
cmd_args = utils.split(message.content)
# Try finding a command object using the command name (first argument)
command = plugins.get_command(cmd_args[0], case_sensitive=case_sensitive)
if not command:
return
try:
# Find the subcommand if there is one
command = plugins.get_sub_command(command,
*cmd_args[1:],
case_sensitive=case_sensitive)
# Check that the author is allowed to use the command
if not plugins.can_use_command(command, message.author,
message.channel):
return
# Parse the command with the user's arguments
parsed_command, args, kwargs = await parse_command(
command, cmd_args, message)
except AssertionError as e: # Return any feedback given from the command via AssertionError, or the command help
await client.send_message(
message.channel,
str(e)
or plugins.format_help(command, message.guild, no_subcommand=True))
log_message(message)
return
if not parsed_command:
return
# Log the command executed and execute said command
log_message(original_message)
client.loop.create_task(
execute_command(parsed_command, original_message, *args, **kwargs))
# Manually dispatch an event for when commands are requested
client.dispatch("command_requested", message, parsed_command, *args,
**kwargs)
# Log time spent parsing the command
stop_time = datetime.utcnow()
time_elapsed = (stop_time - start_time).total_seconds() * 1000
logging.debug("Time spent parsing command: {elapsed:.6f}ms".format(
elapsed=time_elapsed))
