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

Normalize names of attributes with Config instances (#3765)

Browse Source 
* Lets normalize how we name config attributes across the bot.

Signed-off-by: Drapersniper <27962761+drapersniper@users.noreply.github.com>

* ....

Signed-off-by: Drapersniper <27962761+drapersniper@users.noreply.github.com>

* nothing to see here

Signed-off-by: Drapersniper <27962761+drapersniper@users.noreply.github.com>
This commit is contained in:
Draper 2020-04-20 18:12:57 +01:00 committed by GitHub
parent df7ca65108
commit e4018ec677
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 328 additions and 325 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
docs/framework_config.rst
View File

@ -202,15 +202,15 @@ the built-in Economy credits::
class Pets: class Pets:
def __init__(self): def __init__(self):
self.conf = Config.get_conf(self, 1234567890) self.config = Config.get_conf(self, 1234567890)
# Here we'll assign some default costs for the pets # Here we'll assign some default costs for the pets
self.conf.register_global( self.config.register_global(
dog=100, dog=100,
cat=100, cat=100,
bird=50 bird=50
) )
self.conf.register_user( self.config.register_user(
pets={} pets={}
) )
@ -229,7 +229,7 @@ And now that the cog is set up we'll need to create some commands that allow use
# We will need to use "get_raw" # We will need to use "get_raw"
try: try:
cost = await self.conf.get_raw(pet_type) cost = await self.config.get_raw(pet_type)
except KeyError: except KeyError:
# KeyError is thrown whenever the data you try to access does not # KeyError is thrown whenever the data you try to access does not
# exist in the registered defaults or in the saved data. # exist in the registered defaults or in the saved data.
@ -241,15 +241,15 @@ assign a new pet to the user. This is very easily done using the V3 bank API and
# continued # continued
if await bank.can_spend(ctx.author, cost): if await bank.can_spend(ctx.author, cost):
await self.conf.user(ctx.author).pets.set_raw( await self.config.user(ctx.author).pets.set_raw(
pet_name, value={'cost': cost, 'hunger': 0} pet_name, value={'cost': cost, 'hunger': 0}
) )
# this is equivalent to doing the following # this is equivalent to doing the following
pets = await self.conf.user(ctx.author).pets() pets = await self.config.user(ctx.author).pets()
pets[pet_name] = {'cost': cost, 'hunger': 0} pets[pet_name] = {'cost': cost, 'hunger': 0}
await self.conf.user(ctx.author).pets.set(pets) await self.config.user(ctx.author).pets.set(pets)
Since the pets can get hungry we're gonna need a command that let's pet owners check how hungry their pets are:: Since the pets can get hungry we're gonna need a command that let's pet owners check how hungry their pets are::
@ -257,7 +257,7 @@ Since the pets can get hungry we're gonna need a command that let's pet owners c
@commands.command() @commands.command()
async def hunger(self, ctx, pet_name: str): async def hunger(self, ctx, pet_name: str):
try: try:
hunger = await self.conf.user(ctx.author).pets.get_raw(pet_name, 'hunger') hunger = await self.config.user(ctx.author).pets.get_raw(pet_name, 'hunger')
except KeyError: except KeyError:
# Remember, this is thrown if something in the provided identifiers # Remember, this is thrown if something in the provided identifiers
# is not found in the saved data or the defaults. # is not found in the saved data or the defaults.
@ -274,7 +274,7 @@ We're responsible pet owners here, so we've also got to have a way to feed our p
# This is a bit more complicated because we need to check if the pet is # This is a bit more complicated because we need to check if the pet is
# owned first. # owned first.
try: try:
pet = await self.conf.user(ctx.author).pets.get_raw(pet_name) pet = await self.config.user(ctx.author).pets.get_raw(pet_name)
except KeyError: except KeyError:
# If the given pet name doesn't exist in our data # If the given pet name doesn't exist in our data
await ctx.send("You don't own that pet!") await ctx.send("You don't own that pet!")
@ -285,12 +285,12 @@ We're responsible pet owners here, so we've also got to have a way to feed our p
# Determine the new hunger and make sure it doesn't go negative # Determine the new hunger and make sure it doesn't go negative
new_hunger = max(hunger - food, 0) new_hunger = max(hunger - food, 0)
await self.conf.user(ctx.author).pets.set_raw( await self.config.user(ctx.author).pets.set_raw(
pet_name, 'hunger', value=new_hunger pet_name, 'hunger', value=new_hunger
) )
# We could accomplish the same thing a slightly different way # We could accomplish the same thing a slightly different way
await self.conf.user(ctx.author).pets.get_attr(pet_name).hunger.set(new_hunger) await self.config.user(ctx.author).pets.get_attr(pet_name).hunger.set(new_hunger)
await ctx.send("Your pet is now at {}/100 hunger!".format(new_hunger) await ctx.send("Your pet is now at {}/100 hunger!".format(new_hunger)
@ -300,7 +300,7 @@ Of course, if we're less than responsible pet owners, there are consequences::
@commands.command() @commands.command()
async def adopt(self, ctx, pet_name: str, *, member: discord.Member): async def adopt(self, ctx, pet_name: str, *, member: discord.Member):
try: try:
pet = await self.conf.user(member).pets.get_raw(pet_name) pet = await self.config.user(member).pets.get_raw(pet_name)
except KeyError: except KeyError:
await ctx.send("That person doesn't own that pet!") await ctx.send("That person doesn't own that pet!")
return return
@ -310,15 +310,15 @@ Of course, if we're less than responsible pet owners, there are consequences::
await ctx.send("That pet is too well taken care of to be adopted.") await ctx.send("That pet is too well taken care of to be adopted.")
return return
await self.conf.user(member).pets.clear_raw(pet_name) await self.config.user(member).pets.clear_raw(pet_name)
# this is equivalent to doing the following # this is equivalent to doing the following
pets = await self.conf.user(member).pets() pets = await self.config.user(member).pets()
del pets[pet_name] del pets[pet_name]
await self.conf.user(member).pets.set(pets) await self.config.user(member).pets.set(pets)
await self.conf.user(ctx.author).pets.set_raw(pet_name, value=pet) await self.config.user(ctx.author).pets.set_raw(pet_name, value=pet)
await ctx.send( await ctx.send(
"Your request to adopt this pet has been granted due to " "Your request to adopt this pet has been granted due to "
"how poorly it was taken care of." "how poorly it was taken care of."
@ -351,15 +351,15 @@ much the same way they would in V2. The following examples will demonstrate how
class ExampleCog: class ExampleCog:
def __init__(self): def __init__(self):
self.conf = Config.get_conf(self, 1234567890) self.config = Config.get_conf(self, 1234567890)
self.data = {} self.data = {}
async def load_data(self): async def load_data(self):
self.data = await self.conf.custom("V2", "V2").all() self.data = await self.config.custom("V2", "V2").all()
async def save_data(self): async def save_data(self):
await self.conf.custom("V2", "V2").set(self.data) await self.config.custom("V2", "V2").set(self.data)
async def setup(bot): async def setup(bot):
@ -407,13 +407,13 @@ API Reference
includes keys within a `dict` when one is being set, as well as keys in nested dictionaries includes keys within a `dict` when one is being set, as well as keys in nested dictionaries
within that `dict`. For example:: within that `dict`. For example::
>>> conf = Config.get_conf(self, identifier=999) >>> config = Config.get_conf(self, identifier=999)
>>> conf.register_global(foo={}) >>> config.register_global(foo={})
>>> await conf.foo.set_raw(123, value=True) >>> await config.foo.set_raw(123, value=True)
>>> await conf.foo() >>> await config.foo()
{'123': True} {'123': True}
>>> await conf.foo.set({123: True, 456: {789: False}} >>> await config.foo.set({123: True, 456: {789: False}}
>>> await conf.foo() >>> await config.foo()
{'123': True, '456': {'789': False}} {'123': True, '456': {'789': False}}
.. automodule:: redbot.core.config .. automodule:: redbot.core.config

28
redbot/cogs/admin/admin.py
View File

@ -70,11 +70,11 @@ class Admin(commands.Cog):
"""A collection of server administration utilities.""" """A collection of server administration utilities."""
def __init__(self): def __init__(self):
self.conf = Config.get_conf(self, 8237492837454039, force_registration=True) self.config = Config.get_conf(self, 8237492837454039, force_registration=True)
self.conf.register_global(serverlocked=False) self.config.register_global(serverlocked=False)
self.conf.register_guild( self.config.register_guild(
announce_ignore=False, announce_ignore=False,
announce_channel=None, # Integer ID announce_channel=None, # Integer ID
selfroles=[], # List of integer ID's selfroles=[], # List of integer ID's
@ -290,7 +290,7 @@ class Admin(commands.Cog):
async def announce(self, ctx: commands.Context, *, message: str): async def announce(self, ctx: commands.Context, *, message: str):
"""Announce a message to all servers the bot is in.""" """Announce a message to all servers the bot is in."""
if not self.is_announcing(): if not self.is_announcing():
announcer = Announcer(ctx, message, config=self.conf) announcer = Announcer(ctx, message, config=self.config)
announcer.start() announcer.start()
self.__current_announcer = announcer self.__current_announcer = announcer
@ -325,7 +325,7 @@ class Admin(commands.Cog):
""" """
if channel is None: if channel is None:
channel = ctx.channel channel = ctx.channel
await self.conf.guild(ctx.guild).announce_channel.set(channel.id) await self.config.guild(ctx.guild).announce_channel.set(channel.id)
await ctx.send( await ctx.send(
_("The announcement channel has been set to {channel.mention}").format(channel=channel) _("The announcement channel has been set to {channel.mention}").format(channel=channel)
) )
@ -333,8 +333,8 @@ class Admin(commands.Cog):
@announceset.command(name="ignore") @announceset.command(name="ignore")
async def announceset_ignore(self, ctx): async def announceset_ignore(self, ctx):
"""Toggle announcements being enabled this server.""" """Toggle announcements being enabled this server."""
ignored = await self.conf.guild(ctx.guild).announce_ignore() ignored = await self.config.guild(ctx.guild).announce_ignore()
await self.conf.guild(ctx.guild).announce_ignore.set(not ignored) await self.config.guild(ctx.guild).announce_ignore.set(not ignored)
if ignored: if ignored:
await ctx.send( await ctx.send(
_("The server {guild.name} will receive announcements.").format(guild=ctx.guild) _("The server {guild.name} will receive announcements.").format(guild=ctx.guild)
@ -352,14 +352,14 @@ class Admin(commands.Cog):
:param guild: :param guild:
:return: :return:
""" """
selfrole_ids = set(await self.conf.guild(guild).selfroles()) selfrole_ids = set(await self.config.guild(guild).selfroles())
guild_roles = guild.roles guild_roles = guild.roles
valid_roles = tuple(r for r in guild_roles if r.id in selfrole_ids) valid_roles = tuple(r for r in guild_roles if r.id in selfrole_ids)
valid_role_ids = set(r.id for r in valid_roles) valid_role_ids = set(r.id for r in valid_roles)
if selfrole_ids != valid_role_ids: if selfrole_ids != valid_role_ids:
await self.conf.guild(guild).selfroles.set(list(valid_role_ids)) await self.config.guild(guild).selfroles.set(list(valid_role_ids))
# noinspection PyTypeChecker # noinspection PyTypeChecker
return valid_roles return valid_roles
@ -427,7 +427,7 @@ class Admin(commands.Cog):
).format(role=role) ).format(role=role)
) )
return return
async with self.conf.guild(ctx.guild).selfroles() as curr_selfroles: async with self.config.guild(ctx.guild).selfroles() as curr_selfroles:
if role.id not in curr_selfroles: if role.id not in curr_selfroles:
curr_selfroles.append(role.id) curr_selfroles.append(role.id)
await ctx.send(_("Added.")) await ctx.send(_("Added."))
@ -449,7 +449,7 @@ class Admin(commands.Cog):
).format(role=role) ).format(role=role)
) )
return return
async with self.conf.guild(ctx.guild).selfroles() as curr_selfroles: async with self.config.guild(ctx.guild).selfroles() as curr_selfroles:
curr_selfroles.remove(role.id) curr_selfroles.remove(role.id)
await ctx.send(_("Removed.")) await ctx.send(_("Removed."))
@ -458,8 +458,8 @@ class Admin(commands.Cog):
@checks.is_owner() @checks.is_owner()
async def serverlock(self, ctx: commands.Context): async def serverlock(self, ctx: commands.Context):
"""Lock a bot to its current servers only.""" """Lock a bot to its current servers only."""
serverlocked = await self.conf.serverlocked() serverlocked = await self.config.serverlocked()
await self.conf.serverlocked.set(not serverlocked) await self.config.serverlocked.set(not serverlocked)
if serverlocked: if serverlocked:
await ctx.send(_("The bot is no longer serverlocked.")) await ctx.send(_("The bot is no longer serverlocked."))
@ -468,7 +468,7 @@ class Admin(commands.Cog):
# region Event Handlers # region Event Handlers
async def on_guild_join(self, guild: discord.Guild): async def on_guild_join(self, guild: discord.Guild):
if await self.conf.serverlocked(): if await self.config.serverlocked():
await guild.leave() await guild.leave()

3
redbot/cogs/admin/converters.py
View File

@ -14,8 +14,7 @@ class SelfRole(commands.Converter):
role_converter = commands.RoleConverter() role_converter = commands.RoleConverter()
role = await role_converter.convert(ctx, arg) role = await role_converter.convert(ctx, arg)
conf = admin.conf selfroles = await admin.config.guild(ctx.guild).selfroles()
selfroles = await conf.guild(ctx.guild).selfroles()
if role.id not in selfroles: if role.id not in selfroles:
raise commands.BadArgument(_("The provided role is not a valid selfrole.")) raise commands.BadArgument(_("The provided role is not a valid selfrole."))

22
redbot/cogs/alias/alias.py
View File

@ -49,25 +49,25 @@ class Alias(commands.Cog):
def __init__(self, bot: Red): def __init__(self, bot: Red):
super().__init__() super().__init__()
self.bot = bot self.bot = bot
self._aliases = Config.get_conf(self, 8927348724) self.config = Config.get_conf(self, 8927348724)
self._aliases.register_global(**self.default_global_settings) self.config.register_global(**self.default_global_settings)
self._aliases.register_guild(**self.default_guild_settings) self.config.register_guild(**self.default_guild_settings)
async def unloaded_aliases(self, guild: discord.Guild) -> Generator[AliasEntry, None, None]: async def unloaded_aliases(self, guild: discord.Guild) -> Generator[AliasEntry, None, None]:
return (AliasEntry.from_json(d) for d in (await self._aliases.guild(guild).entries())) return (AliasEntry.from_json(d) for d in (await self.config.guild(guild).entries()))
async def unloaded_global_aliases(self) -> Generator[AliasEntry, None, None]: async def unloaded_global_aliases(self) -> Generator[AliasEntry, None, None]:
return (AliasEntry.from_json(d) for d in (await self._aliases.entries())) return (AliasEntry.from_json(d) for d in (await self.config.entries()))
async def loaded_aliases(self, guild: discord.Guild) -> Generator[AliasEntry, None, None]: async def loaded_aliases(self, guild: discord.Guild) -> Generator[AliasEntry, None, None]:
return ( return (
AliasEntry.from_json(d, bot=self.bot) AliasEntry.from_json(d, bot=self.bot)
for d in (await self._aliases.guild(guild).entries()) for d in (await self.config.guild(guild).entries())
) )
async def loaded_global_aliases(self) -> Generator[AliasEntry, None, None]: async def loaded_global_aliases(self) -> Generator[AliasEntry, None, None]:
return (AliasEntry.from_json(d, bot=self.bot) for d in (await self._aliases.entries())) return (AliasEntry.from_json(d, bot=self.bot) for d in (await self.config.entries()))
async def is_alias( async def is_alias(
self, self,
@ -123,9 +123,9 @@ class Alias(commands.Cog):
alias = AliasEntry(alias_name, command, ctx.author, global_=global_) alias = AliasEntry(alias_name, command, ctx.author, global_=global_)
if global_: if global_:
settings = self._aliases settings = self.config
else: else:
settings = self._aliases.guild(ctx.guild) settings = self.config.guild(ctx.guild)
await settings.enabled.set(True) await settings.enabled.set(True)
async with settings.entries() as curr_aliases: async with settings.entries() as curr_aliases:
@ -137,9 +137,9 @@ class Alias(commands.Cog):
self, ctx: commands.Context, alias_name: str, global_: bool = False self, ctx: commands.Context, alias_name: str, global_: bool = False
) -> bool: ) -> bool:
if global_: if global_:
settings = self._aliases settings = self.config
else: else:
settings = self._aliases.guild(ctx.guild) settings = self.config.guild(ctx.guild)
async with settings.entries() as aliases: async with settings.entries() as aliases:
for alias in aliases: for alias in aliases:

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

@ -48,15 +48,15 @@ class Bank(commands.Cog):
"""Base command for bank settings.""" """Base command for bank settings."""
if ctx.invoked_subcommand is None: if ctx.invoked_subcommand is None:
if await bank.is_global(): if await bank.is_global():
bank_name = await bank._conf.bank_name() bank_name = await bank._config.bank_name()
currency_name = await bank._conf.currency() currency_name = await bank._config.currency()
default_balance = await bank._conf.default_balance() default_balance = await bank._config.default_balance()
else: else:
if not ctx.guild: if not ctx.guild:
return return
bank_name = await bank._conf.guild(ctx.guild).bank_name() bank_name = await bank._config.guild(ctx.guild).bank_name()
currency_name = await bank._conf.guild(ctx.guild).currency() currency_name = await bank._config.guild(ctx.guild).currency()
default_balance = await bank._conf.guild(ctx.guild).default_balance() default_balance = await bank._config.guild(ctx.guild).default_balance()
settings = _( settings = _(
"Bank settings:\n\nBank name: {bank_name}\nCurrency: {currency_name}\n" "Bank settings:\n\nBank name: {bank_name}\nCurrency: {currency_name}\n"

34
redbot/cogs/downloader/downloader.py
View File

@ -40,9 +40,9 @@ class Downloader(commands.Cog):
super().__init__() super().__init__()
self.bot = bot self.bot = bot
self.conf = Config.get_conf(self, identifier=998240343, force_registration=True) self.config = Config.get_conf(self, identifier=998240343, force_registration=True)
self.conf.register_global(schema_version=0, installed_cogs={}, installed_libraries={}) self.config.register_global(schema_version=0, installed_cogs={}, installed_libraries={})
self.already_agreed = False self.already_agreed = False
@ -99,22 +99,22 @@ class Downloader(commands.Cog):
self._ready.set() self._ready.set()
async def _maybe_update_config(self) -> None: async def _maybe_update_config(self) -> None:
schema_version = await self.conf.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.conf.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):
""" """
This contains migration to allow saving state This contains migration to allow saving state
of both installed cogs and shared libraries. of both installed cogs and shared libraries.
""" """
old_conf = await self.conf.get_raw("installed", default=[]) old_conf = await self.config.get_raw("installed", default=[])
if not old_conf: if not old_conf:
return return
async with self.conf.installed_cogs() as new_cog_conf: async with self.config.installed_cogs() as new_cog_conf:
for cog_json in old_conf: for cog_json in old_conf:
repo_name = cog_json["repo_name"] repo_name = cog_json["repo_name"]
module_name = cog_json["cog_name"] module_name = cog_json["cog_name"]
@ -126,7 +126,7 @@ class Downloader(commands.Cog):
"commit": "", "commit": "",
"pinned": False, "pinned": False,
} }
await self.conf.clear_raw("installed") await self.config.clear_raw("installed")
# no reliable way to get installed libraries (i.a. missing repo name) # no reliable way to get installed libraries (i.a. missing repo name)
# but it only helps `[p]cog update` run faster so it's not an issue # but it only helps `[p]cog update` run faster so it's not an issue
@ -150,7 +150,7 @@ class Downloader(commands.Cog):
All installed cogs. All installed cogs.
""" """
installed = await self.conf.installed_cogs() installed = await self.config.installed_cogs()
# noinspection PyTypeChecker # noinspection PyTypeChecker
return tuple( return tuple(
InstalledModule.from_json(cog_json, self._repo_manager) InstalledModule.from_json(cog_json, self._repo_manager)
@ -167,7 +167,7 @@ class Downloader(commands.Cog):
All installed shared libraries. All installed shared libraries.
""" """
installed = await self.conf.installed_libraries() installed = await self.config.installed_libraries()
# noinspection PyTypeChecker # noinspection PyTypeChecker
return tuple( return tuple(
InstalledModule.from_json(lib_json, self._repo_manager) InstalledModule.from_json(lib_json, self._repo_manager)
@ -195,8 +195,8 @@ class Downloader(commands.Cog):
The modules to check off. The modules to check off.
""" """
installed_cogs = await self.conf.installed_cogs() installed_cogs = await self.config.installed_cogs()
installed_libraries = await self.conf.installed_libraries() installed_libraries = await self.config.installed_libraries()
for module in modules: for module in modules:
if module.type == InstallableType.COG: if module.type == InstallableType.COG:
installed = installed_cogs installed = installed_cogs
@ -208,8 +208,8 @@ class Downloader(commands.Cog):
repo_json = installed.setdefault(module.repo_name, {}) repo_json = installed.setdefault(module.repo_name, {})
repo_json[module.name] = module_json repo_json[module.name] = module_json
await self.conf.installed_cogs.set(installed_cogs) await self.config.installed_cogs.set(installed_cogs)
await self.conf.installed_libraries.set(installed_libraries) await self.config.installed_libraries.set(installed_libraries)
async def _remove_from_installed(self, modules: Iterable[InstalledModule]) -> None: async def _remove_from_installed(self, modules: Iterable[InstalledModule]) -> None:
"""Remove modules from the saved list """Remove modules from the saved list
@ -221,8 +221,8 @@ class Downloader(commands.Cog):
The modules to remove. The modules to remove.
""" """
installed_cogs = await self.conf.installed_cogs() installed_cogs = await self.config.installed_cogs()
installed_libraries = await self.conf.installed_libraries() installed_libraries = await self.config.installed_libraries()
for module in modules: for module in modules:
if module.type == InstallableType.COG: if module.type == InstallableType.COG:
installed = installed_cogs installed = installed_cogs
@ -233,8 +233,8 @@ class Downloader(commands.Cog):
with contextlib.suppress(KeyError): with contextlib.suppress(KeyError):
installed[module._json_repo_name].pop(module.name) installed[module._json_repo_name].pop(module.name)
await self.conf.installed_cogs.set(installed_cogs) await self.config.installed_cogs.set(installed_cogs)
await self.conf.installed_libraries.set(installed_libraries) await self.config.installed_libraries.set(installed_libraries)
async def _shared_lib_load_check(self, cog_name: str) -> Optional[Repo]: async def _shared_lib_load_check(self, cog_name: str) -> Optional[Repo]:
# remove in Red 3.4 # remove in Red 3.4

12
redbot/cogs/downloader/repo_manager.py
View File

@ -990,8 +990,8 @@ class RepoManager:
def __init__(self) -> None: def __init__(self) -> None:
self._repos: Dict[str, Repo] = {} self._repos: Dict[str, Repo] = {}
self.conf = Config.get_conf(self, identifier=170708480, force_registration=True) self.config = Config.get_conf(self, identifier=170708480, force_registration=True)
self.conf.register_global(repos={}) self.config.register_global(repos={})
async def initialize(self) -> None: async def initialize(self) -> None:
await self._load_repos(set_repos=True) await self._load_repos(set_repos=True)
@ -1040,7 +1040,7 @@ class RepoManager:
url=url, name=name, branch=branch, commit="", folder_path=self.repos_folder / name url=url, name=name, branch=branch, commit="", folder_path=self.repos_folder / name
) )
await r.clone() await r.clone()
await self.conf.repos.set_raw(name, value=r.branch) await self.config.repos.set_raw(name, value=r.branch)
self._repos[name] = r self._repos[name] = r
@ -1110,7 +1110,7 @@ class RepoManager:
safe_delete(repo.folder_path) safe_delete(repo.folder_path)
await self.conf.repos.clear_raw(repo.name) await self.config.repos.clear_raw(repo.name)
try: try:
del self._repos[name] del self._repos[name]
except KeyError: except KeyError:
@ -1189,10 +1189,10 @@ class RepoManager:
if not folder.is_dir(): if not folder.is_dir():
continue continue
try: try:
branch = await self.conf.repos.get_raw(folder.stem, default="") branch = await self.config.repos.get_raw(folder.stem, default="")
ret[folder.stem] = await Repo.from_folder(folder, branch) ret[folder.stem] = await Repo.from_folder(folder, branch)
if branch == "": if branch == "":
await self.conf.repos.set_raw(folder.stem, value=ret[folder.stem].branch) await self.config.repos.set_raw(folder.stem, value=ret[folder.stem].branch)
except errors.NoRemoteURL: except errors.NoRemoteURL:
log.warning("A remote URL does not exist for repo %s", folder.stem) log.warning("A remote URL does not exist for repo %s", folder.stem)
except errors.DownloaderException as err: except errors.DownloaderException as err:

56
redbot/cogs/filter/filter.py
View File

@ -17,7 +17,7 @@ class Filter(commands.Cog):
def __init__(self, bot: Red): def __init__(self, bot: Red):
super().__init__() super().__init__()
self.bot = bot self.bot = bot
self.settings = Config.get_conf(self, 4766951341) self.config = Config.get_conf(self, 4766951341)
default_guild_settings = { default_guild_settings = {
"filter": [], "filter": [],
"filterban_count": 0, "filterban_count": 0,
@ -27,9 +27,9 @@ class Filter(commands.Cog):
} }
default_member_settings = {"filter_count": 0, "next_reset_time": 0} default_member_settings = {"filter_count": 0, "next_reset_time": 0}
default_channel_settings = {"filter": []} default_channel_settings = {"filter": []}
self.settings.register_guild(**default_guild_settings) self.config.register_guild(**default_guild_settings)
self.settings.register_member(**default_member_settings) self.config.register_member(**default_member_settings)
self.settings.register_channel(**default_channel_settings) self.config.register_channel(**default_channel_settings)
self.register_task = self.bot.loop.create_task(self.register_filterban()) self.register_task = self.bot.loop.create_task(self.register_filterban())
self.pattern_cache = {} self.pattern_cache = {}
@ -62,7 +62,7 @@ class Filter(commands.Cog):
The default name used is *John Doe*. The default name used is *John Doe*.
""" """
guild = ctx.guild guild = ctx.guild
await self.settings.guild(guild).filter_default_name.set(name) await self.config.guild(guild).filter_default_name.set(name)
await ctx.send(_("The name to use on filtered names has been set.")) await ctx.send(_("The name to use on filtered names has been set."))
@filterset.command(name="ban") @filterset.command(name="ban")
@ -83,12 +83,12 @@ class Filter(commands.Cog):
) )
return return
elif count == 0 and timeframe == 0: elif count == 0 and timeframe == 0:
await self.settings.guild(ctx.guild).filterban_count.set(0) await self.config.guild(ctx.guild).filterban_count.set(0)
await self.settings.guild(ctx.guild).filterban_time.set(0) await self.config.guild(ctx.guild).filterban_time.set(0)
await ctx.send(_("Autoban disabled.")) await ctx.send(_("Autoban disabled."))
else: else:
await self.settings.guild(ctx.guild).filterban_count.set(count) await self.config.guild(ctx.guild).filterban_count.set(count)
await self.settings.guild(ctx.guild).filterban_time.set(timeframe) await self.config.guild(ctx.guild).filterban_time.set(timeframe)
await ctx.send(_("Count and time have been set.")) await ctx.send(_("Count and time have been set."))
@commands.group(name="filter") @commands.group(name="filter")
@ -105,7 +105,7 @@ class Filter(commands.Cog):
if ctx.invoked_subcommand is None: if ctx.invoked_subcommand is None:
server = ctx.guild server = ctx.guild
author = ctx.author author = ctx.author
word_list = await self.settings.guild(server).filter() word_list = await self.config.guild(server).filter()
if word_list: if word_list:
words = ", ".join(word_list) words = ", ".join(word_list)
words = _("Filtered in this server:") + "\n\n" + words words = _("Filtered in this server:") + "\n\n" + words
@ -127,7 +127,7 @@ class Filter(commands.Cog):
if ctx.invoked_subcommand is None: if ctx.invoked_subcommand is None:
channel = ctx.channel channel = ctx.channel
author = ctx.author author = ctx.author
word_list = await self.settings.channel(channel).filter() word_list = await self.config.channel(channel).filter()
if word_list: if word_list:
words = ", ".join(word_list) words = ", ".join(word_list)
words = _("Filtered in this channel:") + "\n\n" + words words = _("Filtered in this channel:") + "\n\n" + words
@ -276,8 +276,8 @@ class Filter(commands.Cog):
This is disabled by default. This is disabled by default.
""" """
guild = ctx.guild guild = ctx.guild
current_setting = await self.settings.guild(guild).filter_names() current_setting = await self.config.guild(guild).filter_names()
await self.settings.guild(guild).filter_names.set(not current_setting) await self.config.guild(guild).filter_names.set(not current_setting)
if current_setting: if current_setting:
await ctx.send(_("Names and nicknames will no longer be filtered.")) await ctx.send(_("Names and nicknames will no longer be filtered."))
else: else:
@ -296,14 +296,14 @@ class Filter(commands.Cog):
) -> bool: ) -> bool:
added = False added = False
if isinstance(server_or_channel, discord.Guild): if isinstance(server_or_channel, discord.Guild):
async with self.settings.guild(server_or_channel).filter() as cur_list: async with self.config.guild(server_or_channel).filter() as cur_list:
for w in words: for w in words:
if w.lower() not in cur_list and w: if w.lower() not in cur_list and w:
cur_list.append(w.lower()) cur_list.append(w.lower())
added = True added = True
elif isinstance(server_or_channel, discord.TextChannel): elif isinstance(server_or_channel, discord.TextChannel):
async with self.settings.channel(server_or_channel).filter() as cur_list: async with self.config.channel(server_or_channel).filter() as cur_list:
for w in words: for w in words:
if w.lower not in cur_list and w: if w.lower not in cur_list and w:
cur_list.append(w.lower()) cur_list.append(w.lower())
@ -316,14 +316,14 @@ class Filter(commands.Cog):
) -> bool: ) -> bool:
removed = False removed = False
if isinstance(server_or_channel, discord.Guild): if isinstance(server_or_channel, discord.Guild):
async with self.settings.guild(server_or_channel).filter() as cur_list: async with self.config.guild(server_or_channel).filter() as cur_list:
for w in words: for w in words:
if w.lower() in cur_list: if w.lower() in cur_list:
cur_list.remove(w.lower()) cur_list.remove(w.lower())
removed = True removed = True
elif isinstance(server_or_channel, discord.TextChannel): elif isinstance(server_or_channel, discord.TextChannel):
async with self.settings.channel(server_or_channel).filter() as cur_list: async with self.config.channel(server_or_channel).filter() as cur_list:
for w in words: for w in words:
if w.lower() in cur_list: if w.lower() in cur_list:
cur_list.remove(w.lower()) cur_list.remove(w.lower())
@ -347,9 +347,9 @@ class Filter(commands.Cog):
try: try:
pattern = self.pattern_cache[(guild, channel)] pattern = self.pattern_cache[(guild, channel)]
except KeyError: except KeyError:
word_list = set(await self.settings.guild(guild).filter()) word_list = set(await self.config.guild(guild).filter())
if channel: if channel:
word_list |= set(await self.settings.channel(channel).filter()) word_list |= set(await self.config.channel(channel).filter())
if word_list: if word_list:
pattern = re.compile( pattern = re.compile(
@ -368,18 +368,18 @@ class Filter(commands.Cog):
server = message.guild server = message.guild
author = message.author author = message.author
filter_count = await self.settings.guild(server).filterban_count() filter_count = await self.config.guild(server).filterban_count()
filter_time = await self.settings.guild(server).filterban_time() filter_time = await self.config.guild(server).filterban_time()
user_count = await self.settings.member(author).filter_count() user_count = await self.config.member(author).filter_count()
next_reset_time = await self.settings.member(author).next_reset_time() next_reset_time = await self.config.member(author).next_reset_time()
if filter_count > 0 and filter_time > 0: if filter_count > 0 and filter_time > 0:
if message.created_at.timestamp() >= next_reset_time: if message.created_at.timestamp() >= next_reset_time:
next_reset_time = message.created_at.timestamp() + filter_time next_reset_time = message.created_at.timestamp() + filter_time
await self.settings.member(author).next_reset_time.set(next_reset_time) await self.config.member(author).next_reset_time.set(next_reset_time)
if user_count > 0: if user_count > 0:
user_count = 0 user_count = 0
await self.settings.member(author).filter_count.set(user_count) await self.config.member(author).filter_count.set(user_count)
hits = await self.filter_hits(message.content, message.channel) hits = await self.filter_hits(message.content, message.channel)
@ -392,7 +392,7 @@ class Filter(commands.Cog):
self.bot.dispatch("filter_message_delete", message, hits) self.bot.dispatch("filter_message_delete", message, hits)
if filter_count > 0 and filter_time > 0: if filter_count > 0 and filter_time > 0:
user_count += 1 user_count += 1
await self.settings.member(author).filter_count.set(user_count) await self.config.member(author).filter_count.set(user_count)
if ( if (
user_count >= filter_count user_count >= filter_count
and message.created_at.timestamp() < next_reset_time and message.created_at.timestamp() < next_reset_time
@ -449,12 +449,12 @@ class Filter(commands.Cog):
return # Discord Hierarchy applies to nicks return # Discord Hierarchy applies to nicks
if await self.bot.is_automod_immune(member): if await self.bot.is_automod_immune(member):
return return
if not await self.settings.guild(member.guild).filter_names(): if not await self.config.guild(member.guild).filter_names():
return return
if await self.filter_hits(member.display_name, member.guild): if await self.filter_hits(member.display_name, member.guild):
name_to_use = await self.settings.guild(member.guild).filter_default_name() name_to_use = await self.config.guild(member.guild).filter_default_name()
reason = _("Filtered nickname") if member.nick else _("Filtered name") reason = _("Filtered nickname") if member.nick else _("Filtered name")
try: try:
await member.edit(nick=name_to_use, reason=reason) await member.edit(nick=name_to_use, reason=reason)

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

@ -18,8 +18,8 @@ class Image(commands.Cog):
def __init__(self, bot): def __init__(self, bot):
super().__init__() super().__init__()
self.bot = bot self.bot = bot
self.settings = Config.get_conf(self, identifier=2652104208, force_registration=True) self.config = Config.get_conf(self, identifier=2652104208, force_registration=True)
self.settings.register_global(**self.default_global) self.config.register_global(**self.default_global)
self.session = aiohttp.ClientSession() self.session = aiohttp.ClientSession()
self.imgur_base_url = "https://api.imgur.com/3/" self.imgur_base_url = "https://api.imgur.com/3/"
@ -28,11 +28,11 @@ 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.config.imgur_client_id()
if imgur_token is not None: if imgur_token is not None:
if not await self.bot.get_shared_api_tokens("imgur"): if not await self.bot.get_shared_api_tokens("imgur"):
await self.bot.set_shared_api_tokens("imgur", client_id=imgur_token) await self.bot.set_shared_api_tokens("imgur", client_id=imgur_token)
await self.settings.imgur_client_id.clear() await self.config.imgur_client_id.clear()
@commands.group(name="imgur") @commands.group(name="imgur")
async def _imgur(self, ctx): async def _imgur(self, ctx):

2
redbot/cogs/mod/abc.py
View File

@ -14,7 +14,7 @@ class MixinMeta(ABC):
""" """
def __init__(self, *_args): def __init__(self, *_args):
self.settings: Config self.config: Config
self.bot: Red self.bot: Red
self.cache: dict self.cache: dict

8
redbot/cogs/mod/events.py
View File

@ -23,7 +23,7 @@ class Events(MixinMeta):
guild_cache = self.cache.get(guild.id, None) guild_cache = self.cache.get(guild.id, None)
if guild_cache is None: if guild_cache is None:
repeats = await self.settings.guild(guild).delete_repeats() repeats = await self.config.guild(guild).delete_repeats()
if repeats == -1: if repeats == -1:
return False return False
guild_cache = self.cache[guild.id] = defaultdict(lambda: deque(maxlen=repeats)) guild_cache = self.cache[guild.id] = defaultdict(lambda: deque(maxlen=repeats))
@ -45,7 +45,7 @@ class Events(MixinMeta):
guild = message.guild guild = message.guild
author = message.author author = message.author
max_mentions = await self.settings.guild(guild).ban_mention_spam() max_mentions = await self.config.guild(guild).ban_mention_spam()
if max_mentions: if max_mentions:
mentions = set(message.mentions) mentions = set(message.mentions)
if len(mentions) >= max_mentions: if len(mentions) >= max_mentions:
@ -97,7 +97,7 @@ class Events(MixinMeta):
@commands.Cog.listener() @commands.Cog.listener()
async def on_user_update(self, before: discord.User, after: discord.User): async def on_user_update(self, before: discord.User, after: discord.User):
if before.name != after.name: if before.name != after.name:
async with self.settings.user(before).past_names() as name_list: async with self.config.user(before).past_names() as name_list:
while None in name_list: # clean out null entries from a bug while None in name_list: # clean out null entries from a bug
name_list.remove(None) name_list.remove(None)
if after.name in name_list: if after.name in name_list:
@ -110,7 +110,7 @@ class Events(MixinMeta):
@commands.Cog.listener() @commands.Cog.listener()
async def on_member_update(self, before: discord.Member, after: discord.Member): async def on_member_update(self, before: discord.Member, after: discord.Member):
if before.nick != after.nick and after.nick is not None: if before.nick != after.nick and after.nick is not None:
async with self.settings.member(before).past_nicks() as nick_list: async with self.config.member(before).past_nicks() as nick_list:
while None in nick_list: # clean out null entries from a bug while None in nick_list: # clean out null entries from a bug
nick_list.remove(None) nick_list.remove(None)
if after.nick in nick_list: if after.nick in nick_list:

28
redbot/cogs/mod/kickban.py
View File

@ -71,7 +71,7 @@ class KickBanMixin(MixinMeta):
if author == user: if author == user:
return _("I cannot let you do that. Self-harm is bad {}").format("\N{PENSIVE FACE}") return _("I cannot let you do that. Self-harm is bad {}").format("\N{PENSIVE FACE}")
elif not await is_allowed_by_hierarchy(self.bot, self.settings, guild, author, user): elif not await is_allowed_by_hierarchy(self.bot, self.config, guild, author, user):
return _( return _(
"I cannot let you do that. You are " "I cannot let you do that. You are "
"not higher than the user in the role " "not higher than the user in the role "
@ -82,7 +82,7 @@ class KickBanMixin(MixinMeta):
elif not (0 <= days <= 7): elif not (0 <= days <= 7):
return _("Invalid days. Must be between 0 and 7.") return _("Invalid days. Must be between 0 and 7.")
toggle = await self.settings.guild(guild).dm_on_kickban() toggle = await self.config.guild(guild).dm_on_kickban()
if toggle: if toggle:
with contextlib.suppress(discord.HTTPException): with contextlib.suppress(discord.HTTPException):
em = discord.Embed( em = discord.Embed(
@ -142,13 +142,13 @@ class KickBanMixin(MixinMeta):
except discord.HTTPException: except discord.HTTPException:
continue continue
async with self.settings.guild(guild).current_tempbans() as guild_tempbans: async with self.config.guild(guild).current_tempbans() as guild_tempbans:
for uid in guild_tempbans.copy(): for uid in guild_tempbans.copy():
user = banned_users.get(uid, None) user = banned_users.get(uid, None)
if not user: if not user:
continue continue
unban_time = datetime.utcfromtimestamp( unban_time = datetime.utcfromtimestamp(
await self.settings.member(member(uid, guild)).banned_until() await self.config.member(member(uid, guild)).banned_until()
) )
if datetime.utcnow() > unban_time: # Time to unban the user if datetime.utcnow() > unban_time: # Time to unban the user
queue_entry = (guild.id, uid) queue_entry = (guild.id, uid)
@ -186,7 +186,7 @@ class KickBanMixin(MixinMeta):
) )
) )
return return
elif not await is_allowed_by_hierarchy(self.bot, self.settings, guild, author, user): elif not await is_allowed_by_hierarchy(self.bot, self.config, guild, author, user):
await ctx.send( await ctx.send(
_( _(
"I cannot let you do that. You are " "I cannot let you do that. You are "
@ -199,7 +199,7 @@ class KickBanMixin(MixinMeta):
await ctx.send(_("I cannot do that due to discord hierarchy rules")) await ctx.send(_("I cannot do that due to discord hierarchy rules"))
return return
audit_reason = get_audit_reason(author, reason) audit_reason = get_audit_reason(author, reason)
toggle = await self.settings.guild(guild).dm_on_kickban() toggle = await self.config.guild(guild).dm_on_kickban()
if toggle: if toggle:
with contextlib.suppress(discord.HTTPException): with contextlib.suppress(discord.HTTPException):
em = discord.Embed( em = discord.Embed(
@ -255,7 +255,7 @@ class KickBanMixin(MixinMeta):
author = ctx.author author = ctx.author
guild = ctx.guild guild = ctx.guild
if days is None: if days is None:
days = await self.settings.guild(guild).default_days() days = await self.config.guild(guild).default_days()
result = await self.ban_user( result = await self.ban_user(
user=user, ctx=ctx, days=days, reason=reason, create_modlog_case=True user=user, ctx=ctx, days=days, reason=reason, create_modlog_case=True
@ -309,7 +309,7 @@ class KickBanMixin(MixinMeta):
return return
if days is None: if days is None:
days = await self.settings.guild(guild).default_days() days = await self.config.guild(guild).default_days()
if not (0 <= days <= 7): if not (0 <= days <= 7):
await ctx.send(_("Invalid days. Must be between 0 and 7.")) await ctx.send(_("Invalid days. Must be between 0 and 7."))
@ -409,10 +409,10 @@ class KickBanMixin(MixinMeta):
invite = "" invite = ""
queue_entry = (guild.id, user.id) queue_entry = (guild.id, user.id)
await self.settings.member(user).banned_until.set(unban_time.timestamp()) await self.config.member(user).banned_until.set(unban_time.timestamp())
cur_tbans = await self.settings.guild(guild).current_tempbans() cur_tbans = await self.config.guild(guild).current_tempbans()
cur_tbans.append(user.id) cur_tbans.append(user.id)
await self.settings.guild(guild).current_tempbans.set(cur_tbans) await self.config.guild(guild).current_tempbans.set(cur_tbans)
with contextlib.suppress(discord.HTTPException): with contextlib.suppress(discord.HTTPException):
# We don't want blocked DMs preventing us from banning # We don't want blocked DMs preventing us from banning
@ -464,7 +464,7 @@ class KickBanMixin(MixinMeta):
) )
) )
return return
elif not await is_allowed_by_hierarchy(self.bot, self.settings, guild, author, user): elif not await is_allowed_by_hierarchy(self.bot, self.config, guild, author, user):
await ctx.send( await ctx.send(
_( _(
"I cannot let you do that. You are " "I cannot let you do that. You are "
@ -540,7 +540,7 @@ class KickBanMixin(MixinMeta):
if await self._voice_perm_check(ctx, user_voice_state, move_members=True) is False: if await self._voice_perm_check(ctx, user_voice_state, move_members=True) is False:
return return
elif not await is_allowed_by_hierarchy(self.bot, self.settings, guild, author, member): elif not await is_allowed_by_hierarchy(self.bot, self.config, guild, author, member):
await ctx.send( await ctx.send(
_( _(
"I cannot let you do that. You are " "I cannot let you do that. You are "
@ -620,7 +620,7 @@ class KickBanMixin(MixinMeta):
await ctx.send(e) await ctx.send(e)
await ctx.send(_("Unbanned that user from this server")) await ctx.send(_("Unbanned that user from this server"))
if await self.settings.guild(guild).reinvite_on_unban(): if await self.config.guild(guild).reinvite_on_unban():
user = ctx.bot.get_user(user_id) user = ctx.bot.get_user(user_id)
if not user: if not user:
await ctx.send( await ctx.send(

40
redbot/cogs/mod/mod.py
View File

@ -69,12 +69,12 @@ class Mod(
super().__init__() super().__init__()
self.bot = bot self.bot = bot
self.settings = Config.get_conf(self, 4961522000, force_registration=True) self.config = Config.get_conf(self, 4961522000, force_registration=True)
self.settings.register_global(**self.default_global_settings) self.config.register_global(**self.default_global_settings)
self.settings.register_guild(**self.default_guild_settings) self.config.register_guild(**self.default_guild_settings)
self.settings.register_channel(**self.default_channel_settings) self.config.register_channel(**self.default_channel_settings)
self.settings.register_member(**self.default_member_settings) self.config.register_member(**self.default_member_settings)
self.settings.register_user(**self.default_user_settings) self.config.register_user(**self.default_user_settings)
self.cache: dict = {} self.cache: dict = {}
self.tban_expiry_task = self.bot.loop.create_task(self.check_tempban_expirations()) self.tban_expiry_task = self.bot.loop.create_task(self.check_tempban_expirations())
self.last_case: dict = defaultdict(dict) self.last_case: dict = defaultdict(dict)
@ -93,45 +93,45 @@ class Mod(
async def _maybe_update_config(self): async def _maybe_update_config(self):
"""Maybe update `delete_delay` value set by Config prior to Mod 1.0.0.""" """Maybe update `delete_delay` value set by Config prior to Mod 1.0.0."""
if not await self.settings.version(): if not await self.config.version():
guild_dict = await self.settings.all_guilds() guild_dict = await self.config.all_guilds()
for guild_id, info in guild_dict.items(): for guild_id, info in guild_dict.items():
delete_repeats = info.get("delete_repeats", False) delete_repeats = info.get("delete_repeats", False)
if delete_repeats: if delete_repeats:
val = 3 val = 3
else: else:
val = -1 val = -1
await self.settings.guild(discord.Object(id=guild_id)).delete_repeats.set(val) await self.config.guild(discord.Object(id=guild_id)).delete_repeats.set(val)
await self.settings.version.set("1.0.0") # set version of last update await self.config.version.set("1.0.0") # set version of last update
if await self.settings.version() < "1.1.0": if await self.config.version() < "1.1.0":
msg = _( msg = _(
"Ignored guilds and channels have been moved. " "Ignored guilds and channels have been moved. "
"Please use `[p]moveignoredchannels` if " "Please use `[p]moveignoredchannels` if "
"you were previously using these functions." "you were previously using these functions."
) )
self.bot.loop.create_task(send_to_owners_with_prefix_replaced(self.bot, msg)) self.bot.loop.create_task(send_to_owners_with_prefix_replaced(self.bot, msg))
await self.settings.version.set("1.1.0") await self.config.version.set("1.1.0")
if await self.settings.version() < "1.2.0": if await self.config.version() < "1.2.0":
msg = _( msg = _(
"Delete delay settings have been moved. " "Delete delay settings have been moved. "
"Please use `[p]movedeletedelay` if " "Please use `[p]movedeletedelay` if "
"you were previously using these functions." "you were previously using these functions."
) )
self.bot.loop.create_task(send_to_owners_with_prefix_replaced(self.bot, msg)) self.bot.loop.create_task(send_to_owners_with_prefix_replaced(self.bot, msg))
await self.settings.version.set("1.2.0") await self.config.version.set("1.2.0")
@commands.command() @commands.command()
@commands.is_owner() @commands.is_owner()
async def moveignoredchannels(self, ctx: commands.Context) -> None: async def moveignoredchannels(self, ctx: commands.Context) -> None:
"""Move ignored channels and servers to core""" """Move ignored channels and servers to core"""
all_guilds = await self.settings.all_guilds() all_guilds = await self.config.all_guilds()
all_channels = await self.settings.all_channels() all_channels = await self.config.all_channels()
for guild_id, settings in all_guilds.items(): for guild_id, settings in all_guilds.items():
await self.bot._config.guild_from_id(guild_id).ignored.set(settings["ignored"]) await self.bot._config.guild_from_id(guild_id).ignored.set(settings["ignored"])
await self.settings.guild_from_id(guild_id).ignored.clear() await self.config.guild_from_id(guild_id).ignored.clear()
for channel_id, settings in all_channels.items(): for channel_id, settings in all_channels.items():
await self.bot._config.channel_from_id(channel_id).ignored.set(settings["ignored"]) await self.bot._config.channel_from_id(channel_id).ignored.set(settings["ignored"])
await self.settings.channel_from_id(channel_id).clear() await self.config.channel_from_id(channel_id).clear()
await ctx.send(_("Ignored channels and guilds restored.")) await ctx.send(_("Ignored channels and guilds restored."))
@commands.command() @commands.command()
@ -140,10 +140,10 @@ class Mod(
""" """
Move deletedelay settings to core Move deletedelay settings to core
""" """
all_guilds = await self.settings.all_guilds() all_guilds = await self.config.all_guilds()
for guild_id, settings in all_guilds.items(): for guild_id, settings in all_guilds.items():
await self.bot._config.guild_from_id(guild_id).delete_delay.set( await self.bot._config.guild_from_id(guild_id).delete_delay.set(
settings["delete_delay"] settings["delete_delay"]
) )
await self.settings.guild_from_id(guild_id).delete_delay.clear() await self.config.guild_from_id(guild_id).delete_delay.clear()
await ctx.send(_("Delete delay settings restored.")) await ctx.send(_("Delete delay settings restored."))

12
redbot/cogs/mod/mutes.py
View File

@ -415,7 +415,7 @@ class MuteMixin(MixinMeta):
if all(getattr(permissions, p) is False for p in new_overs.keys()): if all(getattr(permissions, p) is False for p in new_overs.keys()):
return False, _(mute_unmute_issues["already_muted"]) return False, _(mute_unmute_issues["already_muted"])
elif not await is_allowed_by_hierarchy(self.bot, self.settings, guild, author, user): elif not await is_allowed_by_hierarchy(self.bot, self.config, guild, author, user):
return False, _(mute_unmute_issues["hierarchy_problem"]) return False, _(mute_unmute_issues["hierarchy_problem"])
old_overs = {k: getattr(overwrites, k) for k in new_overs} old_overs = {k: getattr(overwrites, k) for k in new_overs}
@ -430,9 +430,7 @@ class MuteMixin(MixinMeta):
elif e.code == 10009: elif e.code == 10009:
return False, _(mute_unmute_issues["left_guild"]) return False, _(mute_unmute_issues["left_guild"])
else: else:
await self.settings.member(user).set_raw( await self.config.member(user).set_raw("perms_cache", str(channel.id), value=old_overs)
"perms_cache", str(channel.id), value=old_overs
)
return True, None return True, None
async def unmute_user( async def unmute_user(
@ -444,7 +442,7 @@ class MuteMixin(MixinMeta):
reason: str, reason: str,
) -> (bool, str): ) -> (bool, str):
overwrites = channel.overwrites_for(user) overwrites = channel.overwrites_for(user)
perms_cache = await self.settings.member(user).perms_cache() perms_cache = await self.config.member(user).perms_cache()
if channel.id in perms_cache: if channel.id in perms_cache:
old_values = perms_cache[channel.id] old_values = perms_cache[channel.id]
@ -454,7 +452,7 @@ class MuteMixin(MixinMeta):
if all(getattr(overwrites, k) == v for k, v in old_values.items()): if all(getattr(overwrites, k) == v for k, v in old_values.items()):
return False, _(mute_unmute_issues["already_unmuted"]) return False, _(mute_unmute_issues["already_unmuted"])
elif not await is_allowed_by_hierarchy(self.bot, self.settings, guild, author, user): elif not await is_allowed_by_hierarchy(self.bot, self.config, guild, author, user):
return False, _(mute_unmute_issues["hierarchy_problem"]) return False, _(mute_unmute_issues["hierarchy_problem"])
overwrites.update(**old_values) overwrites.update(**old_values)
@ -473,5 +471,5 @@ class MuteMixin(MixinMeta):
elif e.code == 10009: elif e.code == 10009:
return False, _(mute_unmute_issues["left_guild"]) return False, _(mute_unmute_issues["left_guild"])
else: else:
await self.settings.member(user).clear_raw("perms_cache", str(channel.id)) await self.config.member(user).clear_raw("perms_cache", str(channel.id))
return True, None return True, None

4
redbot/cogs/mod/names.py
View File

@ -20,8 +20,8 @@ class ModInfo(MixinMeta):
""" """
async def get_names_and_nicks(self, user): async def get_names_and_nicks(self, user):
names = await self.settings.user(user).past_names() names = await self.config.user(user).past_names()
nicks = await self.settings.member(user).past_nicks() nicks = await self.config.member(user).past_nicks()
if names: if names:
names = [escape_spoilers_and_mass_mentions(name) for name in names if name] names = [escape_spoilers_and_mass_mentions(name) for name in names if name]
if nicks: if nicks:

32
redbot/cogs/mod/settings.py
View File

@ -21,7 +21,7 @@ class ModSettings(MixinMeta):
if ctx.invoked_subcommand is None: if ctx.invoked_subcommand is None:
guild = ctx.guild guild = ctx.guild
# Display current settings # Display current settings
data = await self.settings.guild(guild).all() data = await self.config.guild(guild).all()
delete_repeats = data["delete_repeats"] delete_repeats = data["delete_repeats"]
ban_mention_spam = data["ban_mention_spam"] ban_mention_spam = data["ban_mention_spam"]
respect_hierarchy = data["respect_hierarchy"] respect_hierarchy = data["respect_hierarchy"]
@ -73,14 +73,14 @@ class ModSettings(MixinMeta):
This is enabled by default. This is enabled by default.
""" """
guild = ctx.guild guild = ctx.guild
toggled = await self.settings.guild(guild).respect_hierarchy() toggled = await self.config.guild(guild).respect_hierarchy()
if not toggled: if not toggled:
await self.settings.guild(guild).respect_hierarchy.set(True) await self.config.guild(guild).respect_hierarchy.set(True)
await ctx.send( await ctx.send(
_("Role hierarchy will be checked when moderation commands are issued.") _("Role hierarchy will be checked when moderation commands are issued.")
) )
else: else:
await self.settings.guild(guild).respect_hierarchy.set(False) await self.config.guild(guild).respect_hierarchy.set(False)
await ctx.send( await ctx.send(
_("Role hierarchy will be ignored when moderation commands are issued.") _("Role hierarchy will be ignored when moderation commands are issued.")
) )
@ -99,7 +99,7 @@ class ModSettings(MixinMeta):
if max_mentions: if max_mentions:
if max_mentions < 5: if max_mentions < 5:
max_mentions = 5 max_mentions = 5
await self.settings.guild(guild).ban_mention_spam.set(max_mentions) await self.config.guild(guild).ban_mention_spam.set(max_mentions)
await ctx.send( await ctx.send(
_( _(
"Autoban for mention spam enabled. " "Autoban for mention spam enabled. "
@ -108,11 +108,11 @@ class ModSettings(MixinMeta):
).format(max_mentions=max_mentions) ).format(max_mentions=max_mentions)
) )
else: else:
cur_setting = await self.settings.guild(guild).ban_mention_spam() cur_setting = await self.config.guild(guild).ban_mention_spam()
if not cur_setting: if not cur_setting:
await ctx.send_help() await ctx.send_help()
return return
await self.settings.guild(guild).ban_mention_spam.set(False) await self.config.guild(guild).ban_mention_spam.set(False)
await ctx.send(_("Autoban for mention spam disabled.")) await ctx.send(_("Autoban for mention spam disabled."))
@modset.command() @modset.command()
@ -127,11 +127,11 @@ class ModSettings(MixinMeta):
guild = ctx.guild guild = ctx.guild
if repeats is not None: if repeats is not None:
if repeats == -1: if repeats == -1:
await self.settings.guild(guild).delete_repeats.set(repeats) await self.config.guild(guild).delete_repeats.set(repeats)
self.cache.pop(guild.id, None) # remove cache with old repeat limits self.cache.pop(guild.id, None) # remove cache with old repeat limits
await ctx.send(_("Repeated messages will be ignored.")) await ctx.send(_("Repeated messages will be ignored."))
elif 2 <= repeats <= 20: elif 2 <= repeats <= 20:
await self.settings.guild(guild).delete_repeats.set(repeats) await self.config.guild(guild).delete_repeats.set(repeats)
# purge and update cache to new repeat limits # purge and update cache to new repeat limits
self.cache[guild.id] = defaultdict(lambda: deque(maxlen=repeats)) self.cache[guild.id] = defaultdict(lambda: deque(maxlen=repeats))
await ctx.send( await ctx.send(
@ -145,7 +145,7 @@ class ModSettings(MixinMeta):
) )
) )
else: else:
repeats = await self.settings.guild(guild).delete_repeats() repeats = await self.config.guild(guild).delete_repeats()
if repeats != -1: if repeats != -1:
await ctx.send( await ctx.send(
_( _(
@ -166,16 +166,16 @@ class ModSettings(MixinMeta):
to the newly-unbanned user. to the newly-unbanned user.
""" """
guild = ctx.guild guild = ctx.guild
cur_setting = await self.settings.guild(guild).reinvite_on_unban() cur_setting = await self.config.guild(guild).reinvite_on_unban()
if not cur_setting: if not cur_setting:
await self.settings.guild(guild).reinvite_on_unban.set(True) await self.config.guild(guild).reinvite_on_unban.set(True)
await ctx.send( await ctx.send(
_("Users unbanned with `{command}` will be reinvited.").format( _("Users unbanned with `{command}` will be reinvited.").format(
command=f"{ctx.clean_prefix}unban" command=f"{ctx.clean_prefix}unban"
) )
) )
else: else:
await self.settings.guild(guild).reinvite_on_unban.set(False) await self.config.guild(guild).reinvite_on_unban.set(False)
await ctx.send( await ctx.send(
_("Users unbanned with `{command}` will not be reinvited.").format( _("Users unbanned with `{command}` will not be reinvited.").format(
command=f"{ctx.clean_prefix}unban" command=f"{ctx.clean_prefix}unban"
@ -192,12 +192,12 @@ class ModSettings(MixinMeta):
""" """
guild = ctx.guild guild = ctx.guild
if enabled is None: if enabled is None:
setting = await self.settings.guild(guild).dm_on_kickban() setting = await self.config.guild(guild).dm_on_kickban()
await ctx.send( await ctx.send(
_("DM when kicked/banned is currently set to: {setting}").format(setting=setting) _("DM when kicked/banned is currently set to: {setting}").format(setting=setting)
) )
return return
await self.settings.guild(guild).dm_on_kickban.set(enabled) await self.config.guild(guild).dm_on_kickban.set(enabled)
if enabled: if enabled:
await ctx.send(_("Bot will now attempt to send a DM to user before kick and ban.")) await ctx.send(_("Bot will now attempt to send a DM to user before kick and ban."))
else: else:
@ -215,7 +215,7 @@ class ModSettings(MixinMeta):
guild = ctx.guild guild = ctx.guild
if not (0 <= days <= 7): if not (0 <= days <= 7):
return await ctx.send(_("Invalid number of days. Must be between 0 and 7.")) return await ctx.send(_("Invalid number of days. Must be between 0 and 7."))
await self.settings.guild(guild).default_days.set(days) await self.config.guild(guild).default_days.set(days)
await ctx.send( await ctx.send(
_("{days} days worth of messages will be deleted when a user is banned.").format( _("{days} days worth of messages will be deleted when a user is banned.").format(
days=days days=days

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

@ -54,11 +54,11 @@ class Streams(commands.Cog):
def __init__(self, bot: Red): def __init__(self, bot: Red):
super().__init__() super().__init__()
self.db: Config = Config.get_conf(self, 26262626) self.config: Config = Config.get_conf(self, 26262626)
self.ttv_bearer_cache: dict = {} self.ttv_bearer_cache: dict = {}
self.db.register_global(**self.global_defaults) self.config.register_global(**self.global_defaults)
self.db.register_guild(**self.guild_defaults) self.config.register_guild(**self.guild_defaults)
self.db.register_role(**self.role_defaults) self.config.register_role(**self.role_defaults)
self.bot: Red = bot self.bot: Red = bot
@ -95,7 +95,7 @@ class Streams(commands.Cog):
async def move_api_keys(self) -> None: async def move_api_keys(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."""
tokens = await self.db.tokens() tokens = await self.config.tokens()
youtube = await self.bot.get_shared_api_tokens("youtube") youtube = await self.bot.get_shared_api_tokens("youtube")
twitch = await self.bot.get_shared_api_tokens("twitch") twitch = await self.bot.get_shared_api_tokens("twitch")
for token_type, token in tokens.items(): for token_type, token in tokens.items():
@ -104,7 +104,7 @@ class Streams(commands.Cog):
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.set_shared_api_tokens("twitch", client_id=token) await self.bot.set_shared_api_tokens("twitch", client_id=token)
await self.db.tokens.clear() await self.config.tokens.clear()
async def get_twitch_bearer_token(self) -> None: async def get_twitch_bearer_token(self) -> None:
tokens = await self.bot.get_shared_api_tokens("twitch") tokens = await self.bot.get_shared_api_tokens("twitch")
@ -244,7 +244,7 @@ class Streams(commands.Cog):
else: else:
if isinstance(info, tuple): if isinstance(info, tuple):
embed, is_rerun = info embed, is_rerun = info
ignore_reruns = await self.db.guild(ctx.channel.guild).ignore_reruns() ignore_reruns = await self.config.guild(ctx.channel.guild).ignore_reruns()
if ignore_reruns and is_rerun: if ignore_reruns and is_rerun:
await ctx.send(_("That user is offline.")) await ctx.send(_("That user is offline."))
return return
@ -418,7 +418,7 @@ class Streams(commands.Cog):
if refresh_time < 60: if refresh_time < 60:
return await ctx.send(_("You cannot set the refresh timer to less than 60 seconds")) return await ctx.send(_("You cannot set the refresh timer to less than 60 seconds"))
await self.db.refresh_timer.set(refresh_time) await self.config.refresh_timer.set(refresh_time)
await ctx.send( await ctx.send(
_("Refresh timer set to {refresh_time} seconds".format(refresh_time=refresh_time)) _("Refresh timer set to {refresh_time} seconds".format(refresh_time=refresh_time))
) )
@ -484,7 +484,7 @@ class Streams(commands.Cog):
""" """
if message is not None: if message is not None:
guild = ctx.guild guild = ctx.guild
await self.db.guild(guild).live_message_mention.set(message) await self.config.guild(guild).live_message_mention.set(message)
await ctx.send(_("Stream alert message set!")) await ctx.send(_("Stream alert message set!"))
else: else:
await ctx.send_help() await ctx.send_help()
@ -500,7 +500,7 @@ class Streams(commands.Cog):
""" """
if message is not None: if message is not None:
guild = ctx.guild guild = ctx.guild
await self.db.guild(guild).live_message_nomention.set(message) await self.config.guild(guild).live_message_nomention.set(message)
await ctx.send(_("Stream alert message set!")) await ctx.send(_("Stream alert message set!"))
else: else:
await ctx.send_help() await ctx.send_help()
@ -510,8 +510,8 @@ class Streams(commands.Cog):
async def clear_message(self, ctx: commands.Context): async def clear_message(self, ctx: commands.Context):
"""Reset the stream alert messages in this server.""" """Reset the stream alert messages in this server."""
guild = ctx.guild guild = ctx.guild
await self.db.guild(guild).live_message_mention.set(False) await self.config.guild(guild).live_message_mention.set(False)
await self.db.guild(guild).live_message_nomention.set(False) await self.config.guild(guild).live_message_nomention.set(False)
await ctx.send(_("Stream alerts in this server will now use the default alert message.")) await ctx.send(_("Stream alerts in this server will now use the default alert message."))
@streamset.group() @streamset.group()
@ -525,12 +525,12 @@ class Streams(commands.Cog):
async def all(self, ctx: commands.Context): async def all(self, ctx: commands.Context):
"""Toggle the `@\u200beveryone` mention.""" """Toggle the `@\u200beveryone` mention."""
guild = ctx.guild guild = ctx.guild
current_setting = await self.db.guild(guild).mention_everyone() current_setting = await self.config.guild(guild).mention_everyone()
if current_setting: if current_setting:
await self.db.guild(guild).mention_everyone.set(False) await self.config.guild(guild).mention_everyone.set(False)
await ctx.send(_("`@\u200beveryone` will no longer be mentioned for stream alerts.")) await ctx.send(_("`@\u200beveryone` will no longer be mentioned for stream alerts."))
else: else:
await self.db.guild(guild).mention_everyone.set(True) await self.config.guild(guild).mention_everyone.set(True)
await ctx.send(_("When a stream is live, `@\u200beveryone` will be mentioned.")) await ctx.send(_("When a stream is live, `@\u200beveryone` will be mentioned."))
@mention.command(aliases=["here"]) @mention.command(aliases=["here"])
@ -538,28 +538,28 @@ class Streams(commands.Cog):
async def online(self, ctx: commands.Context): async def online(self, ctx: commands.Context):
"""Toggle the `@\u200bhere` mention.""" """Toggle the `@\u200bhere` mention."""
guild = ctx.guild guild = ctx.guild
current_setting = await self.db.guild(guild).mention_here() current_setting = await self.config.guild(guild).mention_here()
if current_setting: if current_setting:
await self.db.guild(guild).mention_here.set(False) await self.config.guild(guild).mention_here.set(False)
await ctx.send(_("`@\u200bhere` will no longer be mentioned for stream alerts.")) await ctx.send(_("`@\u200bhere` will no longer be mentioned for stream alerts."))
else: else:
await self.db.guild(guild).mention_here.set(True) await self.config.guild(guild).mention_here.set(True)
await ctx.send(_("When a stream is live, `@\u200bhere` will be mentioned.")) await ctx.send(_("When a stream is live, `@\u200bhere` will be mentioned."))
@mention.command() @mention.command()
@commands.guild_only() @commands.guild_only()
async def role(self, ctx: commands.Context, *, role: discord.Role): async def role(self, ctx: commands.Context, *, role: discord.Role):
"""Toggle a role mention.""" """Toggle a role mention."""
current_setting = await self.db.role(role).mention() current_setting = await self.config.role(role).mention()
if current_setting: if current_setting:
await self.db.role(role).mention.set(False) await self.config.role(role).mention.set(False)
await ctx.send( await ctx.send(
_("`@\u200b{role.name}` will no longer be mentioned for stream alerts.").format( _("`@\u200b{role.name}` will no longer be mentioned for stream alerts.").format(
role=role role=role
) )
) )
else: else:
await self.db.role(role).mention.set(True) await self.config.role(role).mention.set(True)
msg = _( msg = _(
"When a stream or community is live, `@\u200b{role.name}` will be mentioned." "When a stream or community is live, `@\u200b{role.name}` will be mentioned."
).format(role=role) ).format(role=role)
@ -576,7 +576,7 @@ class Streams(commands.Cog):
@commands.guild_only() @commands.guild_only()
async def autodelete(self, ctx: commands.Context, on_off: bool): async def autodelete(self, ctx: commands.Context, on_off: bool):
"""Toggle alert deletion for when streams go offline.""" """Toggle alert deletion for when streams go offline."""
await self.db.guild(ctx.guild).autodelete.set(on_off) await self.config.guild(ctx.guild).autodelete.set(on_off)
if on_off: if on_off:
await ctx.send(_("The notifications will be deleted once streams go offline.")) await ctx.send(_("The notifications will be deleted once streams go offline."))
else: else:
@ -587,12 +587,12 @@ class Streams(commands.Cog):
async def ignore_reruns(self, ctx: commands.Context): async def ignore_reruns(self, ctx: commands.Context):
"""Toggle excluding rerun streams from alerts.""" """Toggle excluding rerun streams from alerts."""
guild = ctx.guild guild = ctx.guild
current_setting = await self.db.guild(guild).ignore_reruns() current_setting = await self.config.guild(guild).ignore_reruns()
if current_setting: if current_setting:
await self.db.guild(guild).ignore_reruns.set(False) await self.config.guild(guild).ignore_reruns.set(False)
await ctx.send(_("Streams of type 'rerun' will be included in alerts.")) await ctx.send(_("Streams of type 'rerun' will be included in alerts."))
else: else:
await self.db.guild(guild).ignore_reruns.set(True) await self.config.guild(guild).ignore_reruns.set(True)
await ctx.send(_("Streams of type 'rerun' will no longer send an alert.")) await ctx.send(_("Streams of type 'rerun' will no longer send an alert."))
async def add_or_remove(self, ctx: commands.Context, stream): async def add_or_remove(self, ctx: commands.Context, stream):
@ -653,7 +653,7 @@ class Streams(commands.Cog):
await self.check_streams() await self.check_streams()
except asyncio.CancelledError: except asyncio.CancelledError:
pass pass
await asyncio.sleep(await self.db.refresh_timer()) await asyncio.sleep(await self.config.refresh_timer())
async def check_streams(self): async def check_streams(self):
for stream in self.streams: for stream in self.streams:
@ -670,7 +670,7 @@ class Streams(commands.Cog):
continue continue
for message in stream._messages_cache: for message in stream._messages_cache:
with contextlib.suppress(Exception): with contextlib.suppress(Exception):
autodelete = await self.db.guild(message.guild).autodelete() autodelete = await self.config.guild(message.guild).autodelete()
if autodelete: if autodelete:
await message.delete() await message.delete()
stream._messages_cache.clear() stream._messages_cache.clear()
@ -682,13 +682,15 @@ class Streams(commands.Cog):
channel = self.bot.get_channel(channel_id) channel = self.bot.get_channel(channel_id)
if not channel: if not channel:
continue continue
ignore_reruns = await self.db.guild(channel.guild).ignore_reruns() ignore_reruns = await self.config.guild(channel.guild).ignore_reruns()
if ignore_reruns and is_rerun: if ignore_reruns and is_rerun:
continue continue
mention_str, edited_roles = await self._get_mention_str(channel.guild) mention_str, edited_roles = await self._get_mention_str(channel.guild)
if mention_str: if mention_str:
alert_msg = await self.db.guild(channel.guild).live_message_mention() alert_msg = await self.config.guild(
channel.guild
).live_message_mention()
if alert_msg: if alert_msg:
content = alert_msg.format(mention=mention_str, stream=stream) content = alert_msg.format(mention=mention_str, stream=stream)
else: else:
@ -699,7 +701,9 @@ class Streams(commands.Cog):
), ),
) )
else: else:
alert_msg = await self.db.guild(channel.guild).live_message_nomention() alert_msg = await self.config.guild(
channel.guild
).live_message_nomention()
if alert_msg: if alert_msg:
content = alert_msg.format(stream=stream) content = alert_msg.format(stream=stream)
else: else:
@ -720,7 +724,7 @@ class Streams(commands.Cog):
"""Returns a 2-tuple with the string containing the mentions, and a list of """Returns a 2-tuple with the string containing the mentions, and a list of
all roles which need to have their `mentionable` property set back to False. all roles which need to have their `mentionable` property set back to False.
""" """
settings = self.db.guild(guild) settings = self.config.guild(guild)
mentions = [] mentions = []
edited_roles = [] edited_roles = []
if await settings.mention_everyone(): if await settings.mention_everyone():
@ -729,7 +733,7 @@ class Streams(commands.Cog):
mentions.append("@here") mentions.append("@here")
can_manage_roles = guild.me.guild_permissions.manage_roles can_manage_roles = guild.me.guild_permissions.manage_roles
for role in guild.roles: for role in guild.roles:
if await self.db.role(role).mention(): if await self.config.role(role).mention():
if can_manage_roles and not role.mentionable: if can_manage_roles and not role.mentionable:
try: try:
await role.edit(mentionable=True) await role.edit(mentionable=True)
@ -755,7 +759,7 @@ class Streams(commands.Cog):
async def load_streams(self): async def load_streams(self):
streams = [] streams = []
for raw_stream in await self.db.streams(): for raw_stream in await self.config.streams():
_class = getattr(_streamtypes, raw_stream["type"], None) _class = getattr(_streamtypes, raw_stream["type"], None)
if not _class: if not _class:
continue continue
@ -786,7 +790,7 @@ class Streams(commands.Cog):
for stream in self.streams: for stream in self.streams:
raw_streams.append(stream.export()) raw_streams.append(stream.export())
await self.db.streams.set(raw_streams) await self.config.streams.set(raw_streams)
def cog_unload(self): def cog_unload(self):
if self.task: if self.task:

32
redbot/cogs/trivia/trivia.py
View File

@ -42,9 +42,9 @@ class Trivia(commands.Cog):
def __init__(self): def __init__(self):
super().__init__() super().__init__()
self.trivia_sessions = [] self.trivia_sessions = []
self.conf = Config.get_conf(self, identifier=UNIQUE_ID, force_registration=True) self.config = Config.get_conf(self, identifier=UNIQUE_ID, force_registration=True)
self.conf.register_guild( self.config.register_guild(
max_score=10, max_score=10,
timeout=120.0, timeout=120.0,
delay=15.0, delay=15.0,
@ -54,7 +54,7 @@ class Trivia(commands.Cog):
allow_override=True, allow_override=True,
) )
self.conf.register_member(wins=0, games=0, total_score=0) self.config.register_member(wins=0, games=0, total_score=0)
@commands.group() @commands.group()
@commands.guild_only() @commands.guild_only()
@ -62,7 +62,7 @@ class Trivia(commands.Cog):
async def triviaset(self, ctx: commands.Context): async def triviaset(self, ctx: commands.Context):
"""Manage Trivia settings.""" """Manage Trivia settings."""
if ctx.invoked_subcommand is None: if ctx.invoked_subcommand is None:
settings = self.conf.guild(ctx.guild) settings = self.config.guild(ctx.guild)
settings_dict = await settings.all() settings_dict = await settings.all()
msg = box( msg = box(
_( _(
@ -85,7 +85,7 @@ class Trivia(commands.Cog):
if score < 0: if score < 0:
await ctx.send(_("Score must be greater than 0.")) await ctx.send(_("Score must be greater than 0."))
return return
settings = self.conf.guild(ctx.guild) settings = self.config.guild(ctx.guild)
await settings.max_score.set(score) await settings.max_score.set(score)
await ctx.send(_("Done. Points required to win set to {num}.").format(num=score)) await ctx.send(_("Done. Points required to win set to {num}.").format(num=score))
@ -95,14 +95,14 @@ class Trivia(commands.Cog):
if seconds < 4.0: if seconds < 4.0:
await ctx.send(_("Must be at least 4 seconds.")) await ctx.send(_("Must be at least 4 seconds."))
return return
settings = self.conf.guild(ctx.guild) settings = self.config.guild(ctx.guild)
await settings.delay.set(seconds) await settings.delay.set(seconds)
await ctx.send(_("Done. Maximum seconds to answer set to {num}.").format(num=seconds)) await ctx.send(_("Done. Maximum seconds to answer set to {num}.").format(num=seconds))
@triviaset.command(name="stopafter") @triviaset.command(name="stopafter")
async def triviaset_stopafter(self, ctx: commands.Context, seconds: finite_float): async def triviaset_stopafter(self, ctx: commands.Context, seconds: finite_float):
"""Set how long until trivia stops due to no response.""" """Set how long until trivia stops due to no response."""
settings = self.conf.guild(ctx.guild) settings = self.config.guild(ctx.guild)
if seconds < await settings.delay(): if seconds < await settings.delay():
await ctx.send(_("Must be larger than the answer time limit.")) await ctx.send(_("Must be larger than the answer time limit."))
return return
@ -116,7 +116,7 @@ class Trivia(commands.Cog):
@triviaset.command(name="override") @triviaset.command(name="override")
async def triviaset_allowoverride(self, ctx: commands.Context, enabled: bool): async def triviaset_allowoverride(self, ctx: commands.Context, enabled: bool):
"""Allow/disallow trivia lists to override settings.""" """Allow/disallow trivia lists to override settings."""
settings = self.conf.guild(ctx.guild) settings = self.config.guild(ctx.guild)
await settings.allow_override.set(enabled) await settings.allow_override.set(enabled)
if enabled: if enabled:
await ctx.send( await ctx.send(
@ -136,7 +136,7 @@ class Trivia(commands.Cog):
If enabled, the bot will gain a point if no one guesses correctly. If enabled, the bot will gain a point if no one guesses correctly.
""" """
settings = self.conf.guild(ctx.guild) settings = self.config.guild(ctx.guild)
await settings.bot_plays.set(enabled) await settings.bot_plays.set(enabled)
if enabled: if enabled:
await ctx.send(_("Done. I'll now gain a point if users don't answer in time.")) await ctx.send(_("Done. I'll now gain a point if users don't answer in time."))
@ -150,7 +150,7 @@ class Trivia(commands.Cog):
If enabled, the bot will reveal the answer if no one guesses correctly If enabled, the bot will reveal the answer if no one guesses correctly
in time. in time.
""" """
settings = self.conf.guild(ctx.guild) settings = self.config.guild(ctx.guild)
await settings.reveal_answer.set(enabled) await settings.reveal_answer.set(enabled)
if enabled: if enabled:
await ctx.send(_("Done. I'll reveal the answer if no one knows it.")) await ctx.send(_("Done. I'll reveal the answer if no one knows it."))
@ -170,7 +170,7 @@ class Trivia(commands.Cog):
The number of credits is determined by multiplying their total score by The number of credits is determined by multiplying their total score by
this multiplier. this multiplier.
""" """
settings = self.conf.guild(ctx.guild) settings = self.config.guild(ctx.guild)
if multiplier < 0: if multiplier < 0:
await ctx.send(_("Multiplier must be at least 0.")) await ctx.send(_("Multiplier must be at least 0."))
return return
@ -307,7 +307,7 @@ class Trivia(commands.Cog):
_("The trivia list was parsed successfully, however it appears to be empty!") _("The trivia list was parsed successfully, however it appears to be empty!")
) )
return return
settings = await self.conf.guild(ctx.guild).all() settings = await self.config.guild(ctx.guild).all()
config = trivia_dict.pop("CONFIG", None) config = trivia_dict.pop("CONFIG", None)
if config and settings["allow_override"]: if config and settings["allow_override"]:
settings.update(config) settings.update(config)
@ -383,7 +383,7 @@ class Trivia(commands.Cog):
) )
return return
guild = ctx.guild guild = ctx.guild
data = await self.conf.all_members(guild) data = await self.config.all_members(guild)
data = {guild.get_member(u): d for u, d in data.items()} data = {guild.get_member(u): d for u, d in data.items()}
data.pop(None, None) # remove any members which aren't in the guild data.pop(None, None) # remove any members which aren't in the guild
await self.send_leaderboard(ctx, data, key, top) await self.send_leaderboard(ctx, data, key, top)
@ -411,7 +411,7 @@ class Trivia(commands.Cog):
).format(field_name=sort_by, prefix=ctx.clean_prefix) ).format(field_name=sort_by, prefix=ctx.clean_prefix)
) )
return return
data = await self.conf.all_members() data = await self.config.all_members()
collated_data = {} collated_data = {}
for guild_id, guild_data in data.items(): for guild_id, guild_data in data.items():
guild = ctx.bot.get_guild(guild_id) guild = ctx.bot.get_guild(guild_id)
@ -555,12 +555,12 @@ class Trivia(commands.Cog):
for member, score in session.scores.items(): for member, score in session.scores.items():
if member.id == session.ctx.bot.user.id: if member.id == session.ctx.bot.user.id:
continue continue
stats = await self.conf.member(member).all() stats = await self.config.member(member).all()
if score == max_score: if score == max_score:
stats["wins"] += 1 stats["wins"] += 1
stats["total_score"] += score stats["total_score"] += score
stats["games"] += 1 stats["games"] += 1
await self.conf.member(member).set(stats) await self.config.member(member).set(stats)
def get_trivia_list(self, category: str) -> dict: def get_trivia_list(self, category: str) -> dict:
"""Get the trivia list corresponding to the given category. """Get the trivia list corresponding to the given category.

74
redbot/core/bank.py
View File

@ -64,16 +64,16 @@ _DEFAULT_MEMBER = {"name": "", "balance": 0, "created_at": 0}
_DEFAULT_USER = _DEFAULT_MEMBER _DEFAULT_USER = _DEFAULT_MEMBER
_conf: Config = None _config: Config = None
def _init(): def _init():
global _conf global _config
_conf = Config.get_conf(None, 384734293238749, cog_name="Bank", force_registration=True) _config = Config.get_conf(None, 384734293238749, cog_name="Bank", force_registration=True)
_conf.register_global(**_DEFAULT_GLOBAL) _config.register_global(**_DEFAULT_GLOBAL)
_conf.register_guild(**_DEFAULT_GUILD) _config.register_guild(**_DEFAULT_GUILD)
_conf.register_member(**_DEFAULT_MEMBER) _config.register_member(**_DEFAULT_MEMBER)
_conf.register_user(**_DEFAULT_USER) _config.register_user(**_DEFAULT_USER)
class Account: class Account:
@ -211,9 +211,9 @@ async def set_balance(member: Union[discord.Member, discord.User], amount: int)
user=member.display_name, max_balance=max_bal, currency_name=currency user=member.display_name, max_balance=max_bal, currency_name=currency
) )
if await is_global(): if await is_global():
group = _conf.user(member) group = _config.user(member)
else: else:
group = _conf.member(member) group = _config.member(member)
await group.balance.set(amount) await group.balance.set(amount)
if await group.created_at() == 0: if await group.created_at() == 0:
@ -376,9 +376,9 @@ async def wipe_bank(guild: Optional[discord.Guild] = None) -> None:
""" """
if await is_global(): if await is_global():
await _conf.clear_all_users() await _config.clear_all_users()
else: else:
await _conf.clear_all_members(guild) await _config.clear_all_members(guild)
async def bank_prune(bot: Red, guild: discord.Guild = None, user_id: int = None) -> None: async def bank_prune(bot: Red, guild: discord.Guild = None, user_id: int = None) -> None:
@ -407,14 +407,14 @@ async def bank_prune(bot: Red, guild: discord.Guild = None, user_id: int = None)
if global_bank: if global_bank:
_guilds = [g for g in bot.guilds if not g.unavailable and g.large and not g.chunked] _guilds = [g for g in bot.guilds if not g.unavailable and g.large and not g.chunked]
_uguilds = [g for g in bot.guilds if g.unavailable] _uguilds = [g for g in bot.guilds if g.unavailable]
group = _conf._get_base_group(_conf.USER) group = _config._get_base_group(_config.USER)
else: else:
if guild is None: if guild is None:
raise BankPruneError("'guild' can't be None when pruning a local bank") raise BankPruneError("'guild' can't be None when pruning a local bank")
_guilds = [guild] if not guild.unavailable and guild.large else [] _guilds = [guild] if not guild.unavailable and guild.large else []
_uguilds = [guild] if guild.unavailable else [] _uguilds = [guild] if guild.unavailable else []
group = _conf._get_base_group(_conf.MEMBER, str(guild.id)) group = _config._get_base_group(_config.MEMBER, str(guild.id))
if user_id is None: if user_id is None:
await bot.request_offline_members(*_guilds) await bot.request_offline_members(*_guilds)
@ -458,7 +458,7 @@ async def get_leaderboard(positions: int = None, guild: discord.Guild = None) ->
""" """
if await is_global(): if await is_global():
raw_accounts = await _conf.all_users() raw_accounts = await _config.all_users()
if guild is not None: if guild is not None:
tmp = raw_accounts.copy() tmp = raw_accounts.copy()
for acc in tmp: for acc in tmp:
@ -467,7 +467,7 @@ async def get_leaderboard(positions: int = None, guild: discord.Guild = None) ->
else: else:
if guild is None: if guild is None:
raise TypeError("Expected a guild, got NoneType object instead!") raise TypeError("Expected a guild, got NoneType object instead!")
raw_accounts = await _conf.all_members(guild) raw_accounts = await _config.all_members(guild)
sorted_acc = sorted(raw_accounts.items(), key=lambda x: x[1]["balance"], reverse=True) sorted_acc = sorted(raw_accounts.items(), key=lambda x: x[1]["balance"], reverse=True)
if positions is None: if positions is None:
return sorted_acc return sorted_acc
@ -530,9 +530,9 @@ async def get_account(member: Union[discord.Member, discord.User]) -> Account:
""" """
if await is_global(): if await is_global():
all_accounts = await _conf.all_users() all_accounts = await _config.all_users()
else: else:
all_accounts = await _conf.all_members(member.guild) all_accounts = await _config.all_members(member.guild)
if member.id not in all_accounts: if member.id not in all_accounts:
acc_data = {"name": member.display_name, "created_at": _DEFAULT_MEMBER["created_at"]} acc_data = {"name": member.display_name, "created_at": _DEFAULT_MEMBER["created_at"]}
@ -556,7 +556,7 @@ async def is_global() -> bool:
:code:`True` if the bank is global, otherwise :code:`False`. :code:`True` if the bank is global, otherwise :code:`False`.
""" """
return await _conf.is_global() return await _config.is_global()
async def set_global(global_: bool) -> bool: async def set_global(global_: bool) -> bool:
@ -586,11 +586,11 @@ async def set_global(global_: bool) -> bool:
return global_ return global_
if await is_global(): if await is_global():
await _conf.clear_all_users() await _config.clear_all_users()
else: else:
await _conf.clear_all_members() await _config.clear_all_members()
await _conf.is_global.set(global_) await _config.is_global.set(global_)
return global_ return global_
@ -615,9 +615,9 @@ async def get_bank_name(guild: discord.Guild = None) -> str:
""" """
if await is_global(): if await is_global():
return await _conf.bank_name() return await _config.bank_name()
elif guild is not None: elif guild is not None:
return await _conf.guild(guild).bank_name() return await _config.guild(guild).bank_name()
else: else:
raise RuntimeError("Guild parameter is required and missing.") raise RuntimeError("Guild parameter is required and missing.")
@ -645,9 +645,9 @@ async def set_bank_name(name: str, guild: discord.Guild = None) -> str:
""" """
if await is_global(): if await is_global():
await _conf.bank_name.set(name) await _config.bank_name.set(name)
elif guild is not None: elif guild is not None:
await _conf.guild(guild).bank_name.set(name) await _config.guild(guild).bank_name.set(name)
else: else:
raise RuntimeError("Guild must be provided if setting the name of a guild-specific bank.") raise RuntimeError("Guild must be provided if setting the name of a guild-specific bank.")
return name return name
@ -674,9 +674,9 @@ async def get_currency_name(guild: discord.Guild = None) -> str:
""" """
if await is_global(): if await is_global():
return await _conf.currency() return await _config.currency()
elif guild is not None: elif guild is not None:
return await _conf.guild(guild).currency() return await _config.guild(guild).currency()
else: else:
raise RuntimeError("Guild must be provided.") raise RuntimeError("Guild must be provided.")
@ -704,9 +704,9 @@ async def set_currency_name(name: str, guild: discord.Guild = None) -> str:
""" """
if await is_global(): if await is_global():
await _conf.currency.set(name) await _config.currency.set(name)
elif guild is not None: elif guild is not None:
await _conf.guild(guild).currency.set(name) await _config.guild(guild).currency.set(name)
else: else:
raise RuntimeError( raise RuntimeError(
"Guild must be provided if setting the currency name of a guild-specific bank." "Guild must be provided if setting the currency name of a guild-specific bank."
@ -735,9 +735,9 @@ async def get_max_balance(guild: discord.Guild = None) -> int:
""" """
if await is_global(): if await is_global():
return await _conf.max_balance() return await _config.max_balance()
elif guild is not None: elif guild is not None:
return await _conf.guild(guild).max_balance() return await _config.guild(guild).max_balance()
else: else:
raise RuntimeError("Guild must be provided.") raise RuntimeError("Guild must be provided.")
@ -773,9 +773,9 @@ async def set_max_balance(amount: int, guild: discord.Guild = None) -> int:
) )
if await is_global(): if await is_global():
await _conf.max_balance.set(amount) await _config.max_balance.set(amount)
elif guild is not None: elif guild is not None:
await _conf.guild(guild).max_balance.set(amount) await _config.guild(guild).max_balance.set(amount)
else: else:
raise RuntimeError( raise RuntimeError(
"Guild must be provided if setting the maximum balance of a guild-specific bank." "Guild must be provided if setting the maximum balance of a guild-specific bank."
@ -804,9 +804,9 @@ async def get_default_balance(guild: discord.Guild = None) -> int:
""" """
if await is_global(): if await is_global():
return await _conf.default_balance() return await _config.default_balance()
elif guild is not None: elif guild is not None:
return await _conf.guild(guild).default_balance() return await _config.guild(guild).default_balance()
else: else:
raise RuntimeError("Guild is missing and required!") raise RuntimeError("Guild is missing and required!")
@ -846,9 +846,9 @@ async def set_default_balance(amount: int, guild: discord.Guild = None) -> int:
) )
if await is_global(): if await is_global():
await _conf.default_balance.set(amount) await _config.default_balance.set(amount)
elif guild is not None: elif guild is not None:
await _conf.guild(guild).default_balance.set(amount) await _config.guild(guild).default_balance.set(amount)
else: else:
raise RuntimeError("Guild is missing and required.") raise RuntimeError("Guild is missing and required.")

12
redbot/core/cog_manager.py
View File

@ -38,10 +38,10 @@ class CogManager:
CORE_PATH = Path(redbot.cogs.__path__[0]) CORE_PATH = Path(redbot.cogs.__path__[0])
def __init__(self): def __init__(self):
self.conf = Config.get_conf(self, 2938473984732, True) self.config = Config.get_conf(self, 2938473984732, True)
tmp_cog_install_path = cog_data_path(self) / "cogs" tmp_cog_install_path = cog_data_path(self) / "cogs"
tmp_cog_install_path.mkdir(parents=True, exist_ok=True) tmp_cog_install_path.mkdir(parents=True, exist_ok=True)
self.conf.register_global(paths=[], install_path=str(tmp_cog_install_path)) self.config.register_global(paths=[], install_path=str(tmp_cog_install_path))
async def paths(self) -> List[Path]: async def paths(self) -> List[Path]:
"""Get all currently valid path directories, in order of priority """Get all currently valid path directories, in order of priority
@ -68,7 +68,7 @@ class CogManager:
The path to the directory where 3rd party cogs are stored. The path to the directory where 3rd party cogs are stored.
""" """
return Path(await self.conf.install_path()).resolve() return Path(await self.config.install_path()).resolve()
async def user_defined_paths(self) -> List[Path]: async def user_defined_paths(self) -> List[Path]:
"""Get a list of user-defined cog paths. """Get a list of user-defined cog paths.
@ -81,7 +81,7 @@ class CogManager:
A list of user-defined paths. A list of user-defined paths.
""" """
return list(map(Path, deduplicate_iterables(await self.conf.paths()))) return list(map(Path, deduplicate_iterables(await self.config.paths())))
async def set_install_path(self, path: Path) -> Path: async def set_install_path(self, path: Path) -> Path:
"""Set the install path for 3rd party cogs. """Set the install path for 3rd party cogs.
@ -110,7 +110,7 @@ class CogManager:
if not path.is_dir(): if not path.is_dir():
raise ValueError("The install path must be an existing directory.") raise ValueError("The install path must be an existing directory.")
resolved = path.resolve() resolved = path.resolve()
await self.conf.install_path.set(str(resolved)) await self.config.install_path.set(str(resolved))
return resolved return resolved
@staticmethod @staticmethod
@ -192,7 +192,7 @@ class CogManager:
""" """
str_paths = list(map(str, paths_)) str_paths = list(map(str, paths_))
await self.conf.paths.set(str_paths) await self.config.paths.set(str_paths)
async def _find_ext_cog(self, name: str) -> ModuleSpec: async def _find_ext_cog(self, name: str) -> ModuleSpec:
""" """

26
redbot/core/config.py
View File

@ -197,11 +197,11 @@ class Value:
------- -------
:: ::
foo = await conf.guild(some_guild).foo() foo = await config.guild(some_guild).foo()
# Is equivalent to this # Is equivalent to this
group_obj = conf.guild(some_guild) group_obj = config.guild(some_guild)
value_obj = group_obj.foo value_obj = group_obj.foo
foo = await value_obj() foo = await value_obj()
@ -241,10 +241,10 @@ class Value:
:: ::
# Sets global value "foo" to False # Sets global value "foo" to False
await conf.foo.set(False) await config.foo.set(False)
# Sets guild specific value of "bar" to True # Sets guild specific value of "bar" to True
await conf.guild(some_guild).bar.set(True) await config.guild(some_guild).bar.set(True)
Parameters Parameters
---------- ----------
@ -367,7 +367,7 @@ class Group(Value):
For example:: For example::
await conf.clear_raw("foo", "bar") await config.clear_raw("foo", "bar")
# is equivalent to # is equivalent to
@ -430,7 +430,7 @@ class Group(Value):
user = ctx.author user = ctx.author
# Where the value of item is the name of the data field in Config # Where the value of item is the name of the data field in Config
await ctx.send(await self.conf.user(user).get_attr(item).foo()) await ctx.send(await self.config.user(user).get_attr(item).foo())
Parameters Parameters
---------- ----------
@ -455,7 +455,7 @@ class Group(Value):
For example:: For example::
d = await conf.get_raw("foo", "bar") d = await config.get_raw("foo", "bar")
# is equivalent to # is equivalent to
@ -567,7 +567,7 @@ class Group(Value):
For example:: For example::
await conf.set_raw("foo", "bar", value="baz") await config.set_raw("foo", "bar", value="baz")
# is equivalent to # is equivalent to
@ -602,7 +602,7 @@ class Config(metaclass=ConfigMeta):
:python:`global` method because global data is accessed by :python:`global` method because global data is accessed by
normal attribute access:: normal attribute access::
await conf.foo() await config.foo()
Attributes Attributes
---------- ----------
@ -821,11 +821,11 @@ class Config(metaclass=ConfigMeta):
-------- --------
You can register a single value or multiple values:: You can register a single value or multiple values::
conf.register_global( config.register_global(
foo=True foo=True
) )
conf.register_global( config.register_global(
bar=False, bar=False,
baz=None baz=None
) )
@ -840,7 +840,7 @@ class Config(metaclass=ConfigMeta):
} }
# Will register `foo.bar` == True and `foo.baz` == False # Will register `foo.bar` == True and `foo.baz` == False
conf.register_global( config.register_global(
**_defaults **_defaults
) )
@ -848,7 +848,7 @@ class Config(metaclass=ConfigMeta):
using double underscore as a variable name separator:: using double underscore as a variable name separator::
# This is equivalent to the previous example # This is equivalent to the previous example
conf.register_global( config.register_global(
foo__bar=True, foo__bar=True,
foo__baz=False foo__baz=False
) )

86
redbot/core/modlog.py
View File

@ -40,7 +40,7 @@ __all__ = [
"reset_cases", "reset_cases",
] ]
_conf: Optional[Config] = None _config: Optional[Config] = None
_bot_ref: Optional[Red] = None _bot_ref: Optional[Red] = None
_CASETYPES = "CASETYPES" _CASETYPES = "CASETYPES"
@ -52,17 +52,17 @@ _ = Translator("ModLog", __file__)
async def _init(bot: Red): async def _init(bot: Red):
global _conf global _config
global _bot_ref global _bot_ref
_bot_ref = bot _bot_ref = bot
_conf = Config.get_conf(None, 1354799444, cog_name="ModLog") _config = Config.get_conf(None, 1354799444, cog_name="ModLog")
_conf.register_global(schema_version=1) _config.register_global(schema_version=1)
_conf.register_guild(mod_log=None, casetypes={}, latest_case_number=0) _config.register_guild(mod_log=None, casetypes={}, latest_case_number=0)
_conf.init_custom(_CASETYPES, 1) _config.init_custom(_CASETYPES, 1)
_conf.init_custom(_CASES, 2) _config.init_custom(_CASES, 2)
_conf.register_custom(_CASETYPES) _config.register_custom(_CASETYPES)
_conf.register_custom(_CASES) _config.register_custom(_CASES)
await _migrate_config(from_version=await _conf.schema_version(), to_version=_SCHEMA_VERSION) await _migrate_config(from_version=await _config.schema_version(), to_version=_SCHEMA_VERSION)
await register_casetypes(all_generics) await register_casetypes(all_generics)
async def on_member_ban(guild: discord.Guild, member: discord.Member): async def on_member_ban(guild: discord.Guild, member: discord.Member):
@ -149,9 +149,9 @@ async def handle_auditype_key():
for inner_key, inner_value in casetype_data.items() for inner_key, inner_value in casetype_data.items()
if inner_key != "audit_type" if inner_key != "audit_type"
} }
for casetype_name, casetype_data in (await _conf.custom(_CASETYPES).all()).items() for casetype_name, casetype_data in (await _config.custom(_CASETYPES).all()).items()
} }
await _conf.custom(_CASETYPES).set(all_casetypes) await _config.custom(_CASETYPES).set(all_casetypes)
async def _migrate_config(from_version: int, to_version: int): async def _migrate_config(from_version: int, to_version: int):
@ -160,40 +160,42 @@ async def _migrate_config(from_version: int, to_version: int):
if from_version < 2 <= to_version: if from_version < 2 <= to_version:
# casetypes go from GLOBAL -> casetypes to CASETYPES # casetypes go from GLOBAL -> casetypes to CASETYPES
all_casetypes = await _conf.get_raw("casetypes", default={}) all_casetypes = await _config.get_raw("casetypes", default={})
if all_casetypes: if all_casetypes:
await _conf.custom(_CASETYPES).set(all_casetypes) await _config.custom(_CASETYPES).set(all_casetypes)
# cases go from GUILD -> guild_id -> cases to CASES -> guild_id -> cases # cases go from GUILD -> guild_id -> cases to CASES -> guild_id -> cases
all_guild_data = await _conf.all_guilds() all_guild_data = await _config.all_guilds()
all_cases = {} all_cases = {}
for guild_id, guild_data in all_guild_data.items(): for guild_id, guild_data in all_guild_data.items():
guild_cases = guild_data.pop("cases", None) guild_cases = guild_data.pop("cases", None)
if guild_cases: if guild_cases:
all_cases[str(guild_id)] = guild_cases all_cases[str(guild_id)] = guild_cases
await _conf.custom(_CASES).set(all_cases) await _config.custom(_CASES).set(all_cases)
# new schema is now in place # new schema is now in place
await _conf.schema_version.set(2) await _config.schema_version.set(2)
# migration done, now let's delete all the old stuff # migration done, now let's delete all the old stuff
await _conf.clear_raw("casetypes") await _config.clear_raw("casetypes")
for guild_id in all_guild_data: for guild_id in all_guild_data:
await _conf.guild(cast(discord.Guild, discord.Object(id=guild_id))).clear_raw("cases") await _config.guild(cast(discord.Guild, discord.Object(id=guild_id))).clear_raw(
"cases"
)
if from_version < 3 <= to_version: if from_version < 3 <= to_version:
await handle_auditype_key() await handle_auditype_key()
await _conf.schema_version.set(3) await _config.schema_version.set(3)
if from_version < 4 <= to_version: if from_version < 4 <= to_version:
# set latest_case_number # set latest_case_number
for guild_id, cases in (await _conf.custom(_CASES).all()).items(): for guild_id, cases in (await _config.custom(_CASES).all()).items():
if cases: if cases:
await _conf.guild( await _config.guild(
cast(discord.Guild, discord.Object(id=guild_id)) cast(discord.Guild, discord.Object(id=guild_id))
).latest_case_number.set(max(map(int, cases.keys()))) ).latest_case_number.set(max(map(int, cases.keys())))
await _conf.schema_version.set(4) await _config.schema_version.set(4)
class Case: class Case:
@ -253,7 +255,7 @@ class Case:
if not isinstance(self.user, int): if not isinstance(self.user, int):
self.last_known_username = f"{self.user.name}#{self.user.discriminator}" self.last_known_username = f"{self.user.name}#{self.user.discriminator}"
await _conf.custom(_CASES, str(self.guild.id), str(self.case_number)).set(self.to_json()) await _config.custom(_CASES, str(self.guild.id), str(self.case_number)).set(self.to_json())
self.bot.dispatch("modlog_case_edit", self) self.bot.dispatch("modlog_case_edit", self)
if not self.message: if not self.message:
return return
@ -538,7 +540,7 @@ class CaseType:
"image": self.image, "image": self.image,
"case_str": self.case_str, "case_str": self.case_str,
} }
await _conf.custom(_CASETYPES, self.name).set(data) await _config.custom(_CASETYPES, self.name).set(data)
async def is_enabled(self) -> bool: async def is_enabled(self) -> bool:
""" """
@ -555,7 +557,7 @@ class CaseType:
""" """
if not self.guild: if not self.guild:
return False return False
return await _conf.guild(self.guild).casetypes.get_raw( return await _config.guild(self.guild).casetypes.get_raw(
self.name, default=self.default_setting self.name, default=self.default_setting
) )
@ -569,7 +571,7 @@ class CaseType:
True if the case should be enabled, otherwise False""" True if the case should be enabled, otherwise False"""
if not self.guild: if not self.guild:
return return
await _conf.guild(self.guild).casetypes.set_raw(self.name, value=enabled) await _config.guild(self.guild).casetypes.set_raw(self.name, value=enabled)
@classmethod @classmethod
def from_json(cls, name: str, data: dict, **kwargs): def from_json(cls, name: str, data: dict, **kwargs):
@ -619,7 +621,7 @@ async def get_case(case_number: int, guild: discord.Guild, bot: Red) -> Case:
""" """
case = await _conf.custom(_CASES, str(guild.id), str(case_number)).all() case = await _config.custom(_CASES, str(guild.id), str(case_number)).all()
if not case: if not case:
raise RuntimeError("That case does not exist for guild {}".format(guild.name)) raise RuntimeError("That case does not exist for guild {}".format(guild.name))
mod_channel = await get_modlog_channel(guild) mod_channel = await get_modlog_channel(guild)
@ -642,7 +644,7 @@ async def get_latest_case(guild: discord.Guild, bot: Red) -> Optional[Case]:
The latest case object. `None` if it the guild has no cases. The latest case object. `None` if it the guild has no cases.
""" """
case_number = await _conf.guild(guild).latest_case_number() case_number = await _config.guild(guild).latest_case_number()
if case_number: if case_number:
return await get_case(case_number, guild, bot) return await get_case(case_number, guild, bot)
@ -664,7 +666,7 @@ async def get_all_cases(guild: discord.Guild, bot: Red) -> List[Case]:
A list of all cases for the guild A list of all cases for the guild
""" """
cases = await _conf.custom(_CASES, str(guild.id)).all() cases = await _config.custom(_CASES, str(guild.id)).all()
mod_channel = await get_modlog_channel(guild) mod_channel = await get_modlog_channel(guild)
return [ return [
await Case.from_json(mod_channel, bot, case_number, case_data) await Case.from_json(mod_channel, bot, case_number, case_data)
@ -704,7 +706,7 @@ async def get_cases_for_member(
Fetching the user failed. Fetching the user failed.
""" """
cases = await _conf.custom(_CASES, str(guild.id)).all() cases = await _config.custom(_CASES, str(guild.id)).all()
if not (member_id or member): if not (member_id or member):
raise ValueError("Expected a member or a member id to be provided.") from None raise ValueError("Expected a member or a member id to be provided.") from None
@ -776,10 +778,10 @@ async def create_case(
if user == bot.user: if user == bot.user:
return return
async with _conf.guild(guild).latest_case_number.get_lock(): async with _config.guild(guild).latest_case_number.get_lock():
# We're getting the case number from config, incrementing it, awaiting something, then # We're getting the case number from config, incrementing it, awaiting something, then
# setting it again. This warrants acquiring the lock. # setting it again. This warrants acquiring the lock.
next_case_number = await _conf.guild(guild).latest_case_number() + 1 next_case_number = await _config.guild(guild).latest_case_number() + 1
case = Case( case = Case(
bot, bot,
@ -796,8 +798,8 @@ async def create_case(
modified_at=None, modified_at=None,
message=None, message=None,
) )
await _conf.custom(_CASES, str(guild.id), str(next_case_number)).set(case.to_json()) await _config.custom(_CASES, str(guild.id), str(next_case_number)).set(case.to_json())
await _conf.guild(guild).latest_case_number.set(next_case_number) await _config.guild(guild).latest_case_number.set(next_case_number)
bot.dispatch("modlog_case_create", case) bot.dispatch("modlog_case_create", case)
try: try:
@ -831,7 +833,7 @@ async def get_casetype(name: str, guild: Optional[discord.Guild] = None) -> Opti
Optional[CaseType] Optional[CaseType]
Case type with provided name. If such case type doesn't exist this will be `None`. Case type with provided name. If such case type doesn't exist this will be `None`.
""" """
data = await _conf.custom(_CASETYPES, name).all() data = await _config.custom(_CASETYPES, name).all()
if not data: if not data:
return return
casetype = CaseType.from_json(name, data) casetype = CaseType.from_json(name, data)
@ -851,7 +853,7 @@ async def get_all_casetypes(guild: discord.Guild = None) -> List[CaseType]:
""" """
return [ return [
CaseType.from_json(name, data, guild=guild) CaseType.from_json(name, data, guild=guild)
for name, data in (await _conf.custom(_CASETYPES).all()).items() for name, data in (await _config.custom(_CASETYPES).all()).items()
] ]
@ -985,10 +987,10 @@ async def get_modlog_channel(guild: discord.Guild) -> discord.TextChannel:
""" """
if hasattr(guild, "get_channel"): if hasattr(guild, "get_channel"):
channel = guild.get_channel(await _conf.guild(guild).mod_log()) channel = guild.get_channel(await _config.guild(guild).mod_log())
else: else:
# For unit tests only # For unit tests only
channel = await _conf.guild(guild).mod_log() channel = await _config.guild(guild).mod_log()
if channel is None: if channel is None:
raise RuntimeError("Failed to get the mod log channel!") raise RuntimeError("Failed to get the mod log channel!")
return channel return channel
@ -1013,7 +1015,7 @@ async def set_modlog_channel(
`True` if successful `True` if successful
""" """
await _conf.guild(guild).mod_log.set(channel.id if hasattr(channel, "id") else None) await _config.guild(guild).mod_log.set(channel.id if hasattr(channel, "id") else None)
return True return True
@ -1027,8 +1029,8 @@ async def reset_cases(guild: discord.Guild) -> None:
The guild to reset cases for The guild to reset cases for
""" """
await _conf.custom(_CASES, str(guild.id)).clear() await _config.custom(_CASES, str(guild.id)).clear()
await _conf.guild(guild).latest_case_number.clear() await _config.guild(guild).latest_case_number.clear()
def _strfdelta(delta): def _strfdelta(delta):