Drop support for Python 3.4 and make minimum version 3.5.2.

5 files changed, 119 insertions, 167 deletions

diff --git a/discord/ext/commands/bot.py b/discord/ext/commands/bot.py
index 9ef4143c..f2b7a806 100644
--- a/discord/ext/commands/bot.py
+++ b/discord/ext/commands/bot.py
@@ -91,8 +91,7 @@ _mention_pattern = re.compile('|'.join(_mentions_transforms.keys()))
 def _is_submodule(parent, child):
     return parent == child or child.startswith(parent + ".")
 
[email protected]
-def _default_help_command(ctx, *commands : str):
+async def _default_help_command(ctx, *commands : str):
     """Shows this message."""
     bot = ctx.bot
     destination = ctx.message.author if bot.pm_help else ctx.message.channel
@@ -102,7 +101,7 @@ def _default_help_command(ctx, *commands : str):
 
     # help by itself just lists our own commands.
     if len(commands) == 0:
-        pages = yield from bot.formatter.format_help_for(ctx, bot)
+        pages = await bot.formatter.format_help_for(ctx, bot)
     elif len(commands) == 1:
         # try to see if it is a cog name
         name = _mention_pattern.sub(repl, commands[0])
@@ -112,15 +111,15 @@ def _default_help_command(ctx, *commands : str):
         else:
             command = bot.all_commands.get(name)
             if command is None:
-                yield from destination.send(bot.command_not_found.format(name))
+                await destination.send(bot.command_not_found.format(name))
                 return
 
-        pages = yield from bot.formatter.format_help_for(ctx, command)
+        pages = await bot.formatter.format_help_for(ctx, command)
     else:
         name = _mention_pattern.sub(repl, commands[0])
         command = bot.all_commands.get(name)
         if command is None:
-            yield from destination.send(bot.command_not_found.format(name))
+            await destination.send(bot.command_not_found.format(name))
             return
 
         for key in commands[1:]:
@@ -128,13 +127,13 @@ def _default_help_command(ctx, *commands : str):
                 key = _mention_pattern.sub(repl, key)
                 command = command.all_commands.get(key)
                 if command is None:
-                    yield from destination.send(bot.command_not_found.format(key))
+                    await destination.send(bot.command_not_found.format(key))
                     return
             except AttributeError:
-                yield from destination.send(bot.command_has_no_subcommands.format(command, key))
+                await destination.send(bot.command_has_no_subcommands.format(command, key))
                 return
 
-        pages = yield from bot.formatter.format_help_for(ctx, command)
+        pages = await bot.formatter.format_help_for(ctx, command)
 
     if bot.pm_help is None:
         characters = sum(map(lambda l: len(l), pages))
@@ -143,7 +142,7 @@ def _default_help_command(ctx, *commands : str):
             destination = ctx.message.author
 
     for page in pages:
-        yield from destination.send(page)
+        await destination.send(page)
 
 class BotBase(GroupMixin):
     def __init__(self, command_prefix, formatter=None, description=None, pm_help=False, **options):
@@ -189,10 +188,9 @@ class BotBase(GroupMixin):
         ev = 'on_' + event_name
         for event in self.extra_events.get(ev, []):
             coro = self._run_event(event, event_name, *args, **kwargs)
-            discord.compat.create_task(coro, loop=self.loop)
+            asyncio.ensure_future(coro, loop=self.loop)
 
-    @asyncio.coroutine
-    def close(self):
+    async def close(self):
         for extension in tuple(self.extensions):
             try:
                 self.unload_extension(extension)
@@ -205,10 +203,9 @@ class BotBase(GroupMixin):
             except:
                 pass
 
-        yield from super().close()
+        await super().close()
 
-    @asyncio.coroutine
-    def on_command_error(self, context, exception):
+    async def on_command_error(self, context, exception):
         """|coro|
 
         The default command error handler provided by the bot.
@@ -335,17 +332,15 @@ class BotBase(GroupMixin):
         self.add_check(func, call_once=True)
         return func
 
-    @asyncio.coroutine
-    def can_run(self, ctx, *, call_once=False):
+    async def can_run(self, ctx, *, call_once=False):
         data = self._check_once if call_once else self._checks
 
         if len(data) == 0:
             return True
 
-        return (yield from discord.utils.async_all(f(ctx) for f in data))
+        return (await discord.utils.async_all(f(ctx) for f in data))
 
-    @asyncio.coroutine
-    def is_owner(self, user):
+    async def is_owner(self, user):
         """Checks if a :class:`.User` or :class:`.Member` is the owner of
         this bot.
 
@@ -359,7 +354,7 @@ class BotBase(GroupMixin):
         """
 
         if self.owner_id is None:
-            app = yield from self.application_info()
+            app = await self.application_info()
             self.owner_id = owner_id = app.owner.id
             return user.id == owner_id
         return user.id == self.owner_id
@@ -773,8 +768,7 @@ class BotBase(GroupMixin):
 
     # command processing
 
-    @asyncio.coroutine
-    def get_prefix(self, message):
+    async def get_prefix(self, message):
         """|coro|
 
         Retrieves the prefix the bot is listening to
@@ -801,9 +795,7 @@ class BotBase(GroupMixin):
         """
         prefix = ret = self.command_prefix
         if callable(prefix):
-            ret = prefix(self, message)
-            if asyncio.iscoroutine(ret):
-                ret = yield from ret
+            ret = await discord.utils.maybe_coroutine(prefix, self, ret)
 
         if isinstance(ret, (list, tuple)):
             ret = [p for p in ret if p]
@@ -813,8 +805,7 @@ class BotBase(GroupMixin):
 
         return ret
 
-    @asyncio.coroutine
-    def get_context(self, message, *, cls=Context):
+    async def get_context(self, message, *, cls=Context):
         """|coro|
 
         Returns the invocation context from the message.
@@ -850,7 +841,7 @@ class BotBase(GroupMixin):
         if self._skip_check(message.author.id, self.user.id):
             return ctx
 
-        prefix = yield from self.get_prefix(message)
+        prefix = await self.get_prefix(message)
         invoked_prefix = prefix
 
         if isinstance(prefix, str):
@@ -867,8 +858,7 @@ class BotBase(GroupMixin):
         ctx.command = self.all_commands.get(invoker)
         return ctx
 
-    @asyncio.coroutine
-    def invoke(self, ctx):
+    async def invoke(self, ctx):
         """|coro|
 
         Invokes the command given under the invocation context and
@@ -882,18 +872,17 @@ class BotBase(GroupMixin):
         if ctx.command is not None:
             self.dispatch('command', ctx)
             try:
-                if (yield from self.can_run(ctx, call_once=True)):
-                    yield from ctx.command.invoke(ctx)
+                if (await self.can_run(ctx, call_once=True)):
+                    await ctx.command.invoke(ctx)
             except CommandError as e:
-                yield from ctx.command.dispatch_error(ctx, e)
+                await ctx.command.dispatch_error(ctx, e)
             else:
                 self.dispatch('command_completion', ctx)
         elif ctx.invoked_with:
             exc = CommandNotFound('Command "{}" is not found'.format(ctx.invoked_with))
             self.dispatch('command_error', ctx, exc)
 
-    @asyncio.coroutine
-    def process_commands(self, message):
+    async def process_commands(self, message):
         """|coro|
 
         This function processes the commands that have been registered
@@ -912,12 +901,11 @@ class BotBase(GroupMixin):
         message : discord.Message
             The message to process commands for.
         """
-        ctx = yield from self.get_context(message)
-        yield from self.invoke(ctx)
+        ctx = await self.get_context(message)
+        await self.invoke(ctx)
 
-    @asyncio.coroutine
-    def on_message(self, message):
-        yield from self.process_commands(message)
+    async def on_message(self, message):
+        await self.process_commands(message)
 
 class Bot(BotBase, discord.Client):
     """Represents a discord bot.
diff --git a/discord/ext/commands/context.py b/discord/ext/commands/context.py
index 303c1051..dfe1a9ed 100644
--- a/discord/ext/commands/context.py
+++ b/discord/ext/commands/context.py
@@ -86,8 +86,7 @@ class Context(discord.abc.Messageable):
         self.command_failed = attrs.pop('command_failed', False)
         self._state = self.message._state
 
-    @asyncio.coroutine
-    def invoke(self, *args, **kwargs):
+    async def invoke(self, *args, **kwargs):
         """|coro|
 
         Calls a command with the arguments given.
@@ -125,11 +124,10 @@ class Context(discord.abc.Messageable):
         arguments.append(self)
         arguments.extend(args[1:])
 
-        ret = yield from command.callback(*arguments, **kwargs)
+        ret = await command.callback(*arguments, **kwargs)
         return ret
 
-    @asyncio.coroutine
-    def reinvoke(self, *, call_hooks=False, restart=True):
+    async def reinvoke(self, *, call_hooks=False, restart=True):
         """|coro|
 
         Calls the command again.
@@ -174,7 +172,7 @@ class Context(discord.abc.Messageable):
             to_call = cmd
 
         try:
-            yield from to_call.reinvoke(self, call_hooks=call_hooks)
+            await to_call.reinvoke(self, call_hooks=call_hooks)
         finally:
             self.command = cmd
             view.index = index
@@ -188,8 +186,7 @@ class Context(discord.abc.Messageable):
         """Checks if the invocation context is valid to be invoked with."""
         return self.prefix is not None and self.command is not None
 
-    @asyncio.coroutine
-    def _get_channel(self):
+    async def _get_channel(self):
         return self.channel
 
     @property
diff --git a/discord/ext/commands/converter.py b/discord/ext/commands/converter.py
index 9e3718b0..72b2cbf8 100644
--- a/discord/ext/commands/converter.py
+++ b/discord/ext/commands/converter.py
@@ -57,8 +57,7 @@ class Converter:
     method to do its conversion logic. This method must be a coroutine.
     """
 
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         """|coro|
 
         The method to override to do conversion logic.
@@ -99,8 +98,7 @@ class MemberConverter(IDConverter):
     5. Lookup by nickname
     """
 
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         message = ctx.message
         bot = ctx.bot
         match = self._get_id_match(argument) or re.match(r'<@!?([0-9]+)>$', argument)
@@ -136,8 +134,7 @@ class UserConverter(IDConverter):
     3. Lookup by name#discrim
     4. Lookup by name
     """
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         match = self._get_id_match(argument) or re.match(r'<@!?([0-9]+)>$', argument)
         result = None
         state = ctx._state
@@ -176,8 +173,7 @@ class TextChannelConverter(IDConverter):
     2. Lookup by mention.
     3. Lookup by name
     """
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         bot = ctx.bot
 
         match = self._get_id_match(argument) or re.match(r'<#([0-9]+)>$', argument)
@@ -216,8 +212,7 @@ class VoiceChannelConverter(IDConverter):
     2. Lookup by mention.
     3. Lookup by name
     """
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         bot = ctx.bot
         match = self._get_id_match(argument) or re.match(r'<#([0-9]+)>$', argument)
         result = None
@@ -255,8 +250,7 @@ class CategoryChannelConverter(IDConverter):
     2. Lookup by mention.
     3. Lookup by name
     """
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         bot = ctx.bot
 
         match = self._get_id_match(argument) or re.match(r'<#([0-9]+)>$', argument)
@@ -295,8 +289,7 @@ class ColourConverter(Converter):
 
         - The ``_`` in the name can be optionally replaced with spaces.
     """
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         arg = argument.replace('0x', '').lower()
 
         if arg[0] == '#':
@@ -323,8 +316,7 @@ class RoleConverter(IDConverter):
     2. Lookup by mention.
     3. Lookup by name
     """
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         guild = ctx.message.guild
         if not guild:
             raise NoPrivateMessage()
@@ -338,8 +330,7 @@ class RoleConverter(IDConverter):
 
 class GameConverter(Converter):
     """Converts to :class:`Game`."""
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         return discord.Game(name=argument)
 
 class InviteConverter(Converter):
@@ -347,10 +338,9 @@ class InviteConverter(Converter):
 
     This is done via an HTTP request using :meth:`.Bot.get_invite`.
     """
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         try:
-            invite = yield from ctx.bot.get_invite(argument)
+            invite = await ctx.bot.get_invite(argument)
             return invite
         except Exception as e:
             raise BadArgument('Invite is invalid or expired') from e
@@ -368,8 +358,7 @@ class EmojiConverter(IDConverter):
     2. Lookup by extracting ID from the emoji.
     3. Lookup by name
     """
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         match = self._get_id_match(argument) or re.match(r'<a?:[a-zA-Z0-9\_]+:([0-9]+)>$', argument)
         result = None
         bot = ctx.bot
@@ -403,8 +392,7 @@ class PartialEmojiConverter(Converter):
 
     This is done by extracting the animated flag, name and ID from the emoji.
     """
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         match = re.match(r'<(a?):([a-zA-Z0-9\_]+):([0-9]+)>$', argument)
 
         if match:
@@ -436,8 +424,7 @@ class clean_content(Converter):
         self.use_nicknames = use_nicknames
         self.escape_markdown = escape_markdown
 
-    @asyncio.coroutine
-    def convert(self, ctx, argument):
+    async def convert(self, ctx, argument):
         message = ctx.message
         transformations = {}
 
diff --git a/discord/ext/commands/core.py b/discord/ext/commands/core.py
index 927fe6fa..6c1d9a93 100644
--- a/discord/ext/commands/core.py
+++ b/discord/ext/commands/core.py
@@ -41,10 +41,9 @@ __all__ = [ 'Command', 'Group', 'GroupMixin', 'command', 'group',
 
 def wrap_callback(coro):
     @functools.wraps(coro)
-    @asyncio.coroutine
-    def wrapped(*args, **kwargs):
+    async def wrapped(*args, **kwargs):
         try:
-            ret = yield from coro(*args, **kwargs)
+            ret = await coro(*args, **kwargs)
         except CommandError:
             raise
         except asyncio.CancelledError:
@@ -56,10 +55,9 @@ def wrap_callback(coro):
 
 def hooked_wrapped_callback(command, ctx, coro):
     @functools.wraps(coro)
-    @asyncio.coroutine
-    def wrapped(*args, **kwargs):
+    async def wrapped(*args, **kwargs):
         try:
-            ret = yield from coro(*args, **kwargs)
+            ret = await coro(*args, **kwargs)
         except CommandError:
             ctx.command_failed = True
             raise
@@ -70,7 +68,7 @@ def hooked_wrapped_callback(command, ctx, coro):
             ctx.command_failed = True
             raise CommandInvokeError(e) from e
         finally:
-            yield from command.call_after_hooks(ctx)
+            await command.call_after_hooks(ctx)
         return ret
     return wrapped
 
@@ -182,8 +180,7 @@ class Command:
         self._before_invoke = None
         self._after_invoke = None
 
-    @asyncio.coroutine
-    def dispatch_error(self, ctx, error):
+    async def dispatch_error(self, ctx, error):
         ctx.command_failed = True
         cog = self.instance
         try:
@@ -193,9 +190,9 @@ class Command:
         else:
             injected = wrap_callback(coro)
             if cog is not None:
-                yield from injected(cog, ctx, error)
+                await injected(cog, ctx, error)
             else:
-                yield from injected(ctx, error)
+                await injected(ctx, error)
 
         try:
             local = getattr(cog, '_{0.__class__.__name__}__error'.format(cog))
@@ -203,7 +200,7 @@ class Command:
             pass
         else:
             wrapped = wrap_callback(local)
-            yield from wrapped(ctx, error)
+            await wrapped(ctx, error)
         finally:
             ctx.bot.dispatch('command_error', ctx, error)
 
@@ -212,8 +209,7 @@ class Command:
             self.instance = instance
         return self
 
-    @asyncio.coroutine
-    def do_conversion(self, ctx, converter, argument):
+    async def do_conversion(self, ctx, converter, argument):
         if converter is bool:
             return _convert_to_bool(argument)
 
@@ -228,15 +224,15 @@ class Command:
         if inspect.isclass(converter):
             if issubclass(converter, converters.Converter):
                 instance = converter()
-                ret = yield from instance.convert(ctx, argument)
+                ret = await instance.convert(ctx, argument)
                 return ret
             else:
                 method = getattr(converter, 'convert', None)
                 if method is not None and inspect.ismethod(method):
-                    ret = yield from method(ctx, argument)
+                    ret = await method(ctx, argument)
                     return ret
         elif isinstance(converter, converters.Converter):
-            ret = yield from converter.convert(ctx, argument)
+            ret = await converter.convert(ctx, argument)
             return ret
 
         return converter(argument)
@@ -250,8 +246,7 @@ class Command:
                 converter = str
         return converter
 
-    @asyncio.coroutine
-    def transform(self, ctx, param):
+    async def transform(self, ctx, param):
         required = param.default is param.empty
         converter = self._get_converter(param)
         consume_rest_is_special = param.kind == param.KEYWORD_ONLY and not self.rest_is_raw
@@ -271,7 +266,7 @@ class Command:
             argument = quoted_word(view)
 
         try:
-            return (yield from self.do_conversion(ctx, converter, argument))
+            return (await self.do_conversion(ctx, converter, argument))
         except CommandError as e:
             raise e
         except Exception as e:
@@ -354,8 +349,7 @@ class Command:
     def __str__(self):
         return self.qualified_name
 
-    @asyncio.coroutine
-    def _parse_arguments(self, ctx):
+    async def _parse_arguments(self, ctx):
         ctx.args = [ctx] if self.instance is None else [self.instance, ctx]
         ctx.kwargs = {}
         args = ctx.args
@@ -382,21 +376,21 @@ class Command:
 
         for name, param in iterator:
             if param.kind == param.POSITIONAL_OR_KEYWORD:
-                transformed = yield from self.transform(ctx, param)
+                transformed = await self.transform(ctx, param)
                 args.append(transformed)
             elif param.kind == param.KEYWORD_ONLY:
                 # kwarg only param denotes "consume rest" semantics
                 if self.rest_is_raw:
                     converter = self._get_converter(param)
                     argument = view.read_rest()
-                    kwargs[name] = yield from self.do_conversion(ctx, converter, argument)
+                    kwargs[name] = await self.do_conversion(ctx, converter, argument)
                 else:
-                    kwargs[name] = yield from self.transform(ctx, param)
+                    kwargs[name] = await self.transform(ctx, param)
                 break
             elif param.kind == param.VAR_POSITIONAL:
                 while not view.eof:
                     try:
-                        transformed = yield from self.transform(ctx, param)
+                        transformed = await self.transform(ctx, param)
                         args.append(transformed)
                     except RuntimeError:
                         break
@@ -405,24 +399,22 @@ class Command:
             if not view.eof:
                 raise TooManyArguments('Too many arguments passed to ' + self.qualified_name)
 
-    @asyncio.coroutine
-    def _verify_checks(self, ctx):
+    async def _verify_checks(self, ctx):
         if not self.enabled:
             raise DisabledCommand('{0.name} command is disabled'.format(self))
 
-        if not (yield from self.can_run(ctx)):
+        if not (await self.can_run(ctx)):
             raise CheckFailure('The check functions for command {0.qualified_name} failed.'.format(self))
 
-    @asyncio.coroutine
-    def call_before_hooks(self, ctx):
+    async def call_before_hooks(self, ctx):
         # now that we're done preparing we can call the pre-command hooks
         # first, call the command local hook:
         cog = self.instance
         if self._before_invoke is not None:
             if cog is None:
-                yield from self._before_invoke(ctx)
+                await self._before_invoke(ctx)
             else:
-                yield from self._before_invoke(cog, ctx)
+                await self._before_invoke(cog, ctx)
 
         # call the cog local hook if applicable:
         try:
@@ -430,37 +422,35 @@ class Command:
         except AttributeError:
             pass
         else:
-            yield from hook(ctx)
+            await hook(ctx)
 
         # call the bot global hook if necessary
         hook = ctx.bot._before_invoke
         if hook is not None:
-            yield from hook(ctx)
+            await hook(ctx)
 
-    @asyncio.coroutine
-    def call_after_hooks(self, ctx):
+    async def call_after_hooks(self, ctx):
         cog = self.instance
         if self._after_invoke is not None:
             if cog is None:
-                yield from self._after_invoke(ctx)
+                await self._after_invoke(ctx)
             else:
-                yield from self._after_invoke(cog, ctx)
+                await self._after_invoke(cog, ctx)
 
         try:
             hook = getattr(cog, '_{0.__class__.__name__}__after_invoke'.format(cog))
         except AttributeError:
             pass
         else:
-            yield from hook(ctx)
+            await hook(ctx)
 
         hook = ctx.bot._after_invoke
         if hook is not None:
-            yield from hook(ctx)
+            await hook(ctx)
 
-    @asyncio.coroutine
-    def prepare(self, ctx):
+    async def prepare(self, ctx):
         ctx.command = self
-        yield from self._verify_checks(ctx)
+        await self._verify_checks(ctx)
 
         if self._buckets.valid:
             bucket = self._buckets.get_bucket(ctx.message)
@@ -468,8 +458,8 @@ class Command:
             if retry_after:
                 raise CommandOnCooldown(bucket, retry_after)
 
-        yield from self._parse_arguments(ctx)
-        yield from self.call_before_hooks(ctx)
+        await self._parse_arguments(ctx)
+        await self.call_before_hooks(ctx)
 
     def is_on_cooldown(self, ctx):
         """Checks whether the command is currently on cooldown.
@@ -502,34 +492,32 @@ class Command:
             bucket = self._buckets.get_bucket(ctx.message)
             bucket.reset()
 
-    @asyncio.coroutine
-    def invoke(self, ctx):
-        yield from self.prepare(ctx)
+    async def invoke(self, ctx):
+        await self.prepare(ctx)
 
         # terminate the invoked_subcommand chain.
         # since we're in a regular command (and not a group) then
         # the invoked subcommand is None.
         ctx.invoked_subcommand = None
         injected = hooked_wrapped_callback(self, ctx, self.callback)
-        yield from injected(*ctx.args, **ctx.kwargs)
+        await injected(*ctx.args, **ctx.kwargs)
 
-    @asyncio.coroutine
-    def reinvoke(self, ctx, *, call_hooks=False):
+    async def reinvoke(self, ctx, *, call_hooks=False):
         ctx.command = self
-        yield from self._parse_arguments(ctx)
+        await self._parse_arguments(ctx)
 
         if call_hooks:
-            yield from self.call_before_hooks(ctx)
+            await self.call_before_hooks(ctx)
 
         ctx.invoked_subcommand = None
         try:
-            yield from self.callback(*ctx.args, **ctx.kwargs)
+            await self.callback(*ctx.args, **ctx.kwargs)
         except:
             ctx.command_failed = True
             raise
         finally:
             if call_hooks:
-                yield from self.call_after_hooks(ctx)
+                await self.call_after_hooks(ctx)
 
     def error(self, coro):
         """A decorator that registers a coroutine as a local error handler.
@@ -667,8 +655,7 @@ class Command:
 
         return ' '.join(result)
 
-    @asyncio.coroutine
-    def can_run(self, ctx):
+    async def can_run(self, ctx):
         """|coro|
 
         Checks if the command can be executed by checking all the predicates
@@ -695,7 +682,7 @@ class Command:
         ctx.command = self
 
         try:
-            if not (yield from ctx.bot.can_run(ctx)):
+            if not (await ctx.bot.can_run(ctx)):
                 raise CheckFailure('The global check functions for command {0.qualified_name} failed.'.format(self))
 
             cog = self.instance
@@ -705,7 +692,7 @@ class Command:
                 except AttributeError:
                     pass
                 else:
-                    ret = yield from discord.utils.maybe_coroutine(local_check, ctx)
+                    ret = await discord.utils.maybe_coroutine(local_check, ctx)
                     if not ret:
                         return False
 
@@ -714,7 +701,7 @@ class Command:
                 # since we have no checks, then we just return True.
                 return True
 
-            return (yield from discord.utils.async_all(predicate(ctx) for predicate in predicates))
+            return (await discord.utils.async_all(predicate(ctx) for predicate in predicates))
         finally:
             ctx.command = original
 
@@ -903,11 +890,10 @@ class Group(GroupMixin, Command):
         self.invoke_without_command = attrs.pop('invoke_without_command', False)
         super().__init__(**attrs)
 
-    @asyncio.coroutine
-    def invoke(self, ctx):
+    async def invoke(self, ctx):
         early_invoke = not self.invoke_without_command
         if early_invoke:
-            yield from self.prepare(ctx)
+            await self.prepare(ctx)
 
         view = ctx.view
         previous = view.index
@@ -920,26 +906,25 @@ class Group(GroupMixin, Command):
 
         if early_invoke:
             injected = hooked_wrapped_callback(self, ctx, self.callback)
-            yield from injected(*ctx.args, **ctx.kwargs)
+            await injected(*ctx.args, **ctx.kwargs)
 
         if trigger and ctx.invoked_subcommand:
             ctx.invoked_with = trigger
-            yield from ctx.invoked_subcommand.invoke(ctx)
+            await ctx.invoked_subcommand.invoke(ctx)
         elif not early_invoke:
             # undo the trigger parsing
             view.index = previous
             view.previous = previous
-            yield from super().invoke(ctx)
+            await super().invoke(ctx)
 
-    @asyncio.coroutine
-    def reinvoke(self, ctx, *, call_hooks=False):
+    async def reinvoke(self, ctx, *, call_hooks=False):
         early_invoke = not self.invoke_without_command
         if early_invoke:
             ctx.command = self
-            yield from self._parse_arguments(ctx)
+            await self._parse_arguments(ctx)
 
             if call_hooks:
-                yield from self.call_before_hooks(ctx)
+                await self.call_before_hooks(ctx)
 
         view = ctx.view
         previous = view.index
@@ -952,22 +937,22 @@ class Group(GroupMixin, Command):
 
         if early_invoke:
             try:
-                yield from self.callback(*ctx.args, **ctx.kwargs)
+                await self.callback(*ctx.args, **ctx.kwargs)
             except:
                 ctx.command_failed = True
                 raise
             finally:
                 if call_hooks:
-                    yield from self.call_after_hooks(ctx)
+                    await self.call_after_hooks(ctx)
 
         if trigger and ctx.invoked_subcommand:
             ctx.invoked_with = trigger
-            yield from ctx.invoked_subcommand.reinvoke(ctx, call_hooks=call_hooks)
+            await ctx.invoked_subcommand.reinvoke(ctx, call_hooks=call_hooks)
         elif not early_invoke:
             # undo the trigger parsing
             view.index = previous
             view.previous = previous
-            yield from super().reinvoke(ctx, call_hooks=call_hooks)
+            await super().reinvoke(ctx, call_hooks=call_hooks)
 
 # Decorators
 
@@ -1279,9 +1264,8 @@ def is_owner():
     from :exc:`.CheckFailure`.
     """
 
-    @asyncio.coroutine
-    def predicate(ctx):
-        if not (yield from ctx.bot.is_owner(ctx.author)):
+    async def predicate(ctx):
+        if not (await ctx.bot.is_owner(ctx.author)):
             raise NotOwner('You do not own this bot.')
         return True
 
diff --git a/discord/ext/commands/formatter.py b/discord/ext/commands/formatter.py
index 7b9528c4..0dead85f 100644
--- a/discord/ext/commands/formatter.py
+++ b/discord/ext/commands/formatter.py
@@ -199,8 +199,7 @@ class HelpFormatter:
         return "Type {0}{1} command for more info on a command.\n" \
                "You can also type {0}{1} category for more info on a category.".format(self.clean_prefix, command_name)
 
-    @asyncio.coroutine
-    def filter_command_list(self):
+    async def filter_command_list(self):
         """Returns a filtered list of commands based on the two attributes
         provided, :attr:`show_check_failure` and :attr:`show_hidden`.
         Also filters based on if :meth:`~.HelpFormatter.is_cog` is valid.
@@ -224,14 +223,13 @@ class HelpFormatter:
 
             return True
 
-        @asyncio.coroutine
-        def predicate(tup):
+        async def predicate(tup):
             if sane_no_suspension_point_predicate(tup) is False:
                 return False
 
             cmd = tup[1]
             try:
-                return (yield from cmd.can_run(self.context))
+                return (await cmd.can_run(self.context))
             except CommandError:
                 return False
 
@@ -242,7 +240,7 @@ class HelpFormatter:
         # Gotta run every check and verify it
         ret = []
         for elem in iterator:
-            valid = yield from predicate(elem)
+            valid = await predicate(elem)
             if valid:
                 ret.append(elem)
 
@@ -258,8 +256,7 @@ class HelpFormatter:
             shortened = self.shorten(entry)
             self._paginator.add_line(shortened)
 
-    @asyncio.coroutine
-    def format_help_for(self, context, command_or_bot):
+    async def format_help_for(self, context, command_or_bot):
         """Formats the help page and handles the actual heavy lifting of how
         the help command looks like. To change the behaviour, override the
         :meth:`~.HelpFormatter.format` method.
@@ -278,10 +275,9 @@ class HelpFormatter:
         """
         self.context = context
         self.command = command_or_bot
-        return (yield from self.format())
+        return (await self.format())
 
-    @asyncio.coroutine
-    def format(self):
+    async def format(self):
         """Handles the actual behaviour involved with formatting.
 
         To change the behaviour, this method should be overridden.
@@ -323,7 +319,7 @@ class HelpFormatter:
             # last place sorting position.
             return cog + ':' if cog is not None else '\u200bNo Category:'
 
-        filtered = yield from self.filter_command_list()
+        filtered = await self.filter_command_list()
         if self.is_bot():
             data = sorted(filtered, key=category)
             for category, commands in itertools.groupby(data, key=category):