CopyBot/Red-DiscordBot
1
0
Fork 0
mirror of https://github.com/Cog-Creators/Red-DiscordBot.git synced 2025-11-06 03:08:55 -05:00
Code Issues Packages Projects Releases Wiki Activity

Rename bot.db as bot._config (#2967)

Browse Source 
* Rename `bot.db` as `bot._config`

  - Continues work towards strong version guarantees
  - Added methods for cog use for a few things which were previously
  only accessible via direct access.
  - Retained private use in a few internal use locations, though most
  methods were updated away from this.
  - Updated documentation for shared api token users

* changelog

* more detail

* docstring fixes

* Apparently, I forgot to commit something I had locally

  - + a copy/paste failue in the changelog

* *sigh*:

* *sigh*
This commit is contained in:
Michael H 2019-09-01 15:42:28 -04:00 committed by GitHub
parent d86cc7a854
commit 6075c5bde0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 321 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
changelog.d/2967.breaking.rst Normal file
View File

@ -0,0 +1,11 @@
The main bot config is no longer directly accessible to cogs. New methods have been added for use where this is concerned.
New methods for this include
- ``bot.get_shared_api_tokens``
- ``bot.set_shared_api_tokens``
- ``bot.get_embed_color``
- ``bot.get_embed_colour``
- ``bot.get_admin_roles``
- ``bot.get_admin_role_ids``
- ``bot.get_mod_roles``
- ``bot.get_mod_role_ids``

8
docs/framework_apikeys.rst
View File

@ -18,7 +18,7 @@ and when accessed in the code it should be done by
.. code-block:: python .. code-block:: python
await self.bot.db.api_tokens.get_raw("twitch", default={"client_id": None, "client_secret": None}) await self.bot.get_shared_api_keys("twitch")
Each service has its own dict of key, value pairs for each required key type. If there's only one key required then a name for the key is still required for storing and accessing. Each service has its own dict of key, value pairs for each required key type. If there's only one key required then a name for the key is still required for storing and accessing.
@ -30,7 +30,7 @@ and when accessed in the code it should be done by
.. code-block:: python .. code-block:: python
await self.bot.db.api_tokens.get_raw("youtube", default={"api_key": None}) await self.bot.get_shared_api_keys("youtube")
*********** ***********
@ -42,7 +42,7 @@ Basic Usage
class MyCog: class MyCog:
@commands.command() @commands.command()
async def youtube(self, ctx, user: str): async def youtube(self, ctx, user: str):
apikey = await self.bot.db.api_tokens.get_raw("youtube", default={"api_key": None}) youtube_keys = await self.bot.get_shared_api_keys("youtube")
if apikey["api_key"] is None: if youtube_keys.get("api_key") is None:
return await ctx.send("The YouTube API key has not been set.") return await ctx.send("The YouTube API key has not been set.")
# Use the API key to access content as you normally would # Use the API key to access content as you normally would

10
redbot/__main__.py
View File

@ -52,8 +52,8 @@ async def _get_prefix_and_token(red, indict):
:param indict: :param indict:
:return: :return:
""" """
indict["token"] = await red.db.token() indict["token"] = await red._config.token()
indict["prefix"] = await red.db.prefix() indict["prefix"] = await red._config.prefix()
def list_instances(): def list_instances():
@ -115,7 +115,7 @@ def main():
red = Red( red = Red(
cli_flags=cli_flags, description=description, dm_help=None, fetch_offline_members=True cli_flags=cli_flags, description=description, dm_help=None, fetch_offline_members=True
) )
loop.run_until_complete(red.maybe_update_config()) loop.run_until_complete(red._maybe_update_config())
init_global_checks(red) init_global_checks(red)
init_events(red, cli_flags) init_events(red, cli_flags)
@ -153,11 +153,11 @@ def main():
loop.run_until_complete(red.start(token, bot=True)) loop.run_until_complete(red.start(token, bot=True))
except discord.LoginFailure: except discord.LoginFailure:
log.critical("This token doesn't seem to be valid.") log.critical("This token doesn't seem to be valid.")
db_token = loop.run_until_complete(red.db.token()) db_token = loop.run_until_complete(red._config.token())
if db_token and not cli_flags.no_prompt: if db_token and not cli_flags.no_prompt:
print("\nDo you want to reset the token? (y/n)") print("\nDo you want to reset the token? (y/n)")
if confirm("> "): if confirm("> "):
loop.run_until_complete(red.db.token.set("")) loop.run_until_complete(red._config.token.set(""))
print("Token has been reset.") print("Token has been reset.")
except KeyboardInterrupt: except KeyboardInterrupt:
log.info("Keyboard interrupt detected. Quitting...") log.info("Keyboard interrupt detected. Quitting...")

33
redbot/cogs/audio/audio.py
View File

@ -296,7 +296,7 @@ class Audio(commands.Cog):
else: else:
dur = lavalink.utils.format_time(player.current.length) dur = lavalink.utils.format_time(player.current.length)
embed = discord.Embed( embed = discord.Embed(
colour=(await self._get_embed_colour(notify_channel)), colour=(await self.bot.get_embed_color(notify_channel)),
title=_("Now Playing"), title=_("Now Playing"),
description=description, description=description,
) )
@ -328,7 +328,8 @@ class Audio(commands.Cog):
if notify_channel: if notify_channel:
notify_channel = self.bot.get_channel(notify_channel) notify_channel = self.bot.get_channel(notify_channel)
embed = discord.Embed( embed = discord.Embed(
colour=(await self._get_embed_colour(notify_channel)), title=_("Queue ended.") colour=(await self.bot.get_embed_colour(notify_channel)),
title=_("Queue ended."),
) )
await notify_channel.send(embed=embed) await notify_channel.send(embed=embed)
@ -346,7 +347,7 @@ class Audio(commands.Cog):
if message_channel: if message_channel:
message_channel = self.bot.get_channel(message_channel) message_channel = self.bot.get_channel(message_channel)
embed = discord.Embed( embed = discord.Embed(
colour=(await self._get_embed_colour(message_channel)), colour=(await self.bot.get_embed_color(message_channel)),
title=_("Track Error"), title=_("Track Error"),
description="{}\n**[{}]({})**".format( description="{}\n**[{}]({})**".format(
extra, player.current.title, player.current.uri extra, player.current.title, player.current.uri
@ -3834,14 +3835,12 @@ class Audio(commands.Cog):
return False return False
async def _check_api_tokens(self): async def _check_api_tokens(self):
spotify = await self.bot.db.api_tokens.get_raw( spotify = await self.bot.get_shared_api_tokens("spotify")
"spotify", default={"client_id": "", "client_secret": ""} youtube = await self.bot.get_shared_api_tokens("youtube")
)
youtube = await self.bot.db.api_tokens.get_raw("youtube", default={"api_key": ""})
return { return {
"spotify_client_id": spotify["client_id"], "spotify_client_id": spotify.get("client_id", ""),
"spotify_client_secret": spotify["client_secret"], "spotify_client_secret": spotify.get("client_secret", ""),
"youtube_api": youtube["api_key"], "youtube_api": youtube.get("api_key", ""),
} }
async def _check_external(self): async def _check_external(self):
@ -4081,13 +4080,6 @@ class Audio(commands.Cog):
except discord.errors.NotFound: except discord.errors.NotFound:
pass pass
async def _get_embed_colour(self, channel: discord.abc.GuildChannel):
# Unfortunately we need this for when context is unavailable.
if await self.bot.db.guild(channel.guild).use_bot_color():
return channel.guild.me.color
else:
return self.bot.color
async def _get_eq_reaction(self, ctx, message, emoji): async def _get_eq_reaction(self, ctx, message, emoji):
try: try:
reaction, user = await self.bot.wait_for( reaction, user = await self.bot.wait_for(
@ -4323,10 +4315,9 @@ class Audio(commands.Cog):
return {"Authorization": "Basic %s" % auth_header.decode("ascii")} return {"Authorization": "Basic %s" % auth_header.decode("ascii")}
async def _request_token(self): async def _request_token(self):
self.client_id = await self.bot.db.api_tokens.get_raw("spotify", default={"client_id": ""}) tokens = await self.bot.get_shared_api_tokens("spotify")
self.client_secret = await self.bot.db.api_tokens.get_raw( self.client_id = tokens.get("client_id", "")
"spotify", default={"client_secret": ""} self.client_secret = tokens.get("client_secret", "")
)
payload = {"grant_type": "client_credentials"} payload = {"grant_type": "client_credentials"}
headers = self._make_token_auth( headers = self._make_token_auth(
self.client_id["client_id"], self.client_secret["client_secret"] self.client_id["client_id"], self.client_secret["client_secret"]

4
redbot/cogs/bank/bank.py
View File

@ -47,9 +47,9 @@ def check_global_setting_admin():
return True return True
if ctx.channel.permissions_for(author).manage_guild: if ctx.channel.permissions_for(author).manage_guild:
return True return True
admin_roles = set(await ctx.bot.db.guild(ctx.guild).admin_role()) admin_role_ids = await ctx.bot.get_admin_role_ids(ctx.guild.id)
for role in author.roles: for role in author.roles:
if role.id in admin_roles: if role.id in admin_role_ids:
return True return True
else: else:
return await ctx.bot.is_owner(author) return await ctx.bot.is_owner(author)

21
redbot/cogs/image/image.py
View File

@ -28,8 +28,9 @@ class Image(commands.Cog):
async def initialize(self) -> None: async def initialize(self) -> None:
"""Move the API keys from cog stored config to core bot config if they exist.""" """Move the API keys from cog stored config to core bot config if they exist."""
imgur_token = await self.settings.imgur_client_id() imgur_token = await self.settings.imgur_client_id()
if imgur_token is not None and "imgur" not in await self.bot.db.api_tokens(): if imgur_token is not None:
await self.bot.db.api_tokens.set_raw("imgur", value={"client_id": imgur_token}) if not await self.bot.get_shared_api_tokens("imgur"):
await self.bot.set_shared_api_tokens(client_id=imgur_token)
await self.settings.imgur_client_id.clear() await self.settings.imgur_client_id.clear()
@commands.group(name="imgur") @commands.group(name="imgur")
@ -48,7 +49,7 @@ class Image(commands.Cog):
""" """
url = self.imgur_base_url + "gallery/search/time/all/0" url = self.imgur_base_url + "gallery/search/time/all/0"
params = {"q": term} params = {"q": term}
imgur_client_id = await ctx.bot.db.api_tokens.get_raw("imgur", default=None) imgur_client_id = (await ctx.bot.get_shared_api_tokens("imgur")).get("client_id")
if not imgur_client_id: if not imgur_client_id:
await ctx.send( await ctx.send(
_( _(
@ -56,7 +57,7 @@ class Image(commands.Cog):
).format(prefix=ctx.prefix) ).format(prefix=ctx.prefix)
) )
return return
headers = {"Authorization": "Client-ID {}".format(imgur_client_id["client_id"])} headers = {"Authorization": "Client-ID {}".format(imgur_client_id)}
async with self.session.get(url, headers=headers, params=params) as search_get: async with self.session.get(url, headers=headers, params=params) as search_get:
data = await search_get.json() data = await search_get.json()
@ -101,7 +102,7 @@ class Image(commands.Cog):
await ctx.send_help() await ctx.send_help()
return return
imgur_client_id = await ctx.bot.db.api_tokens.get_raw("imgur", default=None) imgur_client_id = (await ctx.bot.get_shared_api_tokens("imgur")).get("client_id")
if not imgur_client_id: if not imgur_client_id:
await ctx.send( await ctx.send(
_( _(
@ -111,7 +112,7 @@ class Image(commands.Cog):
return return
links = [] links = []
headers = {"Authorization": "Client-ID {}".format(imgur_client_id["client_id"])} headers = {"Authorization": "Client-ID {}".format(imgur_client_id)}
url = self.imgur_base_url + "gallery/r/{}/{}/{}/0".format(subreddit, sort, window) url = self.imgur_base_url + "gallery/r/{}/{}/{}/0".format(subreddit, sort, window)
async with self.session.get(url, headers=headers) as sub_get: async with self.session.get(url, headers=headers) as sub_get:
@ -164,7 +165,7 @@ class Image(commands.Cog):
await ctx.send_help() await ctx.send_help()
return return
giphy_api_key = await ctx.bot.db.api_tokens.get_raw("GIPHY", default=None) giphy_api_key = (await ctx.bot.get_shared_api_tokens("GIPHY")).get("api_key")
if not giphy_api_key: if not giphy_api_key:
await ctx.send( await ctx.send(
_("An API key has not been set! Please set one with `{prefix}giphycreds`.").format( _("An API key has not been set! Please set one with `{prefix}giphycreds`.").format(
@ -174,7 +175,7 @@ class Image(commands.Cog):
return return
url = "http://api.giphy.com/v1/gifs/search?&api_key={}&q={}".format( url = "http://api.giphy.com/v1/gifs/search?&api_key={}&q={}".format(
giphy_api_key["api_key"], keywords giphy_api_key, keywords
) )
async with self.session.get(url) as r: async with self.session.get(url) as r:
@ -197,7 +198,7 @@ class Image(commands.Cog):
await ctx.send_help() await ctx.send_help()
return return
giphy_api_key = await ctx.bot.db.api_tokens.get_raw("GIPHY", default=None) giphy_api_key = (await ctx.bot.get_shared_api_tokens("GIPHY")).get("api_key")
if not giphy_api_key: if not giphy_api_key:
await ctx.send( await ctx.send(
_("An API key has not been set! Please set one with `{prefix}giphycreds`.").format( _("An API key has not been set! Please set one with `{prefix}giphycreds`.").format(
@ -207,7 +208,7 @@ class Image(commands.Cog):
return return
url = "http://api.giphy.com/v1/gifs/random?&api_key={}&tag={}".format( url = "http://api.giphy.com/v1/gifs/random?&api_key={}&tag={}".format(
giphy_api_key["api_key"], keywords giphy_api_key, keywords
) )
async with self.session.get(url) as r: async with self.session.get(url) as r:

18
redbot/cogs/streams/streams.py
View File

@ -82,27 +82,27 @@ class Streams(commands.Cog):
async def move_api_keys(self): async def move_api_keys(self):
"""Move the API keys from cog stored config to core bot config if they exist.""" """Move the API keys from cog stored config to core bot config if they exist."""
tokens = await self.db.tokens() tokens = await self.db.tokens()
youtube = await self.bot.db.api_tokens.get_raw("youtube", default={}) youtube = await self.bot.get_shared_api_tokens("youtube")
twitch = await self.bot.db.api_tokens.get_raw("twitch", default={}) twitch = await self.bot.get_shared_api_tokens("twitch")
for token_type, token in tokens.items(): for token_type, token in tokens.items():
if token_type == "YoutubeStream" and "api_key" not in youtube: if token_type == "YoutubeStream" and "api_key" not in youtube:
await self.bot.db.api_tokens.set_raw("youtube", value={"api_key": token}) await self.bot.set_shared_api_tokens("youtube", api_key=token)
if token_type == "TwitchStream" and "client_id" not in twitch: if token_type == "TwitchStream" and "client_id" not in twitch:
# Don't need to check Community since they're set the same # Don't need to check Community since they're set the same
await self.bot.db.api_tokens.set_raw("twitch", value={"client_id": token}) await self.bot.set_shared_api_tokens("twitch", client_id=token)
await self.db.tokens.clear() await self.db.tokens.clear()
@commands.command() @commands.command()
async def twitchstream(self, ctx: commands.Context, channel_name: str): async def twitchstream(self, ctx: commands.Context, channel_name: str):
"""Check if a Twitch channel is live.""" """Check if a Twitch channel is live."""
token = await self.bot.db.api_tokens.get_raw("twitch", default={"client_id": None}) token = (await self.bot.get_shared_api_tokens("twitch")).get("client_id")
stream = TwitchStream(name=channel_name, token=token) stream = TwitchStream(name=channel_name, token=token)
await self.check_online(ctx, stream) await self.check_online(ctx, stream)
@commands.command() @commands.command()
async def youtubestream(self, ctx: commands.Context, channel_id_or_name: str): async def youtubestream(self, ctx: commands.Context, channel_id_or_name: str):
"""Check if a YouTube channel is live.""" """Check if a YouTube channel is live."""
apikey = await self.bot.db.api_tokens.get_raw("youtube", default={"api_key": None}) apikey = await self.bot.get_shared_api_tokens("youtube")
is_name = self.check_name_or_id(channel_id_or_name) is_name = self.check_name_or_id(channel_id_or_name)
if is_name: if is_name:
stream = YoutubeStream(name=channel_id_or_name, token=apikey) stream = YoutubeStream(name=channel_id_or_name, token=apikey)
@ -273,7 +273,7 @@ class Streams(commands.Cog):
async def stream_alert(self, ctx: commands.Context, _class, channel_name): async def stream_alert(self, ctx: commands.Context, _class, channel_name):
stream = self.get_stream(_class, channel_name) stream = self.get_stream(_class, channel_name)
if not stream: if not stream:
token = await self.bot.db.api_tokens.get_raw(_class.token_name, default=None) token = await self.bot.get_shared_api_tokens(_class.token_name)
is_yt = _class.__name__ == "YoutubeStream" is_yt = _class.__name__ == "YoutubeStream"
if is_yt and not self.check_name_or_id(channel_name): if is_yt and not self.check_name_or_id(channel_name):
stream = _class(id=channel_name, token=token) stream = _class(id=channel_name, token=token)
@ -651,8 +651,8 @@ class Streams(commands.Cog):
pass pass
else: else:
raw_stream["_messages_cache"].append(msg) raw_stream["_messages_cache"].append(msg)
token = await self.bot.db.api_tokens.get_raw(_class.token_name, default=None) token = await self.bot.get_shared_api_tokens(_class.token_name)
if token is not None: if token:
raw_stream["token"] = token raw_stream["token"] = token
streams.append(_class(**raw_stream)) streams.append(_class(**raw_stream))

165
redbot/core/bot.py
View File

@ -6,7 +6,7 @@ from collections import Counter
from enum import Enum from enum import Enum
from importlib.machinery import ModuleSpec from importlib.machinery import ModuleSpec
from pathlib import Path from pathlib import Path
from typing import Optional, Union, List from typing import Optional, Union, List, Dict
import discord import discord
from discord.ext.commands import when_mentioned_or from discord.ext.commands import when_mentioned_or
@ -36,11 +36,11 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
def __init__(self, *args, cli_flags=None, bot_dir: Path = Path.cwd(), **kwargs): def __init__(self, *args, cli_flags=None, bot_dir: Path = Path.cwd(), **kwargs):
self._shutdown_mode = ExitCodes.CRITICAL self._shutdown_mode = ExitCodes.CRITICAL
self.db = Config.get_core_conf(force_registration=True) self._config = Config.get_core_conf(force_registration=False)
self._co_owners = cli_flags.co_owner self._co_owners = cli_flags.co_owner
self.rpc_enabled = cli_flags.rpc self.rpc_enabled = cli_flags.rpc
self._last_exception = None self._last_exception = None
self.db.register_global( self._config.register_global(
token=None, token=None,
prefix=[], prefix=[],
packages=[], packages=[],
@ -69,7 +69,7 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
schema_version=0, schema_version=0,
) )
self.db.register_guild( self._config.register_guild(
prefix=[], prefix=[],
whitelist=[], whitelist=[],
blacklist=[], blacklist=[],
@ -82,19 +82,19 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
autoimmune_ids=[], autoimmune_ids=[],
) )
self.db.register_user(embeds=None) self._config.register_user(embeds=None)
self.db.init_custom(CUSTOM_GROUPS, 2) self._config.init_custom(CUSTOM_GROUPS, 2)
self.db.register_custom(CUSTOM_GROUPS) self._config.register_custom(CUSTOM_GROUPS)
async def prefix_manager(bot, message): async def prefix_manager(bot, message):
if not cli_flags.prefix: if not cli_flags.prefix:
global_prefix = await bot.db.prefix() global_prefix = await bot._config.prefix()
else: else:
global_prefix = cli_flags.prefix global_prefix = cli_flags.prefix
if message.guild is None: if message.guild is None:
return global_prefix return global_prefix
server_prefix = await bot.db.guild(message.guild).prefix() server_prefix = await bot._config.guild(message.guild).prefix()
if cli_flags.mentionable: if cli_flags.mentionable:
return ( return (
when_mentioned_or(*server_prefix)(bot, message) when_mentioned_or(*server_prefix)(bot, message)
@ -117,10 +117,10 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
if "command_not_found" not in kwargs: if "command_not_found" not in kwargs:
kwargs["command_not_found"] = "Command {} not found.\n{}" kwargs["command_not_found"] = "Command {} not found.\n{}"
self.counter = Counter() self._counter = Counter()
self.uptime = None self._uptime = None
self.checked_time_accuracy = None self._checked_time_accuracy = None
self.color = discord.Embed.Empty # This is needed or color ends up 0x000000 self._color = discord.Embed.Empty # This is needed or color ends up 0x000000
self.main_dir = bot_dir self.main_dir = bot_dir
@ -134,16 +134,42 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
self._permissions_hooks: List[commands.CheckPredicate] = [] self._permissions_hooks: List[commands.CheckPredicate] = []
async def maybe_update_config(self): async def get_embed_color(self, location: discord.abc.Messageable) -> discord.Color:
"""
Get the embed color for a location.
Parameters
----------
location : `discord.abc.Messageable`
Returns
-------
discord.Color
"""
guild = getattr(location, "guild", None)
if (
guild
and await self._config.guild(guild).use_bot_color()
and not isinstance(location, discord.Member)
):
return guild.me.color
return self._color
get_embed_colour = get_embed_color
async def _maybe_update_config(self):
""" """
This should be run prior to loading cogs or connecting to discord. This should be run prior to loading cogs or connecting to discord.
""" """
schema_version = await self.db.schema_version() schema_version = await self._config.schema_version()
if schema_version == 0: if schema_version == 0:
await self._schema_0_to_1() await self._schema_0_to_1()
schema_version += 1 schema_version += 1
await self.db.schema_version.set(schema_version) await self._config.schema_version.set(schema_version)
async def _schema_0_to_1(self): async def _schema_0_to_1(self):
""" """
@ -151,7 +177,7 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
""" """
log.info("Begin updating guild configs to support multiple mod/admin roles") log.info("Begin updating guild configs to support multiple mod/admin roles")
all_guild_data = await self.db.all_guilds() all_guild_data = await self._config.all_guilds()
for guild_id, guild_data in all_guild_data.items(): for guild_id, guild_data in all_guild_data.items():
guild_obj = discord.Object(id=guild_id) guild_obj = discord.Object(id=guild_id)
mod_roles, admin_roles = [], [] mod_roles, admin_roles = [], []
@ -160,10 +186,10 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
if maybe_mod_role_id: if maybe_mod_role_id:
mod_roles.append(maybe_mod_role_id) mod_roles.append(maybe_mod_role_id)
await self.db.guild(guild_obj).mod_role.set(mod_roles) await self._config.guild(guild_obj).mod_role.set(mod_roles)
if maybe_admin_role_id: if maybe_admin_role_id:
admin_roles.append(maybe_admin_role_id) admin_roles.append(maybe_admin_role_id)
await self.db.guild(guild_obj).admin_role.set(admin_roles) await self._config.guild(guild_obj).admin_role.set(admin_roles)
log.info("Done updating guild configs to support multiple mod/admin roles") log.info("Done updating guild configs to support multiple mod/admin roles")
async def send_help_for( async def send_help_for(
@ -182,8 +208,8 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
:return: :return:
""" """
indict["owner_id"] = await self.db.owner() indict["owner_id"] = await self._config.owner()
i18n.set_locale(await self.db.locale()) i18n.set_locale(await self._config.locale())
async def embed_requested(self, channel, user, command=None) -> bool: async def embed_requested(self, channel, user, command=None) -> bool:
""" """
@ -203,47 +229,112 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
bool bool
:code:`True` if an embed is requested :code:`True` if an embed is requested
""" """
if isinstance(channel, discord.abc.PrivateChannel): if isinstance(channel, discord.abc.PrivateChannel) or (
user_setting = await self.db.user(user).embeds() command and command == self.get_command("help")
):
user_setting = await self._config.user(user).embeds()
if user_setting is not None: if user_setting is not None:
return user_setting return user_setting
else: else:
guild_setting = await self.db.guild(channel.guild).embeds() guild_setting = await self._config.guild(channel.guild).embeds()
if guild_setting is not None: if guild_setting is not None:
return guild_setting return guild_setting
global_setting = await self.db.embeds() global_setting = await self._config.embeds()
return global_setting return global_setting
async def is_owner(self, user): async def is_owner(self, user) -> bool:
if user.id in self._co_owners: if user.id in self._co_owners:
return True return True
return await super().is_owner(user) return await super().is_owner(user)
async def is_admin(self, member: discord.Member): async def is_admin(self, member: discord.Member) -> bool:
"""Checks if a member is an admin of their guild.""" """Checks if a member is an admin of their guild."""
try: try:
member_snowflakes = member._roles # DEP-WARN member_snowflakes = member._roles # DEP-WARN
for snowflake in await self.db.guild(member.guild).admin_role(): for snowflake in await self._config.guild(member.guild).admin_role():
if member_snowflakes.has(snowflake): # Dep-WARN if member_snowflakes.has(snowflake): # Dep-WARN
return True return True
except AttributeError: # someone passed a webhook to this except AttributeError: # someone passed a webhook to this
pass pass
return False return False
async def is_mod(self, member: discord.Member): async def is_mod(self, member: discord.Member) -> bool:
"""Checks if a member is a mod or admin of their guild.""" """Checks if a member is a mod or admin of their guild."""
try: try:
member_snowflakes = member._roles # DEP-WARN member_snowflakes = member._roles # DEP-WARN
for snowflake in await self.db.guild(member.guild).admin_role(): for snowflake in await self._config.guild(member.guild).admin_role():
if member_snowflakes.has(snowflake): # DEP-WARN if member_snowflakes.has(snowflake): # DEP-WARN
return True return True
for snowflake in await self.db.guild(member.guild).mod_role(): for snowflake in await self._config.guild(member.guild).mod_role():
if member_snowflakes.has(snowflake): # DEP-WARN if member_snowflakes.has(snowflake): # DEP-WARN
return True return True
except AttributeError: # someone passed a webhook to this except AttributeError: # someone passed a webhook to this
pass pass
return False return False
async def get_admin_roles(self, guild: discord.Guild) -> List[discord.Role]:
"""
Gets the admin roles for a guild.
"""
ret: List[discord.Role] = []
for snowflake in await self._config.guild(guild).admin_role():
r = guild.get_role(snowflake)
if r:
ret.append(r)
return ret
async def get_mod_roles(self, guild: discord.Guild) -> List[discord.Role]:
"""
Gets the mod roles for a guild.
"""
ret: List[discord.Role] = []
for snowflake in await self._config.guild(guild).mod_role():
r = guild.get_role(snowflake)
if r:
ret.append(r)
return ret
async def get_admin_role_ids(self, guild_id: int) -> List[int]:
"""
Gets the admin role ids for a guild id.
"""
return await self._config.guild(discord.Object(id=guild_id)).admin_role()
async def get_mod_role_ids(self, guild_id: int) -> List[int]:
"""
Gets the mod role ids for a guild id.
"""
return await self._config.guild(discord.Object(id=guild_id)).mod_role()
async def get_shared_api_tokens(self, service_name: str) -> Dict[str, str]:
"""
Gets the shared API tokens for a service
Parameters
----------
service_name: str
Returns
-------
Dict[str, str]
A Mapping of token names to tokens.
This mapping exists because some services have multiple tokens.
"""
return await self._config.api_tokens.get_raw(service_name, default={})
async def set_shared_api_tokens(self, service_name: str, **tokens: str):
"""
Sets shared API tokens for a service
In most cases, this should not be used. Users should instead be using the
``set api`` command
This will not clear existing values not specified.
"""
async with self._config.api_tokens.get_attr(service_name)() as method_abuse:
method_abuse.update(**tokens)
async def get_context(self, message, *, cls=commands.Context): async def get_context(self, message, *, cls=commands.Context):
return await super().get_context(message, cls=cls) return await super().get_context(message, cls=cls)
@ -269,15 +360,15 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
return os.listdir("cogs") return os.listdir("cogs")
async def save_packages_status(self, packages): async def save_packages_status(self, packages):
await self.db.packages.set(packages) await self._config.packages.set(packages)
async def add_loaded_package(self, pkg_name: str): async def add_loaded_package(self, pkg_name: str):
async with self.db.packages() as curr_pkgs: async with self._config.packages() as curr_pkgs:
if pkg_name not in curr_pkgs: if pkg_name not in curr_pkgs:
curr_pkgs.append(pkg_name) curr_pkgs.append(pkg_name)
async def remove_loaded_package(self, pkg_name: str): async def remove_loaded_package(self, pkg_name: str):
async with self.db.packages() as curr_pkgs: async with self._config.packages() as curr_pkgs:
while pkg_name in curr_pkgs: while pkg_name in curr_pkgs:
curr_pkgs.remove(pkg_name) curr_pkgs.remove(pkg_name)
@ -361,7 +452,7 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
else: else:
ids_to_check.append(author.id) ids_to_check.append(author.id)
immune_ids = await self.db.guild(guild).autoimmune_ids() immune_ids = await self._config.guild(guild).autoimmune_ids()
return any(i in immune_ids for i in ids_to_check) return any(i in immune_ids for i in ids_to_check)
@ -545,14 +636,14 @@ class RedBase(commands.GroupMixin, commands.bot.BotBase, RPCMixin): # pylint: d
Gets the users and channels to send to Gets the users and channels to send to
""" """
destinations = [] destinations = []
opt_outs = await self.db.owner_opt_out_list() opt_outs = await self._config.owner_opt_out_list()
for user_id in (self.owner_id, *self._co_owners): for user_id in (self.owner_id, *self._co_owners):
if user_id not in opt_outs: if user_id not in opt_outs:
user = self.get_user(user_id) user = self.get_user(user_id)
if user: if user:
destinations.append(user) destinations.append(user)
channel_ids = await self.db.extra_owner_destinations() channel_ids = await self._config.extra_owner_destinations()
for channel_id in channel_ids: for channel_id in channel_ids:
channel = self.get_channel(channel_id) channel = self.get_channel(channel_id)
if channel: if channel:

5
redbot/core/commands/context.py
View File

@ -175,10 +175,7 @@ class Context(commands.Context):
discord.Colour: discord.Colour:
The colour to be used The colour to be used
""" """
if self.guild and await self.bot.db.guild(self.guild).use_bot_color(): return await self.bot.get_embed_color(self)
return self.guild.me.color
else:
return self.bot.color
@property @property
def embed_color(self): def embed_color(self):

31
redbot/core/commands/help.py
View File

@ -94,7 +94,7 @@ class RedHelpFormatter:
await self.command_not_found(ctx, help_for) await self.command_not_found(ctx, help_for)
return return
except NoSubCommand as exc: except NoSubCommand as exc:
if await ctx.bot.db.help.verify_exists(): if await ctx.bot._config.help.verify_exists():
await self.subcommand_not_found(ctx, exc.last, exc.not_found) await self.subcommand_not_found(ctx, exc.last, exc.not_found)
return return
help_for = exc.last help_for = exc.last
@ -130,7 +130,7 @@ class RedHelpFormatter:
async def format_command_help(self, ctx: Context, obj: commands.Command): async def format_command_help(self, ctx: Context, obj: commands.Command):
send = await ctx.bot.db.help.verify_exists() send = await ctx.bot._config.help.verify_exists()
if not send: if not send:
async for _ in self.help_filter_func(ctx, (obj,), bypass_hidden=True): async for _ in self.help_filter_func(ctx, (obj,), bypass_hidden=True):
# This is a really lazy option for not # This is a really lazy option for not
@ -147,7 +147,7 @@ class RedHelpFormatter:
command = obj command = obj
description = command.description or "" description = command.description or ""
tagline = (await ctx.bot.db.help.tagline()) or self.get_default_tagline(ctx) tagline = (await ctx.bot._config.help.tagline()) or self.get_default_tagline(ctx)
signature = f"`Syntax: {ctx.clean_prefix}{command.qualified_name} {command.signature}`" signature = f"`Syntax: {ctx.clean_prefix}{command.qualified_name} {command.signature}`"
subcommands = None subcommands = None
@ -250,7 +250,7 @@ class RedHelpFormatter:
pages = [] pages = []
page_char_limit = await ctx.bot.db.help.page_char_limit() page_char_limit = await ctx.bot._config.help.page_char_limit()
field_groups = self.group_embed_fields(embed_dict["fields"], page_char_limit) field_groups = self.group_embed_fields(embed_dict["fields"], page_char_limit)
color = await ctx.embed_color() color = await ctx.embed_color()
@ -285,11 +285,11 @@ class RedHelpFormatter:
async def format_cog_help(self, ctx: Context, obj: commands.Cog): async def format_cog_help(self, ctx: Context, obj: commands.Cog):
coms = await self.get_cog_help_mapping(ctx, obj) coms = await self.get_cog_help_mapping(ctx, obj)
if not (coms or await ctx.bot.db.help.verify_exists()): if not (coms or await ctx.bot._config.help.verify_exists()):
return return
description = obj.help description = obj.help
tagline = (await ctx.bot.db.help.tagline()) or self.get_default_tagline(ctx) tagline = (await ctx.bot._config.help.tagline()) or self.get_default_tagline(ctx)
if await ctx.embed_requested(): if await ctx.embed_requested():
emb = {"embed": {"title": "", "description": ""}, "footer": {"text": ""}, "fields": []} emb = {"embed": {"title": "", "description": ""}, "footer": {"text": ""}, "fields": []}
@ -356,7 +356,7 @@ class RedHelpFormatter:
return return
description = ctx.bot.description or "" description = ctx.bot.description or ""
tagline = (await ctx.bot.db.help.tagline()) or self.get_default_tagline(ctx) tagline = (await ctx.bot._config.help.tagline()) or self.get_default_tagline(ctx)
if await ctx.embed_requested(): if await ctx.embed_requested():
@ -433,8 +433,8 @@ class RedHelpFormatter:
This does most of actual filtering. This does most of actual filtering.
""" """
show_hidden = bypass_hidden or await ctx.bot.db.help.show_hidden() show_hidden = bypass_hidden or await ctx.bot._config.help.show_hidden()
verify_checks = await ctx.bot.db.help.verify_checks() verify_checks = await ctx.bot._config.help.verify_checks()
# TODO: Settings for this in core bot db # TODO: Settings for this in core bot db
for obj in objects: for obj in objects:
@ -466,17 +466,17 @@ class RedHelpFormatter:
ret = await format_fuzzy_results(ctx, fuzzy_commands, embed=use_embeds) ret = await format_fuzzy_results(ctx, fuzzy_commands, embed=use_embeds)
if use_embeds: if use_embeds:
ret.set_author(name=f"{ctx.me.display_name} Help Menu", icon_url=ctx.me.avatar_url) ret.set_author(name=f"{ctx.me.display_name} Help Menu", icon_url=ctx.me.avatar_url)
tagline = (await ctx.bot.db.help.tagline()) or self.get_default_tagline(ctx) tagline = (await ctx.bot._config.help.tagline()) or self.get_default_tagline(ctx)
ret.set_footer(text=tagline) ret.set_footer(text=tagline)
await ctx.send(embed=ret) await ctx.send(embed=ret)
else: else:
await ctx.send(ret) await ctx.send(ret)
elif await ctx.bot.db.help.verify_exists(): elif await ctx.bot._config.help.verify_exists():
ret = T_("Help topic for *{command_name}* not found.").format(command_name=help_for) ret = T_("Help topic for *{command_name}* not found.").format(command_name=help_for)
if use_embeds: if use_embeds:
ret = discord.Embed(color=(await ctx.embed_color()), description=ret) ret = discord.Embed(color=(await ctx.embed_color()), description=ret)
ret.set_author(name=f"{ctx.me.display_name} Help Menu", icon_url=ctx.me.avatar_url) ret.set_author(name=f"{ctx.me.display_name} Help Menu", icon_url=ctx.me.avatar_url)
tagline = (await ctx.bot.db.help.tagline()) or self.get_default_tagline(ctx) tagline = (await ctx.bot._config.help.tagline()) or self.get_default_tagline(ctx)
ret.set_footer(text=tagline) ret.set_footer(text=tagline)
await ctx.send(embed=ret) await ctx.send(embed=ret)
else: else:
@ -492,7 +492,7 @@ class RedHelpFormatter:
if await ctx.embed_requested(): if await ctx.embed_requested():
ret = discord.Embed(color=(await ctx.embed_color()), description=ret) ret = discord.Embed(color=(await ctx.embed_color()), description=ret)
ret.set_author(name=f"{ctx.me.display_name} Help Menu", icon_url=ctx.me.avatar_url) ret.set_author(name=f"{ctx.me.display_name} Help Menu", icon_url=ctx.me.avatar_url)
tagline = (await ctx.bot.db.help.tagline()) or self.get_default_tagline(ctx) tagline = (await ctx.bot._config.help.tagline()) or self.get_default_tagline(ctx)
ret.set_footer(text=tagline) ret.set_footer(text=tagline)
await ctx.send(embed=ret) await ctx.send(embed=ret)
else: else:
@ -536,10 +536,11 @@ class RedHelpFormatter:
""" """
if not ( if not (
ctx.channel.permissions_for(ctx.me).add_reactions and await ctx.bot.db.help.use_menus() ctx.channel.permissions_for(ctx.me).add_reactions
and await ctx.bot._config.help.use_menus()
): ):
max_pages_in_guild = await ctx.bot.db.help.max_pages_in_guild() max_pages_in_guild = await ctx.bot._config.help.max_pages_in_guild()
destination = ctx.author if len(pages) > max_pages_in_guild else ctx destination = ctx.author if len(pages) > max_pages_in_guild else ctx
if embed: if embed:

2
redbot/core/commands/requires.py
View File

@ -125,7 +125,7 @@ class PrivilegeLevel(enum.IntEnum):
# The following is simply an optimised way to check if the user has the # The following is simply an optimised way to check if the user has the
# admin or mod role. # admin or mod role.
guild_settings = ctx.bot.db.guild(ctx.guild) guild_settings = ctx.bot._config.guild(ctx.guild)
member_snowflakes = ctx.author._roles # DEP-WARN member_snowflakes = ctx.author._roles # DEP-WARN
for snowflake in await guild_settings.admin_role(): for snowflake in await guild_settings.admin_role():

179
redbot/core/core_commands.py
View File

@ -223,8 +223,9 @@ class CoreLogic:
""" """
if prefixes: if prefixes:
prefixes = sorted(prefixes, reverse=True) prefixes = sorted(prefixes, reverse=True)
await self.bot.db.prefix.set(prefixes) await self.bot._config.prefix.set(prefixes)
return await self.bot.db.prefix() return prefixes
return await self.bot._config.prefix()
@classmethod @classmethod
async def _version_info(cls) -> Dict[str, str]: async def _version_info(cls) -> Dict[str, str]:
@ -248,14 +249,14 @@ class CoreLogic:
Invite URL. Invite URL.
""" """
app_info = await self.bot.application_info() app_info = await self.bot.application_info()
perms_int = await self.bot.db.invite_perm() perms_int = await self.bot._config.invite_perm()
permissions = discord.Permissions(perms_int) permissions = discord.Permissions(perms_int)
return discord.utils.oauth_url(app_info.id, permissions) return discord.utils.oauth_url(app_info.id, permissions)
@staticmethod @staticmethod
async def _can_get_invite_url(ctx): async def _can_get_invite_url(ctx):
is_owner = await ctx.bot.is_owner(ctx.author) is_owner = await ctx.bot.is_owner(ctx.author)
is_invite_public = await ctx.bot.db.invite_public() is_invite_public = await ctx.bot._config.invite_public()
return is_owner or is_invite_public return is_owner or is_invite_public
@ -285,7 +286,7 @@ class Core(commands.Cog, CoreLogic):
red_version = "[{}]({})".format(__version__, red_pypi) red_version = "[{}]({})".format(__version__, red_pypi)
app_info = await self.bot.application_info() app_info = await self.bot.application_info()
owner = app_info.owner owner = app_info.owner
custom_info = await self.bot.db.custom_info() custom_info = await self.bot._config.custom_info()
async with aiohttp.ClientSession() as session: async with aiohttp.ClientSession() as session:
async with session.get("{}/json".format(red_pypi)) as r: async with session.get("{}/json".format(red_pypi)) as r:
@ -343,12 +344,12 @@ class Core(commands.Cog, CoreLogic):
""" """
if ctx.invoked_subcommand is None: if ctx.invoked_subcommand is None:
text = _("Embed settings:\n\n") text = _("Embed settings:\n\n")
global_default = await self.bot.db.embeds() global_default = await self.bot._config.embeds()
text += _("Global default: {}\n").format(global_default) text += _("Global default: {}\n").format(global_default)
if ctx.guild: if ctx.guild:
guild_setting = await self.bot.db.guild(ctx.guild).embeds() guild_setting = await self.bot._config.guild(ctx.guild).embeds()
text += _("Guild setting: {}\n").format(guild_setting) text += _("Guild setting: {}\n").format(guild_setting)
user_setting = await self.bot.db.user(ctx.author).embeds() user_setting = await self.bot._config.user(ctx.author).embeds()
text += _("User setting: {}").format(user_setting) text += _("User setting: {}").format(user_setting)
await ctx.send(box(text)) await ctx.send(box(text))
@ -362,8 +363,8 @@ class Core(commands.Cog, CoreLogic):
or guild hasn't set a preference. The or guild hasn't set a preference. The
default is to use embeds. default is to use embeds.
""" """
current = await self.bot.db.embeds() current = await self.bot._config.embeds()
await self.bot.db.embeds.set(not current) await self.bot._config.embeds.set(not current)
await ctx.send( await ctx.send(
_("Embeds are now {} by default.").format(_("disabled") if current else _("enabled")) _("Embeds are now {} by default.").format(_("disabled") if current else _("enabled"))
) )
@ -383,7 +384,7 @@ class Core(commands.Cog, CoreLogic):
used for all commands done in a guild channel except used for all commands done in a guild channel except
for help commands. for help commands.
""" """
await self.bot.db.guild(ctx.guild).embeds.set(enabled) await self.bot._config.guild(ctx.guild).embeds.set(enabled)
if enabled is None: if enabled is None:
await ctx.send(_("Embeds will now fall back to the global setting.")) await ctx.send(_("Embeds will now fall back to the global setting."))
else: else:
@ -406,7 +407,7 @@ class Core(commands.Cog, CoreLogic):
used for all commands done in a DM with the bot, as used for all commands done in a DM with the bot, as
well as all help commands everywhere. well as all help commands everywhere.
""" """
await self.bot.db.user(ctx.author).embeds.set(enabled) await self.bot._config.user(ctx.author).embeds.set(enabled)
if enabled is None: if enabled is None:
await ctx.send(_("Embeds will now fall back to the global setting.")) await ctx.send(_("Embeds will now fall back to the global setting."))
else: else:
@ -454,8 +455,8 @@ class Core(commands.Cog, CoreLogic):
""" """
Define if the command should be accessible for the average user. Define if the command should be accessible for the average user.
""" """
if await self.bot.db.invite_public(): if await self.bot._config.invite_public():
await self.bot.db.invite_public.set(False) await self.bot._config.invite_public.set(False)
await ctx.send("The invite is now private.") await ctx.send("The invite is now private.")
return return
app_info = await self.bot.application_info() app_info = await self.bot.application_info()
@ -475,7 +476,7 @@ class Core(commands.Cog, CoreLogic):
"If you agree, you can type `{0}inviteset public yes`.".format(ctx.prefix) "If you agree, you can type `{0}inviteset public yes`.".format(ctx.prefix)
) )
else: else:
await self.bot.db.invite_public.set(True) await self.bot._config.invite_public.set(True)
await ctx.send("The invite command is now public.") await ctx.send("The invite command is now public.")
@inviteset.command() @inviteset.command()
@ -493,7 +494,7 @@ class Core(commands.Cog, CoreLogic):
Please note that you might need two factor authentification for\ Please note that you might need two factor authentification for\
some permissions. some permissions.
""" """
await self.bot.db.invite_perm.set(level) await self.bot._config.invite_perm.set(level)
await ctx.send("The new permissions level has been set.") await ctx.send("The new permissions level has been set.")
@commands.command() @commands.command()
@ -759,15 +760,15 @@ class Core(commands.Cog, CoreLogic):
if ctx.invoked_subcommand is None: if ctx.invoked_subcommand is None:
if ctx.guild: if ctx.guild:
guild = ctx.guild guild = ctx.guild
admin_role_ids = await ctx.bot.db.guild(ctx.guild).admin_role() admin_role_ids = await ctx.bot._config.guild(ctx.guild).admin_role()
admin_role_names = [r.name for r in guild.roles if r.id in admin_role_ids] admin_role_names = [r.name for r in guild.roles if r.id in admin_role_ids]
admin_roles_str = ( admin_roles_str = (
humanize_list(admin_role_names) if admin_role_names else "Not Set." humanize_list(admin_role_names) if admin_role_names else "Not Set."
) )
mod_role_ids = await ctx.bot.db.guild(ctx.guild).mod_role() mod_role_ids = await ctx.bot._config.guild(ctx.guild).mod_role()
mod_role_names = [r.name for r in guild.roles if r.id in mod_role_ids] mod_role_names = [r.name for r in guild.roles if r.id in mod_role_ids]
mod_roles_str = humanize_list(mod_role_names) if mod_role_names else "Not Set." mod_roles_str = humanize_list(mod_role_names) if mod_role_names else "Not Set."
prefixes = await ctx.bot.db.guild(ctx.guild).prefix() prefixes = await ctx.bot._config.guild(ctx.guild).prefix()
guild_settings = _("Admin roles: {admin}\nMod roles: {mod}\n").format( guild_settings = _("Admin roles: {admin}\nMod roles: {mod}\n").format(
admin=admin_roles_str, mod=mod_roles_str admin=admin_roles_str, mod=mod_roles_str
) )
@ -775,8 +776,8 @@ class Core(commands.Cog, CoreLogic):
guild_settings = "" guild_settings = ""
prefixes = None # This is correct. The below can happen in a guild. prefixes = None # This is correct. The below can happen in a guild.
if not prefixes: if not prefixes:
prefixes = await ctx.bot.db.prefix() prefixes = await ctx.bot._config.prefix()
locale = await ctx.bot.db.locale() locale = await ctx.bot._config.locale()
prefix_string = " ".join(prefixes) prefix_string = " ".join(prefixes)
settings = _( settings = _(
@ -800,7 +801,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Adds an admin role for this guild. Adds an admin role for this guild.
""" """
async with ctx.bot.db.guild(ctx.guild).admin_role() as roles: async with ctx.bot._config.guild(ctx.guild).admin_role() as roles:
if role.id in roles: if role.id in roles:
return await ctx.send(_("This role is already an admin role.")) return await ctx.send(_("This role is already an admin role."))
roles.append(role.id) roles.append(role.id)
@ -813,7 +814,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Adds a mod role for this guild. Adds a mod role for this guild.
""" """
async with ctx.bot.db.guild(ctx.guild).mod_role() as roles: async with ctx.bot._config.guild(ctx.guild).mod_role() as roles:
if role.id in roles: if role.id in roles:
return await ctx.send(_("This role is already a mod role.")) return await ctx.send(_("This role is already a mod role."))
roles.append(role.id) roles.append(role.id)
@ -826,7 +827,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Removes an admin role for this guild. Removes an admin role for this guild.
""" """
async with ctx.bot.db.guild(ctx.guild).admin_role() as roles: async with ctx.bot._config.guild(ctx.guild).admin_role() as roles:
if role.id not in roles: if role.id not in roles:
return await ctx.send(_("That role was not an admin role to begin with.")) return await ctx.send(_("That role was not an admin role to begin with."))
roles.remove(role.id) roles.remove(role.id)
@ -839,7 +840,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Removes a mod role for this guild. Removes a mod role for this guild.
""" """
async with ctx.bot.db.guild(ctx.guild).mod_role() as roles: async with ctx.bot._config.guild(ctx.guild).mod_role() as roles:
if role.id not in roles: if role.id not in roles:
return await ctx.send(_("That role was not a mod role to begin with.")) return await ctx.send(_("That role was not a mod role to begin with."))
roles.remove(role.id) roles.remove(role.id)
@ -855,8 +856,8 @@ class Core(commands.Cog, CoreLogic):
Default is to not use the bot's configured colour, in which case the Default is to not use the bot's configured colour, in which case the
colour used will be the colour of the bot's top role. colour used will be the colour of the bot's top role.
""" """
current_setting = await ctx.bot.db.guild(ctx.guild).use_bot_color() current_setting = await ctx.bot._config.guild(ctx.guild).use_bot_color()
await ctx.bot.db.guild(ctx.guild).use_bot_color.set(not current_setting) await ctx.bot._config.guild(ctx.guild).use_bot_color.set(not current_setting)
await ctx.send( await ctx.send(
_("The bot {} use its configured color for embeds.").format( _("The bot {} use its configured color for embeds.").format(
_("will not") if current_setting else _("will") _("will not") if current_setting else _("will")
@ -872,8 +873,8 @@ class Core(commands.Cog, CoreLogic):
Default is for fuzzy command search to be disabled. Default is for fuzzy command search to be disabled.
""" """
current_setting = await ctx.bot.db.guild(ctx.guild).fuzzy() current_setting = await ctx.bot._config.guild(ctx.guild).fuzzy()
await ctx.bot.db.guild(ctx.guild).fuzzy.set(not current_setting) await ctx.bot._config.guild(ctx.guild).fuzzy.set(not current_setting)
await ctx.send( await ctx.send(
_("Fuzzy command search has been {} for this server.").format( _("Fuzzy command search has been {} for this server.").format(
_("disabled") if current_setting else _("enabled") _("disabled") if current_setting else _("enabled")
@ -888,8 +889,8 @@ class Core(commands.Cog, CoreLogic):
Default is for fuzzy command search to be disabled. Default is for fuzzy command search to be disabled.
""" """
current_setting = await ctx.bot.db.fuzzy() current_setting = await ctx.bot._config.fuzzy()
await ctx.bot.db.fuzzy.set(not current_setting) await ctx.bot._config.fuzzy.set(not current_setting)
await ctx.send( await ctx.send(
_("Fuzzy command search has been {} in DMs.").format( _("Fuzzy command search has been {} in DMs.").format(
_("disabled") if current_setting else _("enabled") _("disabled") if current_setting else _("enabled")
@ -907,11 +908,11 @@ class Core(commands.Cog, CoreLogic):
https://discordpy.readthedocs.io/en/stable/ext/commands/api.html#discord.ext.commands.ColourConverter https://discordpy.readthedocs.io/en/stable/ext/commands/api.html#discord.ext.commands.ColourConverter
""" """
if colour is None: if colour is None:
ctx.bot.color = discord.Color.red() ctx.bot._color = discord.Color.red()
await ctx.bot.db.color.set(discord.Color.red().value) await ctx.bot._config.color.set(discord.Color.red().value)
return await ctx.send(_("The color has been reset.")) return await ctx.send(_("The color has been reset."))
ctx.bot.color = colour ctx.bot._color = colour
await ctx.bot.db.color.set(colour.value) await ctx.bot._config.color.set(colour.value)
await ctx.send(_("The color has been set.")) await ctx.send(_("The color has been set."))
@_set.command() @_set.command()
@ -1076,11 +1077,11 @@ class Core(commands.Cog, CoreLogic):
async def serverprefix(self, ctx: commands.Context, *prefixes: str): async def serverprefix(self, ctx: commands.Context, *prefixes: str):
"""Sets Red's server prefix(es)""" """Sets Red's server prefix(es)"""
if not prefixes: if not prefixes:
await ctx.bot.db.guild(ctx.guild).prefix.set([]) await ctx.bot._config.guild(ctx.guild).prefix.set([])
await ctx.send(_("Guild prefixes have been reset.")) await ctx.send(_("Guild prefixes have been reset."))
return return
prefixes = sorted(prefixes, reverse=True) prefixes = sorted(prefixes, reverse=True)
await ctx.bot.db.guild(ctx.guild).prefix.set(prefixes) await ctx.bot._config.guild(ctx.guild).prefix.set(prefixes)
await ctx.send(_("Prefix set.")) await ctx.send(_("Prefix set."))
@_set.command() @_set.command()
@ -1098,7 +1099,7 @@ class Core(commands.Cog, CoreLogic):
locale_list = [loc.stem.lower() for loc in list(red_path.glob("**/*.po"))] locale_list = [loc.stem.lower() for loc in list(red_path.glob("**/*.po"))]
if locale_name.lower() in locale_list or locale_name.lower() == "en-us": if locale_name.lower() in locale_list or locale_name.lower() == "en-us":
i18n.set_locale(locale_name) i18n.set_locale(locale_name)
await ctx.bot.db.locale.set(locale_name) await ctx.bot._config.locale.set(locale_name)
await ctx.send(_("Locale has been set.")) await ctx.send(_("Locale has been set."))
else: else:
await ctx.send( await ctx.send(
@ -1119,11 +1120,11 @@ class Core(commands.Cog, CoreLogic):
`[My link](https://example.com)` `[My link](https://example.com)`
""" """
if not text: if not text:
await ctx.bot.db.custom_info.clear() await ctx.bot._config.custom_info.clear()
await ctx.send(_("The custom text has been cleared.")) await ctx.send(_("The custom text has been cleared."))
return return
if len(text) <= 1024: if len(text) <= 1024:
await ctx.bot.db.custom_info.set(text) await ctx.bot._config.custom_info.set(text)
await ctx.send(_("The custom text has been set.")) await ctx.send(_("The custom text has been set."))
await ctx.invoke(self.info) await ctx.invoke(self.info)
else: else:
@ -1144,7 +1145,7 @@ class Core(commands.Cog, CoreLogic):
""" """
if ctx.channel.permissions_for(ctx.me).manage_messages: if ctx.channel.permissions_for(ctx.me).manage_messages:
await ctx.message.delete() await ctx.message.delete()
await ctx.bot.db.api_tokens.set_raw(service, value=tokens) await ctx.bot._config.api_tokens.set_raw(service, value=tokens)
await ctx.send(_("`{service}` API tokens have been set.").format(service=service)) await ctx.send(_("`{service}` API tokens have been set.").format(service=service))
@commands.group() @commands.group()
@ -1163,8 +1164,8 @@ class Core(commands.Cog, CoreLogic):
Using this without a setting will toggle. Using this without a setting will toggle.
""" """
if use_menus is None: if use_menus is None:
use_menus = not await ctx.bot.db.help.use_menus() use_menus = not await ctx.bot._config.help.use_menus()
await ctx.bot.db.help.use_menus.set(use_menus) await ctx.bot._config.help.use_menus.set(use_menus)
if use_menus: if use_menus:
await ctx.send(_("Help will use menus.")) await ctx.send(_("Help will use menus."))
else: else:
@ -1179,8 +1180,8 @@ class Core(commands.Cog, CoreLogic):
Using this without a setting will toggle. Using this without a setting will toggle.
""" """
if show_hidden is None: if show_hidden is None:
show_hidden = not await ctx.bot.db.help.show_hidden() show_hidden = not await ctx.bot._config.help.show_hidden()
await ctx.bot.db.help.show_hidden.set(show_hidden) await ctx.bot._config.help.show_hidden.set(show_hidden)
if show_hidden: if show_hidden:
await ctx.send(_("Help will not filter hidden commands")) await ctx.send(_("Help will not filter hidden commands"))
else: else:
@ -1196,8 +1197,8 @@ class Core(commands.Cog, CoreLogic):
Using this without a setting will toggle. Using this without a setting will toggle.
""" """
if verify is None: if verify is None:
verify = not await ctx.bot.db.help.verify_checks() verify = not await ctx.bot._config.help.verify_checks()
await ctx.bot.db.help.verify_checks.set(verify) await ctx.bot._config.help.verify_checks.set(verify)
if verify: if verify:
await ctx.send(_("Help will only show for commands which can be run.")) await ctx.send(_("Help will only show for commands which can be run."))
else: else:
@ -1215,8 +1216,8 @@ class Core(commands.Cog, CoreLogic):
Using this without a setting will toggle. Using this without a setting will toggle.
""" """
if verify is None: if verify is None:
verify = not await ctx.bot.db.help.verify_exists() verify = not await ctx.bot._config.help.verify_exists()
await ctx.bot.db.help.verify_exists.set(verify) await ctx.bot._config.help.verify_exists.set(verify)
if verify: if verify:
await ctx.send(_("Help will verify the existence of help topics.")) await ctx.send(_("Help will verify the existence of help topics."))
else: else:
@ -1243,7 +1244,7 @@ class Core(commands.Cog, CoreLogic):
await ctx.send(_("You must give a positive value!")) await ctx.send(_("You must give a positive value!"))
return return
await ctx.bot.db.help.page_char_limit.set(limit) await ctx.bot._config.help.page_char_limit.set(limit)
await ctx.send(_("Done. The character limit per page has been set to {}.").format(limit)) await ctx.send(_("Done. The character limit per page has been set to {}.").format(limit))
@helpset.command(name="maxpages") @helpset.command(name="maxpages")
@ -1262,7 +1263,7 @@ class Core(commands.Cog, CoreLogic):
await ctx.send(_("You must give a value of zero or greater!")) await ctx.send(_("You must give a value of zero or greater!"))
return return
await ctx.bot.db.help.max_pages_in_guild.set(pages) await ctx.bot._config.help.max_pages_in_guild.set(pages)
await ctx.send(_("Done. The page limit has been set to {}.").format(pages)) await ctx.send(_("Done. The page limit has been set to {}.").format(pages))
@helpset.command(name="tagline") @helpset.command(name="tagline")
@ -1274,7 +1275,7 @@ class Core(commands.Cog, CoreLogic):
specified, the default will be used instead. specified, the default will be used instead.
""" """
if tagline is None: if tagline is None:
await ctx.bot.db.help.tagline.set("") await ctx.bot._config.help.tagline.set("")
return await ctx.send(_("The tagline has been reset.")) return await ctx.send(_("The tagline has been reset."))
if len(tagline) > 2048: if len(tagline) > 2048:
@ -1286,7 +1287,7 @@ class Core(commands.Cog, CoreLogic):
) )
return return
await ctx.bot.db.help.tagline.set(tagline) await ctx.bot._config.help.tagline.set(tagline)
await ctx.send(_("The tagline has been set to {}.").format(tagline[:1900])) await ctx.send(_("The tagline has been set to {}.").format(tagline[:1900]))
@commands.command() @commands.command()
@ -1393,7 +1394,7 @@ class Core(commands.Cog, CoreLogic):
footer += _(" | Server ID: {}").format(guild.id) footer += _(" | Server ID: {}").format(guild.id)
# We need to grab the DM command prefix (global) # We need to grab the DM command prefix (global)
# Since it can also be set through cli flags, bot.db is not a reliable # Since it can also be set through cli flags, bot._config is not a reliable
# source. So we'll just mock a DM message instead. # source. So we'll just mock a DM message instead.
fake_message = namedtuple("Message", "guild") fake_message = namedtuple("Message", "guild")
prefixes = await ctx.bot.command_prefix(ctx.bot, fake_message(guild=None)) prefixes = await ctx.bot.command_prefix(ctx.bot, fake_message(guild=None))
@ -1417,24 +1418,24 @@ class Core(commands.Cog, CoreLogic):
send_embed = None send_embed = None
if is_dm: if is_dm:
send_embed = await ctx.bot.db.user(destination).embeds() send_embed = await ctx.bot._config.user(destination).embeds()
else: else:
if not destination.permissions_for(destination.guild.me).send_messages: if not destination.permissions_for(destination.guild.me).send_messages:
continue continue
if destination.permissions_for(destination.guild.me).embed_links: if destination.permissions_for(destination.guild.me).embed_links:
send_embed = await ctx.bot.db.guild(destination.guild).embeds() send_embed = await ctx.bot._config.guild(destination.guild).embeds()
else: else:
send_embed = False send_embed = False
if send_embed is None: if send_embed is None:
send_embed = await ctx.bot.db.embeds() send_embed = await ctx.bot._config.embeds()
if send_embed: if send_embed:
if not is_dm and await self.bot.db.guild(destination.guild).use_bot_color(): if not is_dm:
color = destination.guild.me.color color = await ctx.bot.get_embed_color(destination)
else: else:
color = ctx.bot.color color = ctx.bot._color
e = discord.Embed(colour=color, description=message) e = discord.Embed(colour=color, description=message)
if author.avatar_url: if author.avatar_url:
@ -1608,7 +1609,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Adds a user to the whitelist. Adds a user to the whitelist.
""" """
async with ctx.bot.db.whitelist() as curr_list: async with ctx.bot._config.whitelist() as curr_list:
if user.id not in curr_list: if user.id not in curr_list:
curr_list.append(user.id) curr_list.append(user.id)
@ -1619,7 +1620,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Lists whitelisted users. Lists whitelisted users.
""" """
curr_list = await ctx.bot.db.whitelist() curr_list = await ctx.bot._config.whitelist()
msg = _("Whitelisted Users:") msg = _("Whitelisted Users:")
for user in curr_list: for user in curr_list:
@ -1635,7 +1636,7 @@ class Core(commands.Cog, CoreLogic):
""" """
removed = False removed = False
async with ctx.bot.db.whitelist() as curr_list: async with ctx.bot._config.whitelist() as curr_list:
if user.id in curr_list: if user.id in curr_list:
removed = True removed = True
curr_list.remove(user.id) curr_list.remove(user.id)
@ -1650,7 +1651,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Clears the whitelist. Clears the whitelist.
""" """
await ctx.bot.db.whitelist.set([]) await ctx.bot._config.whitelist.set([])
await ctx.send(_("Whitelist has been cleared.")) await ctx.send(_("Whitelist has been cleared."))
@commands.group() @commands.group()
@ -1670,7 +1671,7 @@ class Core(commands.Cog, CoreLogic):
await ctx.send(_("You cannot blacklist an owner!")) await ctx.send(_("You cannot blacklist an owner!"))
return return
async with ctx.bot.db.blacklist() as curr_list: async with ctx.bot._config.blacklist() as curr_list:
if user.id not in curr_list: if user.id not in curr_list:
curr_list.append(user.id) curr_list.append(user.id)
@ -1681,7 +1682,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Lists blacklisted users. Lists blacklisted users.
""" """
curr_list = await ctx.bot.db.blacklist() curr_list = await ctx.bot._config.blacklist()
msg = _("Blacklisted Users:") msg = _("Blacklisted Users:")
for user in curr_list: for user in curr_list:
@ -1697,7 +1698,7 @@ class Core(commands.Cog, CoreLogic):
""" """
removed = False removed = False
async with ctx.bot.db.blacklist() as curr_list: async with ctx.bot._config.blacklist() as curr_list:
if user.id in curr_list: if user.id in curr_list:
removed = True removed = True
curr_list.remove(user.id) curr_list.remove(user.id)
@ -1712,7 +1713,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Clears the blacklist. Clears the blacklist.
""" """
await ctx.bot.db.blacklist.set([]) await ctx.bot._config.blacklist.set([])
await ctx.send(_("Blacklist has been cleared.")) await ctx.send(_("Blacklist has been cleared."))
@commands.group() @commands.group()
@ -1732,7 +1733,7 @@ class Core(commands.Cog, CoreLogic):
Adds a user or role to the whitelist. Adds a user or role to the whitelist.
""" """
user = isinstance(user_or_role, discord.Member) user = isinstance(user_or_role, discord.Member)
async with ctx.bot.db.guild(ctx.guild).whitelist() as curr_list: async with ctx.bot._config.guild(ctx.guild).whitelist() as curr_list:
if user_or_role.id not in curr_list: if user_or_role.id not in curr_list:
curr_list.append(user_or_role.id) curr_list.append(user_or_role.id)
@ -1746,7 +1747,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Lists whitelisted users and roles. Lists whitelisted users and roles.
""" """
curr_list = await ctx.bot.db.guild(ctx.guild).whitelist() curr_list = await ctx.bot._config.guild(ctx.guild).whitelist()
msg = _("Whitelisted Users and roles:") msg = _("Whitelisted Users and roles:")
for obj in curr_list: for obj in curr_list:
@ -1765,7 +1766,7 @@ class Core(commands.Cog, CoreLogic):
user = isinstance(user_or_role, discord.Member) user = isinstance(user_or_role, discord.Member)
removed = False removed = False
async with ctx.bot.db.guild(ctx.guild).whitelist() as curr_list: async with ctx.bot._config.guild(ctx.guild).whitelist() as curr_list:
if user_or_role.id in curr_list: if user_or_role.id in curr_list:
removed = True removed = True
curr_list.remove(user_or_role.id) curr_list.remove(user_or_role.id)
@ -1786,7 +1787,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Clears the whitelist. Clears the whitelist.
""" """
await ctx.bot.db.guild(ctx.guild).whitelist.set([]) await ctx.bot._config.guild(ctx.guild).whitelist.set([])
await ctx.send(_("Whitelist has been cleared.")) await ctx.send(_("Whitelist has been cleared."))
@commands.group() @commands.group()
@ -1811,7 +1812,7 @@ class Core(commands.Cog, CoreLogic):
await ctx.send(_("You cannot blacklist an owner!")) await ctx.send(_("You cannot blacklist an owner!"))
return return
async with ctx.bot.db.guild(ctx.guild).blacklist() as curr_list: async with ctx.bot._config.guild(ctx.guild).blacklist() as curr_list:
if user_or_role.id not in curr_list: if user_or_role.id not in curr_list:
curr_list.append(user_or_role.id) curr_list.append(user_or_role.id)
@ -1825,7 +1826,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Lists blacklisted users and roles. Lists blacklisted users and roles.
""" """
curr_list = await ctx.bot.db.guild(ctx.guild).blacklist() curr_list = await ctx.bot._config.guild(ctx.guild).blacklist()
msg = _("Blacklisted Users and Roles:") msg = _("Blacklisted Users and Roles:")
for obj in curr_list: for obj in curr_list:
@ -1844,7 +1845,7 @@ class Core(commands.Cog, CoreLogic):
removed = False removed = False
user = isinstance(user_or_role, discord.Member) user = isinstance(user_or_role, discord.Member)
async with ctx.bot.db.guild(ctx.guild).blacklist() as curr_list: async with ctx.bot._config.guild(ctx.guild).blacklist() as curr_list:
if user_or_role.id in curr_list: if user_or_role.id in curr_list:
removed = True removed = True
curr_list.remove(user_or_role.id) curr_list.remove(user_or_role.id)
@ -1865,7 +1866,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Clears the blacklist. Clears the blacklist.
""" """
await ctx.bot.db.guild(ctx.guild).blacklist.set([]) await ctx.bot._config.guild(ctx.guild).blacklist.set([])
await ctx.send(_("Blacklist has been cleared.")) await ctx.send(_("Blacklist has been cleared."))
@checks.guildowner_or_permissions(administrator=True) @checks.guildowner_or_permissions(administrator=True)
@ -1904,7 +1905,7 @@ class Core(commands.Cog, CoreLogic):
) )
return return
async with ctx.bot.db.disabled_commands() as disabled_commands: async with ctx.bot._config.disabled_commands() as disabled_commands:
if command not in disabled_commands: if command not in disabled_commands:
disabled_commands.append(command_obj.qualified_name) disabled_commands.append(command_obj.qualified_name)
@ -1936,7 +1937,7 @@ class Core(commands.Cog, CoreLogic):
await ctx.send(_("You are not allowed to disable that command.")) await ctx.send(_("You are not allowed to disable that command."))
return return
async with ctx.bot.db.guild(ctx.guild).disabled_commands() as disabled_commands: async with ctx.bot._config.guild(ctx.guild).disabled_commands() as disabled_commands:
if command not in disabled_commands: if command not in disabled_commands:
disabled_commands.append(command_obj.qualified_name) disabled_commands.append(command_obj.qualified_name)
@ -1970,7 +1971,7 @@ class Core(commands.Cog, CoreLogic):
) )
return return
async with ctx.bot.db.disabled_commands() as disabled_commands: async with ctx.bot._config.disabled_commands() as disabled_commands:
with contextlib.suppress(ValueError): with contextlib.suppress(ValueError):
disabled_commands.remove(command_obj.qualified_name) disabled_commands.remove(command_obj.qualified_name)
@ -1996,7 +1997,7 @@ class Core(commands.Cog, CoreLogic):
await ctx.send(_("You are not allowed to enable that command.")) await ctx.send(_("You are not allowed to enable that command."))
return return
async with ctx.bot.db.guild(ctx.guild).disabled_commands() as disabled_commands: async with ctx.bot._config.guild(ctx.guild).disabled_commands() as disabled_commands:
with contextlib.suppress(ValueError): with contextlib.suppress(ValueError):
disabled_commands.remove(command_obj.qualified_name) disabled_commands.remove(command_obj.qualified_name)
@ -2017,7 +2018,7 @@ class Core(commands.Cog, CoreLogic):
To include the command name in the message, include the To include the command name in the message, include the
`{command}` placeholder. `{command}` placeholder.
""" """
await ctx.bot.db.disabled_command_msg.set(message) await ctx.bot._config.disabled_command_msg.set(message)
await ctx.tick() await ctx.tick()
@commands.guild_only() @commands.guild_only()
@ -2036,7 +2037,7 @@ class Core(commands.Cog, CoreLogic):
configured for automatic moderation action immunity configured for automatic moderation action immunity
""" """
ai_ids = await ctx.bot.db.guild(ctx.guild).autoimmune_ids() ai_ids = await ctx.bot._config.guild(ctx.guild).autoimmune_ids()
roles = {r.name for r in ctx.guild.roles if r.id in ai_ids} roles = {r.name for r in ctx.guild.roles if r.id in ai_ids}
members = {str(m) for m in ctx.guild.members if m.id in ai_ids} members = {str(m) for m in ctx.guild.members if m.id in ai_ids}
@ -2064,7 +2065,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Makes a user or roles immune from automated moderation actions Makes a user or roles immune from automated moderation actions
""" """
async with ctx.bot.db.guild(ctx.guild).autoimmune_ids() as ai_ids: async with ctx.bot._config.guild(ctx.guild).autoimmune_ids() as ai_ids:
if user_or_role.id in ai_ids: if user_or_role.id in ai_ids:
return await ctx.send(_("Already added.")) return await ctx.send(_("Already added."))
ai_ids.append(user_or_role.id) ai_ids.append(user_or_role.id)
@ -2077,7 +2078,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Makes a user or roles immune from automated moderation actions Makes a user or roles immune from automated moderation actions
""" """
async with ctx.bot.db.guild(ctx.guild).autoimmune_ids() as ai_ids: async with ctx.bot._config.guild(ctx.guild).autoimmune_ids() as ai_ids:
if user_or_role.id not in ai_ids: if user_or_role.id not in ai_ids:
return await ctx.send(_("Not in list.")) return await ctx.send(_("Not in list."))
ai_ids.remove(user_or_role.id) ai_ids.remove(user_or_role.id)
@ -2111,7 +2112,7 @@ class Core(commands.Cog, CoreLogic):
This is the default state. This is the default state.
""" """
async with ctx.bot.db.owner_opt_out_list() as opt_outs: async with ctx.bot._config.owner_opt_out_list() as opt_outs:
if ctx.author.id in opt_outs: if ctx.author.id in opt_outs:
opt_outs.remove(ctx.author.id) opt_outs.remove(ctx.author.id)
@ -2122,7 +2123,7 @@ class Core(commands.Cog, CoreLogic):
""" """
Opt-out of recieving owner notifications. Opt-out of recieving owner notifications.
""" """
async with ctx.bot.db.owner_opt_out_list() as opt_outs: async with ctx.bot._config.owner_opt_out_list() as opt_outs:
if ctx.author.id not in opt_outs: if ctx.author.id not in opt_outs:
opt_outs.append(ctx.author.id) opt_outs.append(ctx.author.id)
@ -2141,7 +2142,7 @@ class Core(commands.Cog, CoreLogic):
except AttributeError: except AttributeError:
channel_id = channel channel_id = channel
async with ctx.bot.db.extra_owner_destinations() as extras: async with ctx.bot._config.extra_owner_destinations() as extras:
if channel_id not in extras: if channel_id not in extras:
extras.append(channel_id) extras.append(channel_id)
@ -2160,7 +2161,7 @@ class Core(commands.Cog, CoreLogic):
except AttributeError: except AttributeError:
channel_id = channel channel_id = channel
async with ctx.bot.db.extra_owner_destinations() as extras: async with ctx.bot._config.extra_owner_destinations() as extras:
if channel_id in extras: if channel_id in extras:
extras.remove(channel_id) extras.remove(channel_id)
@ -2172,7 +2173,7 @@ class Core(commands.Cog, CoreLogic):
Lists the configured extra destinations for owner notifications Lists the configured extra destinations for owner notifications
""" """
channel_ids = await ctx.bot.db.extra_owner_destinations() channel_ids = await ctx.bot._config.extra_owner_destinations()
if not channel_ids: if not channel_ids:
await ctx.send(_("There are no extra channels being sent to.")) await ctx.send(_("There are no extra channels being sent to."))

6
redbot/core/dev_commands.py
View File

@ -126,7 +126,7 @@ class Dev(commands.Cog):
self._last_result = result self._last_result = result
api_keys = await ctx.bot.db.api_tokens() api_keys = await ctx.bot._config.api_tokens()
result = self.sanitize_output(ctx, api_keys, str(result)) result = self.sanitize_output(ctx, api_keys, str(result))
await ctx.send_interactive(self.get_pages(result), box_lang="py") await ctx.send_interactive(self.get_pages(result), box_lang="py")
@ -191,7 +191,7 @@ class Dev(commands.Cog):
msg = "{}{}".format(printed, result) msg = "{}{}".format(printed, result)
else: else:
msg = printed msg = printed
api_keys = await ctx.bot.db.api_tokens() api_keys = await ctx.bot._config.api_tokens()
msg = self.sanitize_output(ctx, api_keys, msg) msg = self.sanitize_output(ctx, api_keys, msg)
await ctx.send_interactive(self.get_pages(msg), box_lang="py") await ctx.send_interactive(self.get_pages(msg), box_lang="py")
@ -276,7 +276,7 @@ class Dev(commands.Cog):
elif value: elif value:
msg = "{}".format(value) msg = "{}".format(value)
api_keys = await ctx.bot.db.api_tokens() api_keys = await ctx.bot._config.api_tokens()
msg = self.sanitize_output(ctx, api_keys, msg) msg = self.sanitize_output(ctx, api_keys, msg)
try: try:

38
redbot/core/events.py
View File

@ -37,19 +37,19 @@ ______ _ ______ _ _ ______ _
def init_events(bot, cli_flags): def init_events(bot, cli_flags):
@bot.event @bot.event
async def on_connect(): async def on_connect():
if bot.uptime is None: if bot._uptime is None:
print("Connected to Discord. Getting ready...") print("Connected to Discord. Getting ready...")
@bot.event @bot.event
async def on_ready(): async def on_ready():
if bot.uptime is not None: if bot._uptime is not None:
return return
bot.uptime = datetime.datetime.utcnow() bot._uptime = datetime.datetime.utcnow()
packages = [] packages = []
if cli_flags.no_cogs is False: if cli_flags.no_cogs is False:
packages.extend(await bot.db.packages()) packages.extend(await bot._config.packages())
if cli_flags.load_cogs: if cli_flags.load_cogs:
packages.extend(cli_flags.load_cogs) packages.extend(cli_flags.load_cogs)
@ -90,8 +90,8 @@ def init_events(bot, cli_flags):
except: except:
invite_url = "Could not fetch invite url" invite_url = "Could not fetch invite url"
prefixes = cli_flags.prefix or (await bot.db.prefix()) prefixes = cli_flags.prefix or (await bot._config.prefix())
lang = await bot.db.locale() lang = await bot._config.locale()
red_pkg = pkg_resources.get_distribution("Red-DiscordBot") red_pkg = pkg_resources.get_distribution("Red-DiscordBot")
dpy_version = discord.__version__ dpy_version = discord.__version__
@ -160,7 +160,7 @@ def init_events(bot, cli_flags):
if invite_url: if invite_url:
print("\nInvite URL: {}\n".format(invite_url)) print("\nInvite URL: {}\n".format(invite_url))
bot.color = discord.Colour(await bot.db.color()) bot._color = discord.Colour(await bot._config.color())
@bot.event @bot.event
async def on_command_error(ctx, error, unhandled_by_cog=False): async def on_command_error(ctx, error, unhandled_by_cog=False):
@ -183,7 +183,7 @@ def init_events(bot, cli_flags):
elif isinstance(error, commands.UserInputError): elif isinstance(error, commands.UserInputError):
await ctx.send_help() await ctx.send_help()
elif isinstance(error, commands.DisabledCommand): elif isinstance(error, commands.DisabledCommand):
disabled_message = await bot.db.disabled_command_msg() disabled_message = await bot._config.disabled_command_msg()
if disabled_message: if disabled_message:
await ctx.send(disabled_message.replace("{command}", ctx.invoked_with)) await ctx.send(disabled_message.replace("{command}", ctx.invoked_with))
elif isinstance(error, commands.CommandInvokeError): elif isinstance(error, commands.CommandInvokeError):
@ -255,12 +255,12 @@ def init_events(bot, cli_flags):
@bot.event @bot.event
async def on_message(message): async def on_message(message):
bot.counter["messages_read"] += 1 bot._counter["messages_read"] += 1
await bot.process_commands(message) await bot.process_commands(message)
discord_now = message.created_at discord_now = message.created_at
if ( if (
not bot.checked_time_accuracy not bot._checked_time_accuracy
or (discord_now - timedelta(minutes=60)) > bot.checked_time_accuracy or (discord_now - timedelta(minutes=60)) > bot._checked_time_accuracy
): ):
system_now = datetime.datetime.utcnow() system_now = datetime.datetime.utcnow()
diff = abs((discord_now - system_now).total_seconds()) diff = abs((discord_now - system_now).total_seconds())
@ -270,28 +270,28 @@ def init_events(bot, cli_flags):
"clock. Any time sensitive code may fail.", "clock. Any time sensitive code may fail.",
diff, diff,
) )
bot.checked_time_accuracy = discord_now bot._checked_time_accuracy = discord_now
@bot.event @bot.event
async def on_resumed(): async def on_resumed():
bot.counter["sessions_resumed"] += 1 bot._counter["sessions_resumed"] += 1
@bot.event @bot.event
async def on_command(command): async def on_command(command):
bot.counter["processed_commands"] += 1 bot._counter["processed_commands"] += 1
@bot.event @bot.event
async def on_command_add(command: commands.Command): async def on_command_add(command: commands.Command):
disabled_commands = await bot.db.disabled_commands() disabled_commands = await bot._config.disabled_commands()
if command.qualified_name in disabled_commands: if command.qualified_name in disabled_commands:
command.enabled = False command.enabled = False
for guild in bot.guilds: for guild in bot.guilds:
disabled_commands = await bot.db.guild(guild).disabled_commands() disabled_commands = await bot._config.guild(guild).disabled_commands()
if command.qualified_name in disabled_commands: if command.qualified_name in disabled_commands:
command.disable_in(guild) command.disable_in(guild)
async def _guild_added(guild: discord.Guild): async def _guild_added(guild: discord.Guild):
disabled_commands = await bot.db.guild(guild).disabled_commands() disabled_commands = await bot._config.guild(guild).disabled_commands()
for command_name in disabled_commands: for command_name in disabled_commands:
command_obj = bot.get_command(command_name) command_obj = bot.get_command(command_name)
if command_obj is not None: if command_obj is not None:
@ -310,7 +310,7 @@ def init_events(bot, cli_flags):
@bot.event @bot.event
async def on_guild_leave(guild: discord.Guild): async def on_guild_leave(guild: discord.Guild):
# Clean up any unneeded checks # Clean up any unneeded checks
disabled_commands = await bot.db.guild(guild).disabled_commands() disabled_commands = await bot._config.guild(guild).disabled_commands()
for command_name in disabled_commands: for command_name in disabled_commands:
command_obj = bot.get_command(command_name) command_obj = bot.get_command(command_name)
if command_obj is not None: if command_obj is not None:
@ -322,7 +322,7 @@ def init_events(bot, cli_flags):
for c in confs: for c in confs:
uuid = c.unique_identifier uuid = c.unique_identifier
group_data = c.custom_groups group_data = c.custom_groups
await bot.db.custom("CUSTOM_GROUPS", c.cog_name, uuid).set(group_data) await bot._config.custom("CUSTOM_GROUPS", c.cog_name, uuid).set(group_data)
def _get_startup_screen_specs(): def _get_startup_screen_specs():

6
redbot/core/global_checks.py
View File

@ -9,11 +9,11 @@ def init_global_checks(bot):
if await bot.is_owner(ctx.author): if await bot.is_owner(ctx.author):
return True return True
whitelist = await bot.db.whitelist() whitelist = await bot._config.whitelist()
if whitelist: if whitelist:
return ctx.author.id in whitelist return ctx.author.id in whitelist
return ctx.author.id not in await bot.db.blacklist() return ctx.author.id not in await bot._config.blacklist()
@bot.check_once @bot.check_once
async def local_perms(ctx: commands.Context): async def local_perms(ctx: commands.Context):
@ -22,7 +22,7 @@ def init_global_checks(bot):
return True return True
elif ctx.guild is None: elif ctx.guild is None:
return True return True
guild_settings = bot.db.guild(ctx.guild) guild_settings = bot._config.guild(ctx.guild)
local_blacklist = await guild_settings.blacklist() local_blacklist = await guild_settings.blacklist()
local_whitelist = await guild_settings.whitelist() local_whitelist = await guild_settings.whitelist()

4
redbot/core/utils/__init__.py
View File

@ -221,9 +221,9 @@ async def fuzzy_command_search(
""" """
if ctx.guild is not None: if ctx.guild is not None:
enabled = await ctx.bot.db.guild(ctx.guild).fuzzy() enabled = await ctx.bot._config.guild(ctx.guild).fuzzy()
else: else:
enabled = await ctx.bot.db.fuzzy() enabled = await ctx.bot._config.fuzzy()
if not enabled: if not enabled:
return return

7
redbot/core/utils/mod.py
View File

@ -128,9 +128,10 @@ async def is_mod_or_superior(
elif isinstance(obj, discord.Member): elif isinstance(obj, discord.Member):
user = obj user = obj
elif isinstance(obj, discord.Role): elif isinstance(obj, discord.Role):
if obj.id in await bot.db.guild(obj.guild).mod_role(): gid = obj.guild.id
if obj in await bot.get_admin_role_ids(gid):
return True return True
if obj.id in await bot.db.guild(obj.guild).admin_role(): if obj in await bot.get_mod_role_ids(gid):
return True return True
return False return False
else: else:
@ -209,7 +210,7 @@ async def is_admin_or_superior(
elif isinstance(obj, discord.Member): elif isinstance(obj, discord.Member):
user = obj user = obj
elif isinstance(obj, discord.Role): elif isinstance(obj, discord.Role):
return obj.id in await bot.db.guild(obj.guild).admin_role() return obj.id in await bot.get_admin_role_ids(obj.guild.id)
else: else:
raise TypeError("Only messages, members or roles may be passed") raise TypeError("Only messages, members or roles may be passed")