Fix the following issue:
Add a scoped configuration system for cogs
Red's cogs currently have no consistent way to declare the settings they use or to read and write those settings at different scopes (the bot as a whole, a particular guild, a channel, a role, a user, or a specific member of a guild). We want a small configuration subsystem that gives every cog a single object to work with.
Add a Config class, importable as from core.config import Config, with the
behaviour described below.
Obtaining a config object
Config.get_conf(cog_name, unique_identifier=0, force_registration=False)
returns a fresh config object for a cog. cog_name is a string; the other two
arguments are keyword options. force_registration controls the strict mode
described further down and defaults to False.
Registering defaults
A cog declares the keys it uses, per scope, by registering defaults:
register_global(**defaults)register_guild(**defaults)register_channel(**defaults)register_role(**defaults)register_user(**defaults)register_member(**defaults)
Each call records the given keys together with their default values for that scope. Calling a register method more than once merges the new keys with the ones already registered for that scope (later calls override earlier defaults for the same key). Defaults for one scope are independent from every other scope.
Reading and writing values
The config object itself represents the global scope. To work with another scope you ask for it by id:
config.guild(guild_id)config.channel(channel_id)config.role(role_id)config.user(user_id)config.member(guild_id, member_id)
An id may be given either as an integer or as an object that exposes an id
attribute (the object's id is used). Each of these returns a scoped view of
the configuration.
Reading a value is done by calling the key as a method on the relevant scope.
On the global scope config.foo() returns the value of foo; on another scope
config.guild(123).foo() returns the value of foo for guild 123. If no
value has been stored for that key in that scope, the registered default for the
scope is returned. If the key was never registered (and strict mode is off), the
reader returns None.
Writing a value is asynchronous: await scope.set(key, value) stores value
for key in that scope, e.g. await config.set("foo", 1) for the global scope
or await config.guild(123).set("foo", 1) for a guild. After a value has been
set, reading the same key in the same scope returns the stored value.
await scope.clear() removes every stored value for that exact scope, so
subsequent reads fall back to the registered defaults again.
Scope isolation
Scopes and individual ids are fully isolated. Storing a value for one guild must
not change what another guild, the global scope, or any other scope reports.
Members are identified by the pair (guild_id, member_id), so the same member
id under two different guilds is two distinct scopes.
Strict mode
When a config object is created with force_registration=True, reading or
writing a key that has not been registered for the scope being used raises
AttributeError. When force_registration is False (the default), reading an
unregistered key returns None and writing an unregistered key is allowed.