async def get_response(bot, context):
response = Response()
if context.author.voice:
voice_channel = context.author.voice.channel
voice_client = await utilities.join_and_ready(bot, voice_channel)
options = {'format': 'bestaudio/best', 'noplaylist': True}
downloader = YoutubeDL(options)
url = context.arguments[0]
try:
file_location = data.get_from_cache(bot, None, url=url)
if not file_location:
logger.info("Not found in cache. Downloading...")
info = await utilities.future(downloader.extract_info,
url,
download=False)
download_url = info['formats'][0]['url']
file_location = await data.add_to_cache(bot,
download_url,
name=url)
ffmpeg_options = '-protocol_whitelist "file,http,https,tcp,tls"'
voice_client.play(
discord.FFmpegPCMAudio(file_location,
before_options=ffmpeg_options))
except BotException as e:
raise e # Pass up
except Exception as e:
raise CBException("Something bad happened.", e=e)
response.content = "Playing your stuff."
else:
raise CBException("You're not in a voice channel.")
return response
async def get_response(bot, context):
response = Response()
if context.author.voice:
voice_channel = context.author.voice.channel
voice_client = await utilities.join_and_ready(bot, voice_channel)
options = {'format': 'bestaudio/best', 'noplaylist': True}
downloader = YoutubeDL(options)
url = context.arguments[0]
try:
file_location = data.get_from_cache(bot, None, url=url)
if not file_location:
logger.info("Not found in cache. Downloading...")
info = await utilities.future(downloader.extract_info, url, download=False)
download_url = info['formats'][0]['url']
file_location = await data.add_to_cache(bot, download_url, name=url)
ffmpeg_options = '-protocol_whitelist "file,http,https,tcp,tls"'
voice_client.play(discord.FFmpegPCMAudio(file_location, before_options=ffmpeg_options))
except BotException as e:
raise e # Pass up
except Exception as e:
raise CBException("Something bad happened.", e=e)
response.content = "Playing your stuff."
else:
raise CBException("You're not in a voice channel.")
return response
async def add_to_cache(bot, url, name=None, file_location=None):
"""Downloads the URL and saves to the audio cache folder.
If the cache folder has surpassed the cache size, this will continually
remove the least used file (by date) until there is enough space. If the
downloaded file is more than half the size of the total cache, it will not
be stored. Returns the final location of the downloaded file.
If name is specified, it will be stored under that name instead of the url.
If file_location is specified, it will move that file instead of
downloading the URL.
"""
if file_location:
cleaned_name = utilities.get_cleaned_filename(file_location)
else:
file_location, cleaned_name = await utilities.download_url(bot, url, include_name=True)
if name:
cleaned_name = utilities.get_cleaned_filename(name)
try:
download_stat = os.stat(file_location)
except FileNotFoundError:
raise CBException("The audio could not be saved. Please try again later.")
cache_limit = configurations.get(bot, 'core', 'cache_size_limit') * 1000 * 1000
store = cache_limit > 0 and download_stat.st_size < cache_limit / 2
# Ensure that the target destination does not exist (remove it if it does)
if store:
cached_location = '{0}/audio_cache/{1}'.format(bot.path, cleaned_name)
else:
cached_location = '{}/temp/tempsound'.format(bot.path)
try:
os.remove(cached_location)
except: # Doesn't matter if file doesn't exist
pass
os.rename(file_location, cached_location)
os.utime(cached_location)
if store:
cache_entries = []
total_size = 0
for entry in os.scandir('{}/audio_cache'.format(bot.path)):
stat = entry.stat()
cache_entries.append((stat.st_atime, stat.st_size, entry.path))
total_size += stat.st_size
cache_entries.sort(reverse=True)
while total_size > cache_limit:
_, size, path = cache_entries.pop()
logger.info("Removing from cache: %s", path)
os.remove(path)
total_size -= size
else:
logger.info("Not storing %s. Download size: %s", file_location, download_stat.st_size)
try:
download_stat = os.stat(cached_location)
except FileNotFoundError:
raise CBException("The file was not moved properly.")
return cached_location
def shutdown(self):
logger.debug("Writing data on shutdown...")
if self.fresh_boot is not None: # Don't write blank data
self.save_data(force=True)
logger.info("Closing down!")
try:
self.loop.close()
except:
pass
sys.exit()
def shutdown(self):
logger.debug("Writing data on shutdown...")
if self.fresh_boot is not None: # Don't write blank data
self.save_data(force=True)
logger.info("Closing down!")
try:
self.loop.close()
except:
pass
logging.shutdown()
sys.exit()
def restore_backup(bot, backup_file):
"""Restores a backup file given the backup filename."""
logger.info("Restoring from a backup file...")
try:
core.bot_data = {'global_users': {}, 'global_plugins': {}}
core.volatile_data = {'global_users': {}, 'global_plugins': {}}
shutil.unpack_archive(backup_file, '{}/data'.format(bot.path))
data.check_all(bot)
data.load_data(bot)
except Exception as e:
raise CBException("Failed to extract backup.", e=e)
logger.info("Finished data restore.")
def restore_backup(bot, backup_file):
"""Restores a backup file given the backup filename."""
logger.info("Restoring from a backup file...")
try:
core.bot_data = {'global_users': {}, 'global_plugins': {}}
core.volatile_data = {'global_users': {}, 'global_plugins': {}}
shutil.unpack_archive(backup_file, '{}/data'.format(bot.path))
data.check_all(bot)
data.load_data(bot)
except Exception as e:
raise CBException("Failed to extract backup.", e=e)
logger.info("Finished data restore.")
async def _parse_command(
self, message, command, parameters, initial_data, elevation, direct):
"""Parses the command and builds a context."""
subcommand, options, arguments = await parser.parse(self, command, parameters, message)
context = self.Context(
message, command.base, subcommand, options, arguments,
subcommand.command.keywords, initial_data[0], elevation,
message.guild, message.channel, message.author, direct,
subcommand.index, subcommand.id, self)
plugins.broadcast_event(self, 'bot_on_command', context)
logger.info([subcommand, options, arguments])
return context
def __init__(self, path, debug):
self.version = '0.4.0-rewrite'
self.date = 'July 3rd, 2017'
self.time = int(time.time())
self.readable_time = time.strftime('%c')
self.path = path
self.debug = debug
logger.info("=== {0: ^40} ===".format("Starting up JshBot " +
self.version))
logger.info("=== {0: ^40} ===".format(self.readable_time))
super().__init__()
self.configurations = {}
plugins.add_configuration(self, 'core', 'core', base)
data.check_folders(self)
logger.debug("Connecting to database...")
self.db_templates = {}
self.db_connection = None
data.db_connect(self)
logger.debug("Loading plugins...")
self.data = {'global_users': {}, 'global_plugins': {}}
self.volatile_data = {'global_users': {}, 'global_plugins': {}}
self.data_changed = []
self.plugins = OrderedDict()
self.manuals = OrderedDict()
self.commands = {}
plugins.add_plugins(self)
config = self.configurations['core']
self.edit_dictionary = {}
self.spam_dictionary = {}
self.spam_limit = config['command_limit']
self.spam_timeout = config['command_limit_timeout']
self.command_invokers = config['command_invokers']
self.locked_commands = config['locked_commands']
self.edit_timeout = config['edit_timeout']
self.selfbot = config['selfbot_mode']
self.owners = config['owners']
self.schedule_timer = None
self.last_exception = None
self.last_traceback = None
self.last_response = None
self.fresh_boot = None
self.extra = None
# Extras
config['token'] = '(redacted)'
config['database_credentials'] = '(redacted)'
def make_backup(bot):
"""Makes a backup of the data directory."""
logger.info("Making backup...")
db_backup(bot)
backup_indices = '{0}/temp/backup{{}}.zip'.format(bot.path)
if os.path.isfile(backup_indices.format(5)):
os.remove(backup_indices.format(5))
for it in range(1, 5):
backup_file_from = backup_indices.format(5-it)
backup_file_to = backup_indices.format(6-it)
if os.path.isfile(backup_file_from):
os.rename(backup_file_from, backup_file_to)
shutil.make_archive(backup_indices.format(1)[:-4], 'zip', '{}/data'.format(bot.path))
logger.info("Finished making backup.")
def make_backup(bot):
"""Makes a backup of the data directory."""
logger.info("Making backup...")
db_backup(bot)
backup_indices = '{0}/temp/backup{{}}.zip'.format(bot.path)
if os.path.isfile(backup_indices.format(5)):
os.remove(backup_indices.format(5))
for it in range(1, 5):
backup_file_from = backup_indices.format(5 - it)
backup_file_to = backup_indices.format(6 - it)
if os.path.isfile(backup_file_from):
os.rename(backup_file_from, backup_file_to)
shutil.make_archive(
backup_indices.format(1)[:-4], 'zip', '{}/data'.format(bot.path))
logger.info("Finished making backup.")
def restore_db_backup(bot, tables=[]):
"""Restores a database dump backup file.
If tables is specified, this will restore those instead of the entire database.
"""
logger.info("Restoring database...")
try:
if tables:
specific_tables = '-t "' + '" -t "'.join(tables) + '"'
else:
specific_tables = ''
command = 'pg_restore -U postgres -d postgres {} /external/temp/db_dump'.format(specific_tables)
docker_send_command(command)
return docker_receive_exit_code()
except Exception as e:
raise CBException("Failed to restore backup.", e=e)
logger.info("Finished database restore.")
async def notify_owners(bot, message, user_id=None):
"""Sends all owners a direct message with the given text.
If user_id is specified, this will check that the user is not in the
blacklist.
"""
if bot.selfbot:
logger.info("Notification:\n{}".format(message))
else:
if user_id:
blacklist = data.get(bot, 'core', 'blacklist', default=[])
if user_id in blacklist:
await asyncio.sleep(0.5)
return
for owner in bot.owners:
member = data.get_member(bot, owner)
if len(message) > 1998:
await send_text_as_file(member, message, 'notification')
else:
await member.send(message)
def save_data(self, force=False):
if force:
logger.info("Forcing data save...")
else:
logger.info("Saving data...")
data.save_data(self, force=force)
logger.info("Save complete.")
def save_data(self, force=False):
if force:
logger.info("Forcing data save...")
else:
logger.info("Saving data...")
data.save_data(self, force=force)
logger.info("Save complete.")
async def notify_owners(bot, message, user_id=None):
"""Sends all owners a direct message with the given text.
If user_id is specified, this will check that the user is not in the
blacklist.
"""
if bot.selfbot:
logger.info("Owner notification:\n{}".format(message))
else:
if user_id:
blacklist = data.get(bot, 'core', 'blacklist', default=[])
if user_id in blacklist:
await asyncio.sleep(0.5)
return
for owner in bot.owners:
try:
member = data.get_member(bot, owner)
if len(message) > 1990:
await send_text_as_file(member, message, 'notification')
else:
await member.send(message)
except Exception as e:
logger.error("Failed to notify owner %s: %s", owner, e)
async def on_ready(bot):
logger.info("on_ready was called from dummy.py!")
def start(start_file=None, debug=False):
if start_file:
path = os.path.split(os.path.realpath(start_file))[0]
logger.debug("Setting directory to " + path)
else: # Use Docker setup
path = '/external'
logger.info("Bot running in Docker mode.")
logger.debug("Using Docker setup path, " + path)
try:
config_file_location = path + '/config/core-config.yaml'
with open(config_file_location, 'rb') as config_file:
config = yaml.load(config_file)
selfbot_mode, token = config['selfbot_mode'], config['token']
except Exception as e:
logger.error("Could not determine token /or selfbot mode.")
raise e
if selfbot_mode:
client_type = discord.Client
logger.debug("Using standard client (selfbot enabled).")
else:
client_type = discord.AutoShardedClient
logger.debug("Using autosharded client (selfbot disabled).")
if debug:
log_file = '{}/temp/logs.txt'.format(path)
if os.path.isfile(log_file):
shutil.copy2(log_file, '{}/temp/last_logs.txt'.format(path))
logging.basicConfig(level=logging.DEBUG,
handlers=[
RotatingFileHandler(log_file,
maxBytes=1000000,
backupCount=3),
logging.StreamHandler()
])
def safe_exit():
loop = asyncio.get_event_loop()
try: # From discord.py client.run
loop.run_until_complete(bot.logout())
pending = asyncio.Task.all_tasks()
gathered = asyncio.gather(*pending)
except Exception as e:
logger.error("Failed to log out. %s", e)
try:
gathered.cancel()
loop.run_until_complete(gathered)
gathered.exception()
except:
pass
logger.warn("Bot disconnected. Shutting down...")
bot.shutdown() # Calls sys.exit
def exception_handler(loop, context):
e = context.get('exception')
if e and e.__traceback__:
traceback_text = ''.join(traceback.format_tb(e.__traceback__))
else:
traceback_text = traceback.format_exc()
if not traceback_text:
traceback_text = '(No traceback available)'
error_message = '{}\n{}'.format(e, traceback_text)
logger.error("An uncaught exception occurred.\n" + error_message)
with open(path + '/temp/error.txt', 'w') as error_file:
error_file.write(error_message)
logger.error("Error file written.")
if bot.is_closed():
safe_exit()
loop = asyncio.get_event_loop()
bot = get_new_bot(client_type, path, debug)
start_task = bot.start(token, bot=not selfbot_mode)
loop.set_exception_handler(exception_handler)
try:
loop.run_until_complete(start_task)
except KeyboardInterrupt:
logger.warn("Interrupted!")
safe_exit()
def restart(self):
logger.info("Attempting to restart the bot...")
self.save_data(force=True)
asyncio.ensure_future(self.logout())
os.system('python3.5 ' + self.path + '/start.py')
async def on_ready(self):
if self.fresh_boot is None:
app_info = await self.application_info()
if app_info.owner.id not in self.owners:
self.owners.append(app_info.owner.id)
if self.selfbot: # Selfbot safety checks
if len(self.owners) != 1:
raise CBException(
"There can be only one owner for "
"a selfbot.",
error_type=ErrorTypes.STARTUP)
elif self.owners[0] != self.user.id:
raise CBException("Token does not match the owner.",
error_type=ErrorTypes.STARTUP)
# Start scheduler
asyncio.ensure_future(utilities._start_scheduler(self))
# Make sure guild data is ready
data.check_all(self)
data.load_data(self)
self.fresh_boot = True
plugins.broadcast_event(self, 'bot_on_ready_boot')
elif self.fresh_boot:
self.fresh_boot = False
if self.debug:
debug_channel = self.get_channel(
self.configurations['core']['debug_channel'])
if self.fresh_boot and debug_channel is not None:
log_file = '{}/temp/last_logs.txt'.format(self.path)
error_file = '{}/temp/error.txt'.format(self.path)
if not os.path.isfile(log_file):
await debug_channel.send(content="Started up fresh.")
else:
discord_file = discord.File(log_file)
await debug_channel.send(content="Logs:",
file=discord_file)
if not os.path.isfile(error_file):
await debug_channel.send(content="No error log.")
else:
discord_file = discord.File(error_file)
await debug_channel.send(content="Last error:",
file=discord_file)
elif debug_channel is not None:
await debug_channel.send("Reconnected.")
logger.info("=== {0: ^40} ===".format(self.user.name + ' online'))
if self.fresh_boot:
asyncio.ensure_future(self.spam_clear_loop())
asyncio.ensure_future(self.save_loop())
asyncio.ensure_future(self.backup_loop())
if self.selfbot:
asyncio.ensure_future(self.selfbot_away_loop())
elif len(self.guilds) == 0:
link = (
'https://discordapp.com/oauth2/authorize?&client_id={}'
'&scope=bot&permissions=8').format(app_info.id)
first_start_note = (
"It appears that this is the first time you are starting up the bot. "
"In order to have it function properly, you must add the bot to the "
"server with the specified debug channel. Invite link:\n{}\n\nIt is "
"highly recommended that you update the core using [{}botowner update] "
"to not only update the bot, but also add the core manual."
).format(link, self.command_invokers[0])
logger.info(first_start_note)
def __init__(self, path, debug, docker_mode):
self.version = core_version
self.date = core_date
self.time = int(time.time())
self.readable_time = time.strftime('%c')
self.path = path
self.debug = debug
self.docker_mode = docker_mode
logger.info("=== {0: ^40} ===".format("Starting up JshBot " + self.version))
logger.info("=== {0: ^40} ===".format(self.readable_time))
super().__init__()
self.configurations = {}
plugins.add_configuration(self, 'core', 'core', base)
data.check_folders(self)
logger.debug("Connecting to database...")
self.db_templates = {}
self.db_connection = None
data.db_connect(self)
logger.debug("Loading plugins...")
self.data = {'global_users': {}, 'global_plugins': {}}
self.volatile_data = {'global_users': {}, 'global_plugins': {}}
self.data_changed = []
self.tables_changed = []
self.dump_exclusions = []
self.plugins = OrderedDict()
self.manuals = OrderedDict()
self.commands = {}
self.event_functions = {}
plugins.add_plugins(self)
config = self.configurations['core']
self.edit_dictionary = {}
self.spam_dictionary = {}
self.spam_limit = config['command_limit']
self.spam_timeout = config['command_limit_timeout']
self.use_verbose_output = config['use_verbose_output']
self.exception_messages = config['exception_messages']
self.command_invokers = config['command_invokers']
self.locked_commands = config['locked_commands']
self.single_command = config['single_command']
self.edit_timeout = config['edit_timeout']
self.selfbot = config['selfbot_mode']
self.owners = config['owners']
self.schedule_timer = None
self.response_deque = deque(maxlen=50)
self.error_deque = deque(maxlen=50)
self.maintenance_message = ''
self.maintenance_mode = 0
self.last_exception = None
self.last_traceback = None
self.last_response = None
self.last_context = None
self.fresh_boot = None
self.ready = False
self.extra = None
# Extras
config['token'] = '(redacted)'
config['database_credentials'] = '(redacted)'
async def set_status_on_boot(bot):
"""Checks to see if the status was set previously."""
previous_status = data.get(bot, __name__, 'status')
if previous_status:
await bot.change_presence(activity=discord.Game(name=previous_status))
logger.info("Detected old status - setting it now!")
async def on_ready(self):
if self.fresh_boot is None:
if self.selfbot: # Selfbot safety checks
self.owners = [self.user.id]
else:
app_info = await self.application_info()
if app_info.owner.id not in self.owners:
self.owners.append(app_info.owner.id)
# Make sure guild data is ready
data.check_all(self)
data.load_data(self)
# Set single command notification
if self.single_command:
try:
command = self.commands[self.single_command]
except KeyError:
raise CBException(
"Invalid single command base.", error_type=ErrorTypes.STARTUP)
command.help_embed_fields.append((
'[Single command mode]',
'The base `{}` can be omitted when invoking these commands.'.format(
self.single_command)))
self.fresh_boot = True
self.ready = True
plugins.broadcast_event(self, 'bot_on_ready_boot')
# Start scheduler
asyncio.ensure_future(utilities._start_scheduler(self))
elif self.fresh_boot:
self.fresh_boot = False
if self.debug:
debug_channel = self.get_channel(
self.configurations['core']['debug_channel'])
if self.fresh_boot and debug_channel is not None:
log_file = '{}/temp/last_logs.txt'.format(self.path)
error_file = '{}/temp/error.txt'.format(self.path)
if not os.path.isfile(log_file):
await debug_channel.send(content="Started up fresh.")
else:
discord_file = discord.File(log_file, filename='last_logs.txt')
await debug_channel.send(content="Logs:", file=discord_file)
if not os.path.isfile(error_file):
await debug_channel.send(content="No error log.")
else:
discord_file = discord.File(error_file)
await debug_channel.send(content="Last error:", file=discord_file)
elif debug_channel is not None:
await debug_channel.send("Reconnected.")
logger.info("=== {0: ^40} ===".format(self.user.name + ' online'))
if self.fresh_boot:
asyncio.ensure_future(self.spam_clear_loop())
asyncio.ensure_future(self.save_loop())
asyncio.ensure_future(self.backup_loop())
if self.selfbot:
asyncio.ensure_future(self.selfbot_away_loop())
elif len(self.guilds) == 0:
link = (
'https://discordapp.com/oauth2/authorize?&client_id={}'
'&scope=bot&permissions=8').format(app_info.id)
first_start_note = (
"It appears that this is the first time you are starting up the bot. "
"In order to have it function properly, you must add the bot to the "
"server with the specified debug channel. Invite link:\n{}\n\nIt is "
"highly recommended that you update the core using [{}botowner update] "
"to not only update the bot, but also add the core manual.").format(
link, self.command_invokers[0])
logger.info(first_start_note)
async def on_message_edit(bot, before, after):
if (before.author != bot.user
and configurations.get(bot, __name__, key='show_edited_messages')):
logger.info(
"Somebody edited their message from '{0}' to '{1}'.".format(
before.content, after.content))
def restart(self):
logger.info("Attempting to restart the bot...")
self.save_data(force=True)
asyncio.ensure_future(self.logout())
os.system('python3.5 ' + self.path + '/start.py')
async def show_edits(bot, before, after):
if (before.author != bot.user and
configurations.get(bot, __name__, key='show_edited_messages')):
logger.info("Somebody edited their message from '{0}' to '{1}'.".format(
before.content, after.content))
async def on_message(self, message, replacement_message=None):
# Ensure bot can respond properly
try:
initial_data = self.can_respond(message)
except Exception as e: # General error
logger.error(e)
logger.error(traceback.format_exc())
self.last_exception = e
return
if not initial_data:
return
# Ensure command is valid
content = initial_data[0]
elevation = 3 - (initial_data[4:0:-1] + [True]).index(True)
split_content = content.split(' ', 1)
if len(split_content) == 1: # No spaces
split_content.append('')
base, parameters = split_content
base = base.lower()
try:
command = self.commands[base]
except KeyError:
logger.debug("Suitable command not found: " + base)
return
# Check that user is not spamming
author_id = message.author.id
direct = isinstance(message.channel, PrivateChannel)
spam_value = self.spam_dictionary.get(author_id, 0)
if elevation > 0 or direct: # Moderators ignore custom limit
spam_limit = self.spam_limit
else:
spam_limit = min(
self.spam_limit,
data.get(self,
'core',
'spam_limit',
guild_id=message.guild.id,
default=self.spam_limit))
if spam_value >= spam_limit:
if spam_value == spam_limit:
self.spam_dictionary[author_id] = spam_limit + 1
plugins.broadcast_event(self, 'bot_on_user_ratelimit',
message.author)
await self.send_message(
message.channel,
"{0}, you appear to be issuing/editing "
"commands too quickly. Please wait {1} seconds.".
format(message.author.mention, self.spam_timeout))
return
# Parse command and reply
try:
context = None
with message.channel.typing():
logger.debug(message.author.name + ': ' + message.content)
subcommand, options, arguments = parser.parse(
self, command, parameters, message)
context = self.Context(
message, base, subcommand, options, arguments,
subcommand.command.keywords, initial_data[0],
elevation, message.guild, message.channel,
message.author, direct, subcommand.index,
subcommand.id, self)
plugins.broadcast_event(self, 'bot_on_command', context)
logger.info([subcommand, options, arguments])
response = await commands.execute(self, context)
if response is None:
response = Response()
if self.selfbot and response.content:
response.content = '\u200b' + response.content
except Exception as e: # General error
response = Response()
destination = message.channel
message_reference = await self.handle_error(
e,
message,
context,
response,
edit=replacement_message,
command_editable=True)
else: # Attempt to respond
send_arguments = response.get_send_kwargs(replacement_message)
try:
destination = response.destination if response.destination else message.channel
message_reference = None
if replacement_message:
try:
await replacement_message.edit(**send_arguments)
message_reference = replacement_message
except discord.NotFound: # Message deleted
response = Response()
message_reference = None
elif (not response.is_empty() and
not (self.selfbot and
response.message_type is MessageTypes.REPLACE)):
message_reference = await destination.send(
**send_arguments)
response.message = message_reference
plugins.broadcast_event(self, 'bot_on_response', response,
context)
except Exception as e:
message_reference = await self.handle_error(
e,
message,
context,
response,
edit=replacement_message,
command_editable=True)
# Incremement the spam dictionary entry
if author_id in self.spam_dictionary:
self.spam_dictionary[author_id] += 1
else:
self.spam_dictionary[author_id] = 1
# MessageTypes:
# NORMAL - Normal. The issuing command can be edited.
# PERMANENT - Message is not added to the edit dictionary.
# REPLACE - Deletes the issuing command after 'extra' seconds. Defaults
# to 0 seconds if 'extra' is not given.
# ACTIVE - The message reference is passed back to the function defined
# with 'extra_function'. If 'extra_function' is not defined, it will call
# plugin.handle_active_message.
# INTERACTIVE - Assembles reaction buttons given by extra['buttons'] and
# calls 'extra_function' whenever one is pressed.
# WAIT - Wait for event. Calls 'extra_function' with the result, or None
# if the wait timed out.
#
# Only the NORMAL message type can be edited.
response.message = message_reference
if message_reference and isinstance(message_reference.channel,
PrivateChannel):
permissions = self.user.permissions_in(
message_reference.channel)
elif message_reference:
permissions = message_reference.guild.me.permissions_in(
message_reference.channel)
else:
permissions = None
self.last_response = message_reference
if response.message_type is MessageTypes.NORMAL:
# Edited commands are handled in base.py
if message_reference is None: # Forbidden exception
return
wait_time = self.edit_timeout
if wait_time:
self.edit_dictionary[str(message.id)] = message_reference
await asyncio.sleep(wait_time)
if str(message.id) in self.edit_dictionary:
del self.edit_dictionary[str(message.id)]
if message_reference.embeds:
embed = message_reference.embeds[0]
if embed.footer.text and embed.footer.text.startswith(
'\u200b' * 3):
embed.set_footer()
try:
await message_reference.edit(embed=embed)
except:
pass
elif response.message_type is MessageTypes.REPLACE:
try:
if self.selfbot and not replacement_message: # Edit instead
await message.edit(**send_arguments)
else:
if response.extra:
await asyncio.sleep(response.extra)
try:
await message.delete(reason='Automatic')
except: # Ignore permissions errors
pass
except Exception as e:
message_reference = await self.handle_error(
e, message, context, response, edit=message_reference)
self.last_response = message_reference
elif response.message_type is MessageTypes.ACTIVE:
if message_reference is None: # Forbidden exception
return
try:
await response.extra_function(self, context, response)
except Exception as e: # General error
message_reference = await self.handle_error(
e, message, context, response, edit=message_reference)
self.last_response = message_reference
elif response.message_type is MessageTypes.INTERACTIVE:
try:
buttons = response.extra['buttons']
kwargs = response.extra.get('kwargs', {})
if 'timeout' not in kwargs:
kwargs['timeout'] = 300
if 'check' not in kwargs:
kwargs['check'] = (lambda r, u: r.message.id ==
message_reference.id and not u.bot)
for button in buttons:
await message_reference.add_reaction(button)
reaction_check = await destination.get_message(
message_reference.id)
for reaction in reaction_check.reactions:
if not reaction.me or reaction.count > 1:
async for user in reaction.users():
if user != self.user and permissions.manage_messages:
asyncio.ensure_future(
message_reference.remove_reaction(
reaction, user))
await response.extra_function(self, context, response,
None, False)
process_result = True
while process_result is not False:
try:
if not permissions.manage_messages:
add_task = self.wait_for(
'reaction_add', **kwargs)
remove_task = self.wait_for(
'reaction_remove', **kwargs)
done, pending = await asyncio.wait(
[add_task, remove_task],
return_when=FIRST_COMPLETED)
result = next(iter(done)).result()
for future in pending:
future.cancel()
else: # Can remove reactions
result = await self.wait_for(
'reaction_add', **kwargs)
if result[1] != self.user:
asyncio.ensure_future(
message_reference.remove_reaction(
*result))
else:
continue
is_mod = data.is_mod(self, message.guild,
result[1].id)
if (response.extra.get('reactionlock', True)
and not result[0].me or
(response.extra.get('userlock', True) and
not (result[1] == message.author or is_mod))):
continue
except (asyncio.futures.TimeoutError,
asyncio.TimeoutError):
await response.extra_function(
self, context, response, None, True)
process_result = False
else:
process_result = await response.extra_function(
self, context, response, result, False)
try:
await response.message.clear_reactions()
except:
pass
except Exception as e:
message_reference = await self.handle_error(
e, message, context, response, edit=message_reference)
self.last_response = message_reference
elif response.message_type is MessageTypes.WAIT:
try:
kwargs = response.extra.get('kwargs', {})
if 'timeout' not in kwargs:
kwargs['timeout'] = 300
process_result = True
while process_result is not False:
try:
result = await self.wait_for(
response.extra['event'], **kwargs)
except asyncio.TimeoutError:
await response.extra_function(
self, context, response, None)
process_result = False
else:
process_result = await response.extra_function(
self, context, response, result)
if not response.extra.get('loop', False):
process_result = False
except Exception as e:
message_reference = await self.handle_error(
e, message, context, response, edit=message_reference)
self.last_response = message_reference
else:
logger.error("Unknown message type: {}".format(
response.message_type))
'''
async def demo_on_boot(bot):
"""This is called only once every time the bot is started (or reloaded)."""
logger.info("demo_on_boot was called from dummy.py!")