async def reload(self, ctx, extension_name: str):
"""
{command_prefix}reload [extension]
Reloads an extension.
"""
loaded = [c.__module__.split(".")[1] for c in self.bot.cogs.values()]
unloaded = [c for c in _list_cogs()
if c not in loaded]
if extension_name.lower() not in _list_cogs():
return await ctx.send("This cog does not exist.")
if extension_name.lower() not in unloaded:
self.bot.unload_extension("cogs." + extension_name)
try:
self.bot.load_extension("cogs." + extension_name)
except Exception as e:
return await ctx.send(":x: {} have not been reloaded...```py\n{}: {}\n```".format(extension_name, type(e).__name__, str(e)))
return await ctx.send(":heavy_check_mark: {} reloaded !".format(extension_name))
async def unload(self, ctx, extension_name: str):
"""
{command_prefix}unload [extension]
Unloads an extension.
"""
if extension_name.lower() not in _list_cogs():
return await ctx.send("This cog is not loaded.")
if extension_name.lower() == self.__class__.__name__.lower():
return await ctx.send("This cog cannot be unloaded.")
self.bot.unload_extension("cogs." + extension_name.lower())
await ctx.send(":heavy_check_mark: {} unloaded !".format(extension_name.lower()))
async def unloadall(self, ctx):
"""
{command_prefix}unloadall
Unloads every extensions.
"""
msg = ""
cogs = _list_cogs()
for c in cogs:
self.bot.unload_extension("cogs." + c)
msg += (":heavy_check_mark: **{}** has been unloaded !\n".format(c))
return await ctx.send(msg)
async def reloadall(self, ctx):
"""
{command_prefix}reloadall
Reloads every extensions.
"""
msg = ""
loaded = [c.__module__.split(".")[1] for c in self.bot.cogs.values()]
unloaded = [c for c in _list_cogs()
if c not in loaded]
cogs = _list_cogs()
for c in cogs:
if c not in unloaded:
self.bot.unload_extension("cogs." + c)
try:
self.bot.load_extension("cogs." + c)
except Exception as e:
msg += (":x: **{}** have not been loaded... ``{}: {}``\n".format(c,
type(e).__name__, e))
continue
msg += (":heavy_check_mark: **{}** has been reloaded !\n".format(c))
return await ctx.send(msg)
async def _show_cogs(self, ctx):
"""
{command_prefix}cogs
Shows loaded/unloaded cogs.
"""
loaded = [c.__module__.split(".")[1] for c in self.bot.cogs.values()]
unloaded = [c for c in _list_cogs() if c not in loaded]
if not unloaded:
unloaded = ["None"]
msg = ("+ Loaded\n"
"{}\n\n"
"- Unloaded\n"
"{}"
"".format(", ".join(sorted(loaded)),
", ".join(sorted(unloaded))))
for page in pagify(msg, [" "], shorten_by=16):
await ctx.send(box(page.lstrip(" "), lang="diff"))
async def on_ready(self):
if self.init_ok:
return
# Store registred custom prefixes
prefix_servers = SettingsDB.get_instance(
).guild_settings_collection.find({
"$and": [{
"prefix": {
"$exists": True
}
}, {
"prefix": {
"$ne": globprefix
}
}]
})
async for server in prefix_servers:
self.prefixes_map[server["_id"]] = server["prefix"]
# Store registred custom languages
language_servers = SettingsDB.get_instance(
).guild_settings_collection.find({
"$and": [{
"language": {
"$exists": True
}
}, {
"language": {
"$ne": "english"
}
}]
})
async for lang in language_servers:
self.languages_map[lang["_id"]] = lang["language"]
# Store registred OwO mod
owo_servers = SettingsDB.get_instance().guild_settings_collection.find(
{"$and": [{
"owo": {
"$exists": True
}
}, {
"owo": {
"$ne": False
}
}]})
async for server in owo_servers:
self.owo_map[server["_id"]] = server["owo"]
# Store registred autosongs
autosongs_servers = SettingsDB.get_instance(
).guild_settings_collection.find({
"$and": [{
"autosongs": {
"$exists": True
}
}, {
"autosongs": {
"$ne": {}
}
}]
})
async for server in autosongs_servers:
self.autosongs_map[server["_id"]] = server["autosongs"]
# Multiprocessing guild count
self.owner_id = owner_id
self.config = await SettingsDB.get_instance().get_glob_settings()
if self.is_main_process and self.shard_count != len(
self.config.server_count):
self.config.server_count = {}
await SettingsDB.get_instance().set_glob_settings(self.config)
# Load cogs
for extension in _list_cogs():
try:
self.load_extension("cogs." + extension)
except Exception as e:
exc = '{}: {}'.format(type(e).__name__, e)
log.warning('Failed to load extension {}\n{}'.format(
extension, exc))
total_cogs = len(_list_cogs())
servers = len(self.guilds)
owner = await self.safe_fetch('user', owner_id) or str(owner_id)
log.info("-----------------")
log.info("{} ({})".format(str(self.user), str(self.user.id)))
log.info("{} server{}".format(servers, "s" if servers > 1 else ""))
log.info("{} shard{}".format(self.shard_count,
"s" if self.shard_count > 1 else ""))
log.info("Prefix: {}".format(globprefix))
log.info("Owner: {}".format(owner))
log.info("{}/{} active cogs with {} commands".format(
len(self.cogs), total_cogs, len(self.commands)))
log.info("-----------------")
if self.pipe and not self.pipe.closed:
self.pipe.send(1)
self.pipe.close()
# Disable all loggers
for name in ['launcher', 'lavalink', 'listenmoe']:
logger = logging.getLogger(name)
logger.disabled = not logger.disabled
self.init_ok = True
async def unload_all_cogs(self):
cogs = _list_cogs()
for c in cogs:
self.bot.unload_extension("cogs." + c)
