Before v1.0, all snowflakes (the ``id`` attribute) were strings. This has been changed to :class:`int`.

Quick example: ::

    # before
    ch = client.get_channel('84319995256905728')
    if message.author.id == '80528701850124288':
        ...

    # after
    ch = client.get_channel(84319995256905728)
    if message.author.id == 80528701850124288:
        ...

This change allows for fewer errors when using the Copy ID feature in the official client since you no longer have
to wrap it in quotes and allows for optimisation opportunities by allowing ETF to be used instead of JSON internally.

Server is now Guild

As mentioned earlier, a lot of functionality was moved out of :class:`Client` and
put into their respective :ref:`model <discord_api_models>`.

A list of these changes is enumerated below.

+---------------------------------------+------------------------------------------------------------------------------+
|                 Before                |                                    After                                     |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.add_reaction``               | :meth:`Message.add_reaction`                                                 |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.add_roles``                  | :meth:`Member.add_roles`                                                     |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.ban``                        | :meth:`Member.ban` or :meth:`Guild.ban`                                      |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.change_nickname``            | :meth:`Member.edit`                                                          |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.clear_reactions``            | :meth:`Message.clear_reactions`                                              |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.create_channel``             | :meth:`Guild.create_text_channel` and :meth:`Guild.create_voice_channel`     |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.create_custom_emoji``        | :meth:`Guild.create_custom_emoji`                                            |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.create_invite``              | :meth:`abc.GuildChannel.create_invite`                                       |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.create_role``                | :meth:`Guild.create_role`                                                    |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.delete_channel``             | :meth:`abc.GuildChannel.delete`                                              |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.delete_channel_permissions`` | :meth:`abc.GuildChannel.set_permissions` with ``overwrite`` set to ``None``  |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.delete_custom_emoji``        | :meth:`Emoji.delete`                                                         |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.delete_invite``              | :meth:`Invite.delete` or :meth:`Client.delete_invite`                        |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.delete_message``             | :meth:`Message.delete`                                                       |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.delete_messages``            | :meth:`TextChannel.delete_messages`                                          |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.delete_role``                | :meth:`Role.delete`                                                          |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.delete_server``              | :meth:`Guild.delete`                                                         |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.edit_channel``               | :meth:`TextChannel.edit` or :meth:`VoiceChannel.edit`                        |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.edit_channel_permissions``   | :meth:`abc.GuildChannel.set_permissions`                                     |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.edit_custom_emoji``          | :meth:`Emoji.edit`                                                           |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.edit_message``               | :meth:`Message.edit`                                                         |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.edit_profile``               | :meth:`ClientUser.edit` (you get this from :attr:`Client.user`)              |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.edit_role``                  | :meth:`Role.edit`                                                            |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.edit_server``                | :meth:`Guild.edit`                                                           |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.estimate_pruned_members``    | :meth:`Guild.estimate_pruned_members`                                        |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.get_all_emojis``             | :attr:`Client.emojis`                                                        |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.get_bans``                   | :meth:`Guild.bans`                                                           |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.get_invite``                 | :meth:`Client.fetch_invite`                                                  |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.get_message``                | :meth:`abc.Messageable.fetch_message`                                        |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.get_reaction_users``         | :meth:`Reaction.users`                                                       |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.get_user_info``              | :meth:`Client.fetch_user`                                                    |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.invites_from``               | :meth:`abc.GuildChannel.invites` or :meth:`Guild.invites`                    |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.join_voice_channel``         | :meth:`VoiceChannel.connect` (see :ref:`migrating_1_0_voice`)                |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.kick``                       | :meth:`Guild.kick` or :meth:`Member.kick`                                    |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.leave_server``               | :meth:`Guild.leave`                                                          |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.logs_from``                  | :meth:`abc.Messageable.history` (see :ref:`migrating_1_0_async_iter`)        |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.move_channel``               | :meth:`TextChannel.edit` or :meth:`VoiceChannel.edit`                        |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.move_member``                | :meth:`Member.edit`                                                          |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.move_role``                  | :meth:`Role.edit`                                                            |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.pin_message``                | :meth:`Message.pin`                                                          |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.pins_from``                  | :meth:`abc.Messageable.pins`                                                 |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.prune_members``              | :meth:`Guild.prune_members`                                                  |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.purge_from``                 | :meth:`TextChannel.purge`                                                    |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.remove_reaction``            | :meth:`Message.remove_reaction`                                              |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.remove_roles``               | :meth:`Member.remove_roles`                                                  |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.replace_roles``              | :meth:`Member.edit`                                                          |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.send_file``                  | :meth:`abc.Messageable.send` (see :ref:`migrating_1_0_sending_messages`)     |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.send_message``               | :meth:`abc.Messageable.send` (see :ref:`migrating_1_0_sending_messages`)     |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.send_typing``                | :meth:`abc.Messageable.trigger_typing` (use :meth:`abc.Messageable.typing`)  |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.server_voice_state``         | :meth:`Member.edit`                                                          |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.start_private_message``      | :meth:`User.create_dm`                                                       |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.unban``                      | :meth:`Guild.unban` or :meth:`Member.unban`                                  |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.unpin_message``              | :meth:`Message.unpin`                                                        |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.wait_for_message``           | :meth:`Client.wait_for` (see :ref:`migrating_1_0_wait_for`)                  |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.wait_for_reaction``          | :meth:`Client.wait_for` (see :ref:`migrating_1_0_wait_for`)                  |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.wait_until_login``           | Removed                                                                      |
+---------------------------------------+------------------------------------------------------------------------------+
| ``Client.wait_until_ready``           | No change                                                                    |
+---------------------------------------+------------------------------------------------------------------------------+

Property Changes
~~~~~~~~~~~~~~~~~~

In order to be a bit more consistent, certain things that were properties were changed to methods instead.

The following are now methods instead of properties (requires parentheses):

- :meth:`Role.is_default`
- :meth:`Client.is_ready`
- :meth:`Client.is_closed`

Dict Value Change

Earlier, in v0.11.0 a :class:`VoiceState` class was added to refer to voice states along with a
:attr:`Member.voice` attribute to refer to it.

However, it was transparent to the user. In an effort to make the library save more memory, the
voice state change is now more visible.

The only way to access voice attributes is via the :attr:`Member.voice` attribute. Note that if
the member does not have a voice state this attribute can be ``None``.

Quick example: ::

    # before
    member.deaf
    member.voice.voice_channel

    # after
    if member.voice: # can be None
        member.voice.deaf
        member.voice.channel


User and Member Type Split

Prior to v1.0, channels were two different types, ``Channel`` and ``PrivateChannel`` with a ``is_private``
property to help differentiate between them.

In order to save memory the channels have been split into 4 different types:

- :class:`TextChannel` for guild text channels.
- :class:`VoiceChannel` for guild voice channels.
- :class:`DMChannel` for DM channels with members.
- :class:`GroupChannel` for Group DM channels with members.

With this split came the removal of the ``is_private`` attribute. You should now use :func:`isinstance`.

The types are split into two different :ref:`discord_api_abcs`:

- :class:`abc.GuildChannel` for guild channels.
- :class:`abc.PrivateChannel` for private channels (DMs and group DMs).

So to check if something is a guild channel you would do: ::

    isinstance(channel, discord.abc.GuildChannel)

And to check if it's a private channel you would do: ::

    isinstance(channel, discord.abc.PrivateChannel)

Of course, if you're looking for only a specific type you can pass that too, e.g. ::

    isinstance(channel, discord.TextChannel)

With this type split also came event changes, which are enumerated in :ref:`migrating_1_0_event_changes`.


Miscellaneous Model Changes

# before
await client.send_message(channel, 'Hello')

# after
await channel.send('Hello')

e = discord.Embed(title='foo')
await channel.send('Hello', embed=e)

# before
await client.send_file(channel, 'cool.png', filename='testing.png', content='Hello')

# after
await channel.send('Hello', file=discord.File('cool.png', 'testing.png'))

my_files = [
    discord.File('cool.png', 'testing.png'),
    discord.File(some_fp, 'cool_filename.png'),
]

await channel.send('Your images:', files=my_files)

async for message in channel.history():
    print(message)

messages = await channel.history().flatten()
for message in messages:
    print(message)

async for m_id in channel.history().filter(lambda m: m.author == client.user).map(lambda m: m.id):
    print(m_id)

my_last_message = await channel.history().get(author=client.user)

async def on_voice_state_update(before, after)

async def on_voice_state_update(member, before, after)

async def on_guild_emojis_update(before, after)

async def on_guild_emojis_update(guild, before, after)

async def on_member_ban(member)

async def on_member_ban(guild, user)

vc = await client.join_voice_channel(channel)
player = vc.create_ffmpeg_player('testing.mp3', after=lambda: print('done'))
player.start()

player.is_playing()
player.pause()
player.resume()
player.stop()
# ...

vc = await channel.connect()
vc.play(discord.FFmpegPCMAudio('testing.mp3'), after=lambda e: print('done', e))
vc.is_playing()
vc.pause()
vc.resume()
vc.stop()
# ...

vc.source = discord.PCMVolumeTransformer(vc.source)
vc.source.volume = 0.6

# before
msg = await client.wait_for_message(author=message.author, channel=message.channel)

# after
def pred(m):
    return m.author == message.author and m.channel == message.channel

msg = await client.wait_for('message', check=pred)

reaction, user = await client.wait_for('reaction_add', check=lambda r, u: u.id == 176995180300206080)

# use user and reaction

def pred(m):
    return m.author == message.author and m.channel == message.channel

try:

    msg = await client.wait_for('message', check=pred, timeout=60.0)
except asyncio.TimeoutError:
    await channel.send('You took too long...')
else:
    await channel.send('You said {0.content}, {0.author}.'.format(msg))

async with aiohttp.ClientSession() as sess:
    async with sess.get('url') as resp:
        # work with resp

client = discord.AutoShardedClient()

# launch 10 shards regardless
client = discord.AutoShardedClient(shard_count=10)

# launch specific shard IDs in this process
client = discord.AutoShardedClient(shard_count=10, shard_ids=(1, 2, 5, 6))

In v1.0, the :class:`.Context` has received a lot of changes with how it's retrieved and used.

The biggest change is that ``pass_context=True`` no longer exists, :class:`.Context` is always passed. Ergo:

.. code-block:: python3

    # before
    @bot.command()
    async def foo():
        await bot.say('Hello')

    # after
    @bot.command()
    async def foo(ctx):
        await ctx.send('Hello')

The reason for this is because :class:`~ext.commands.Context` now meets the requirements of :class:`abc.Messageable`. This
makes it have similar functionality to :class:`TextChannel` or :class:`DMChannel`. Using :meth:`~.Context.send`
will either DM the user in a DM context or send a message in the channel it was in, similar to the old ``bot.say``
functionality. The old helpers have been removed in favour of the new :class:`abc.Messageable` interface. See
:ref:`migrating_1_0_removed_helpers` for more information.

Since the :class:`~ext.commands.Context` is now passed by default, several shortcuts have been added:

**New Shortcuts**

- :attr:`ctx.author <ext.commands.Context.author>` is a shortcut for ``ctx.message.author``.
- :attr:`ctx.guild <ext.commands.Context.guild>` is a shortcut for ``ctx.message.guild``.
- :attr:`ctx.channel <ext.commands.Context.channel>` is a shortcut for ``ctx.message.channel``.
- :attr:`ctx.me <ext.commands.Context.me>` is a shortcut for ``ctx.message.guild.me`` or ``ctx.bot.user``.
- :attr:`ctx.voice_client <ext.commands.Context.voice_client>` is a shortcut for ``ctx.message.guild.voice_client``.

**New Functionality**

- :meth:`.Context.reinvoke` to invoke a command again.

    - This is useful for bypassing cooldowns.
- :attr:`.Context.valid` to check if a context can be invoked with :meth:`.Bot.invoke`.
- :meth:`.Context.send_help` to show the help command for an entity using the new :class:`~.ext.commands.HelpCommand` system.

    - This is useful if you want to show the user help if they misused a command.

Subclassing Context
++++++++++++++++++++

In v1.0, there is now the ability to subclass :class:`~ext.commands.Context` and use it instead of the default
provided one.

For example, if you want to add some functionality to the context:

.. code-block:: python3

    class MyContext(commands.Context):
        @property
        def secret(self):
            return 'my secret here'

Then you can use :meth:`~ext.commands.Bot.get_context` inside :func:`on_message` with combination with
:meth:`~ext.commands.Bot.invoke` to use your custom context:

.. code-block:: python3

    class MyBot(commands.Bot):
        async def on_message(self, message):
            ctx = await self.get_context(message, cls=MyContext)
            await self.invoke(ctx)

Now inside your commands you will have access to your custom context:

.. code-block:: python3

    @bot.command()
    async def secret(ctx):
        await ctx.send(ctx.secret)

.. _migrating_1_0_removed_helpers:

Removed Helpers
+++++++++++++++++

With the new :class:`.Context` changes, a lot of message sending helpers have been removed.

For a full list of changes, see below:

+-----------------+------------------------------------------------------------+
|      Before     |                           After                            |
+-----------------+------------------------------------------------------------+
| ``Bot.say``     | :meth:`.Context.send`                                      |
+-----------------+------------------------------------------------------------+
| ``Bot.upload``  | :meth:`.Context.send`                                      |
+-----------------+------------------------------------------------------------+
| ``Bot.whisper`` | ``ctx.author.send``                                        |
+-----------------+------------------------------------------------------------+
| ``Bot.type``    | :meth:`.Context.typing` or :meth:`.Context.trigger_typing` |
+-----------------+------------------------------------------------------------+
| ``Bot.reply``   | No replacement.                                            |
+-----------------+------------------------------------------------------------+

Command Changes

Prior to v1.0, :func:`~ext.commands.check`\s could only be synchronous. As of v1.0 checks can now be coroutines.

Along with this change, a couple new checks were added.

- :func:`~ext.commands.guild_only` replaces the old ``no_pm=True`` functionality.
- :func:`~ext.commands.is_owner` uses the :meth:`Client.application_info` endpoint by default to fetch owner ID.

    - This is actually powered by a different function, :meth:`~ext.commands.Bot.is_owner`.
    - You can set the owner ID yourself by setting :attr:`.Bot.owner_id`.

- :func:`~ext.commands.is_nsfw` checks if the channel the command is in is a NSFW channel.

    - This is powered by the new :meth:`TextChannel.is_nsfw` method.

Event Changes

on_command(command, ctx)
on_command_completion(command, ctx)
on_command_error(error, ctx)

on_command(ctx)
on_command_completion(ctx)
on_command_error(ctx, error)

The ``HelpFormatter`` class has been removed. It has been replaced with a :class:`~.commands.HelpCommand` class. This class now stores all the command handling and processing of the help command.

The help command is now stored in the :attr:`.Bot.help_command` attribute. As an added extension, you can disable the help command completely by assigning the attribute to ``None`` or passing it at ``__init__`` as ``help_command=None``.

The new interface allows the help command to be customised through special methods that can be overridden.

- :meth:`.HelpCommand.send_bot_help`
    - Called when the user requested for help with the entire bot.
- :meth:`.HelpCommand.send_cog_help`
    - Called when the user requested for help with a specific cog.
- :meth:`.HelpCommand.send_group_help`
    - Called when the user requested for help with a :class:`~.commands.Group`
- :meth:`.HelpCommand.send_command_help`
    - Called when the user requested for help with a :class:`~.commands.Command`
- :meth:`.HelpCommand.get_destination`
    - Called to know where to send the help messages. Useful for deciding whether to DM or not.
- :meth:`.HelpCommand.command_not_found`
    - A function (or coroutine) that returns a presentable no command found string.
- :meth:`.HelpCommand.subcommand_not_found`
    - A function (or coroutine) that returns a string when a subcommand is not found.
- :meth:`.HelpCommand.send_error_message`
    - A coroutine that gets passed the result of :meth:`.HelpCommand.command_not_found` and :meth:`.HelpCommand.subcommand_not_found`.
    - By default it just sends the message. But you can, for example, override it to put it in an embed.
- :meth:`.HelpCommand.on_help_command_error`
    - The :ref:`error handler <ext_commands_error_handler>` for the help command if you want to add one.
- :meth:`.HelpCommand.prepare_help_command`
    - A coroutine that is called right before the help command processing is done.

Certain subclasses can implement more customisable methods.

The old ``HelpFormatter`` was replaced with :class:`~.commands.DefaultHelpCommand`\, which implements all of the logic of the old help command. The customisable methods can be found in the accompanying documentation.

The library now provides a new more minimalistic :class:`~.commands.HelpCommand` implementation that doesn't take as much space, :class:`~.commands.MinimalHelpCommand`. The customisable methods can also be found in the accompanying documentation.

A frequent request was if you could associate a help command with a cog. The new design allows for dynamically changing of cog through binding it to the :attr:`.HelpCommand.cog` attribute. After this assignment the help command will pretend to be part of the cog and everything should work as expected. When the cog is unloaded then the help command will be "unbound" from the cog.

For example, to implement a :class:`~.commands.HelpCommand` in a cog, the following snippet can be used.

.. code-block:: python3

    class MyHelpCommand(commands.MinimalHelpCommand):
        def get_command_signature(self, command):
            return '{0.clean_prefix}{1.qualified_name} {1.signature}'.format(self, command)

    class MyCog(commands.Cog):
        def __init__(self, bot):
            self._original_help_command = bot.help_command
            bot.help_command = MyHelpCommand()
            bot.help_command.cog = self

        def cog_unload(self):
            self.bot.help_command = self._original_help_command

For more information, check out the relevant :ref:`documentation <ext_commands_help_command>`.

Cog Changes
~~~~~~~~~~~~~

Cogs have completely been revamped. They are documented in :ref:`ext_commands_cogs` as well.

Cogs are now required to have a base class, :class:`~.commands.Cog` for future proofing purposes. This comes with special methods to customise some behaviour.

* :meth:`.Cog.cog_unload`
    - This is called when a cog needs to do some cleanup, such as cancelling a task.
* :meth:`.Cog.bot_check_once`
    - This registers a :meth:`.Bot.check_once` check.
* :meth:`.Cog.bot_check`
    - This registers a regular :meth:`.Bot.check` check.
* :meth:`.Cog.cog_check`
    - This registers a check that applies to every command in the cog.
* :meth:`.Cog.cog_command_error`
    - This is a special error handler that is called whenever an error happens inside the cog.
* :meth:`.Cog.cog_before_invoke` and :meth:`.Cog.cog_after_invoke`
    - A special method that registers a cog before and after invoke hook. More information can be found in :ref:`migrating_1_0_before_after_hook`.

Those that were using listeners, such as ``on_message`` inside a cog will now have to explicitly mark them as such using the :meth:`.commands.Cog.listener` decorator.

Along with that, cogs have gained the ability to have custom names through specifying it in the class definition line. More options can be found in the metaclass that facilitates all this, :class:`.commands.CogMeta`.

An example cog with every special method registered and a custom name is as follows:

.. code-block:: python3

    class MyCog(commands.Cog, name='Example Cog'):
        def cog_unload(self):
            print('cleanup goes here')

        def bot_check(self, ctx):
            print('bot check')
            return True

        def bot_check_once(self, ctx):
            print('bot check once')
            return True

        async def cog_check(self, ctx):
            print('cog local check')
            return await ctx.bot.is_owner(ctx.author)

        async def cog_command_error(self, ctx, error):
            print('Error in {0.command.qualified_name}: {1}'.format(ctx, error))

        async def cog_before_invoke(self, ctx):
            print('cog local before: {0.command.qualified_name}'.format(ctx))

        async def cog_after_invoke(self, ctx):
            print('cog local after: {0.command.qualified_name}'.format(ctx))

        @commands.Cog.listener()
        async def on_message(self, message):
            pass


.. _migrating_1_0_before_after_hook:

Before and After Invocation Hooks
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Commands have gained new before and after invocation hooks that allow you to do an action before and after a command is
run.

They take a single parameter, :class:`~ext.commands.Context` and they must be a coroutine.

They are on a global, per-cog, or per-command basis.

Basically: ::


    # global hooks:

    @bot.before_invoke
    async def before_any_command(ctx):
        # do something before a command is called
        pass

    @bot.after_invoke
    async def after_any_command(ctx):
        # do something after a command is called
        pass

The after invocation is hook always called, **regardless of an error in the command**. This makes it ideal for some error
handling or clean up of certain resources such a database connection.

The per-command registration is as follows: ::

    @bot.command()
    async def foo(ctx):
        await ctx.send('foo')

    @foo.before_invoke
    async def before_foo_command(ctx):
        # do something before the foo command is called
        pass

    @foo.after_invoke
    async def after_foo_command(ctx):
        # do something after the foo command is called
        pass

The special cog method for these is :meth:`.Cog.cog_before_invoke` and :meth:`.Cog.cog_after_invoke`, e.g.:

.. code-block:: python3

    class MyCog(commands.Cog):
        async def cog_before_invoke(self, ctx):
            ctx.secret_cog_data = 'foo'

        async def cog_after_invoke(self, ctx):
            print('{0.command} is done...'.format(ctx))

        @commands.command()
        async def foo(self, ctx):
            await ctx.send(ctx.secret_cog_data)

To check if a command failed in the after invocation hook, you can use
:attr:`.Context.command_failed`.

The invocation order is as follows:

1. Command local before invocation hook
2. Cog local before invocation hook
3. Global before invocation hook
4. The actual command
5. Command local after invocation hook
6. Cog local after invocation hook
7. Global after invocation hook

Converter Changes
~~~~~~~~~~~~~~~~~~~

Prior to v1.0, a converter was a type hint that could be a callable that could be invoked
with a singular argument denoting the argument passed by the user as a string.

This system was eventually expanded to support a :class:`~ext.commands.Converter` system to
allow plugging in the :class:`~ext.commands.Context` and do more complicated conversions such
as the built-in "discord" converters.

In v1.0 this converter system was revamped to allow instances of :class:`~ext.commands.Converter` derived
classes to be passed. For consistency, the :meth:`~ext.commands.Converter.convert` method was changed to
always be a coroutine and will now take the two arguments as parameters.

Essentially, before: ::

    class MyConverter(commands.Converter):
        def convert(self):
            return self.ctx.message.server.me

After: ::

    class MyConverter(commands.Converter):
        async def convert(self, ctx, argument):
            return ctx.me

The command framework also got a couple new converters:

- :class:`~ext.commands.clean_content` this is akin to :attr:`Message.clean_content` which scrubs mentions.
- :class:`~ext.commands.UserConverter` will now appropriately convert :class:`User` only.
- ``ChannelConverter`` is now split into two different converters.

    - :class:`~ext.commands.TextChannelConverter` for :class:`TextChannel`.
    - :class:`~ext.commands.VoiceChannelConverter` for :class:`VoiceChannel`.