mirror
/
Rapptz.discord.py
mirror of https://github.com/Rapptz/discord.py
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Drop support for Python 3.4 and make minimum version 3.5.2.

pull/1343/head
Rapptz 7 years ago
parent
7eb918b19e
commit
f25091efe1
35 changed files with 626 additions and 1069 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      README.rst
  2. 98
      discord/abc.py
  3. 85
      discord/channel.py
  4. 128
      discord/client.py
  5. 140
      discord/compat.py
  6. 19
      discord/context_managers.py
  7. 10
      discord/emoji.py
  8. 4
      discord/errors.py
  9. 72
      discord/ext/commands/bot.py
  10. 13
      discord/ext/commands/context.py
  11. 41
      discord/ext/commands/converter.py
  12. 140
      discord/ext/commands/core.py
  13. 20
      discord/ext/commands/formatter.py
  14. 152
      discord/gateway.py
  15. 89
      discord/guild.py
  16. 61
      discord/http.py
  17. 5
      discord/invite.py
  18. 114
      discord/iterators.py
  19. 46
      discord/member.py
  20. 51
      discord/message.py
  21. 2
      discord/reaction.py
  22. 10
      discord/relationship.py
  23. 17
      discord/role.py
  24. 91
      discord/shard.py
  25. 47
      discord/state.py
  26. 45
      discord/user.py
  27. 19
      discord/utils.py
  28. 61
      discord/voice_client.py
  29. 21
      discord/webhook.py
  30. 26
      docs/api.rst
  31. 26
      docs/faq.rst
  32. 6
      docs/intro.rst
  33. 13
      docs/migrating.rst
  34. 4
      requirements.txt
  35. 1
      setup.py

4
README.rst
View File

@ -87,14 +87,12 @@ Quick Example
client = MyClient() client = MyClient()
client.run('token') client.run('token')
Note that in Python 3.4 you use ``@asyncio.coroutine`` instead of ``async def`` and ``yield from`` instead of ``await``.
You can find examples in the examples directory. You can find examples in the examples directory.
Requirements Requirements
------------ ------------
* Python 3.4.2+ * Python 3.5.2+
* ``aiohttp`` library * ``aiohttp`` library
* ``websockets`` library * ``websockets`` library
* ``PyNaCl`` library (optional, for voice only) * ``PyNaCl`` library (optional, for voice only)

98
discord/abc.py
View File

@ -188,8 +188,7 @@ class GuildChannel:
def __str__(self): def __str__(self):
return self.name return self.name
@asyncio.coroutine async def _move(self, position, parent_id=None, lock_permissions=False, *, reason):
def _move(self, position, parent_id=None, lock_permissions=False, *, reason):
if position < 0: if position < 0:
raise InvalidArgument('Channel position cannot be less than 0.') raise InvalidArgument('Channel position cannot be less than 0.')
@ -219,13 +218,12 @@ class GuildChannel:
d.update(parent_id=parent_id, lock_permissions=lock_permissions) d.update(parent_id=parent_id, lock_permissions=lock_permissions)
payload.append(d) payload.append(d)
yield from http.bulk_channel_update(self.guild.id, payload, reason=reason) await http.bulk_channel_update(self.guild.id, payload, reason=reason)
self.position = position self.position = position
if parent_id is not _undefined: if parent_id is not _undefined:
self.category_id = int(parent_id) if parent_id else None self.category_id = int(parent_id) if parent_id else None
@asyncio.coroutine async def _edit(self, options, reason):
def _edit(self, options, reason):
try: try:
parent = options.pop('category') parent = options.pop('category')
except KeyError: except KeyError:
@ -249,10 +247,10 @@ class GuildChannel:
category = self.guild.get_channel(self.category_id) category = self.guild.get_channel(self.category_id)
options['permission_overwrites'] = [c._asdict() for c in category._overwrites] options['permission_overwrites'] = [c._asdict() for c in category._overwrites]
else: else:
yield from self._move(position, parent_id=parent_id, lock_permissions=lock_permissions, reason=reason) await self._move(position, parent_id=parent_id, lock_permissions=lock_permissions, reason=reason)
if options: if options:
data = yield from self._state.http.edit_channel(self.id, reason=reason, **options) data = await self._state.http.edit_channel(self.id, reason=reason, **options)
self._update(self.guild, data) self._update(self.guild, data)
def _fill_overwrites(self, data): def _fill_overwrites(self, data):
@ -466,8 +464,7 @@ class GuildChannel:
return base return base
@asyncio.coroutine async def delete(self, *, reason=None):
def delete(self, *, reason=None):
"""|coro| """|coro|
Deletes the channel. Deletes the channel.
@ -489,10 +486,9 @@ class GuildChannel:
HTTPException HTTPException
Deleting the channel failed. Deleting the channel failed.
""" """
yield from self._state.http.delete_channel(self.id, reason=reason) await self._state.http.delete_channel(self.id, reason=reason)
@asyncio.coroutine async def set_permissions(self, target, *, overwrite=_undefined, reason=None, **permissions):
def set_permissions(self, target, *, overwrite=_undefined, reason=None, **permissions):
"""|coro| """|coro|
Sets the channel specific permission overwrites for a target in the Sets the channel specific permission overwrites for a target in the
@ -579,15 +575,14 @@ class GuildChannel:
# TODO: wait for event # TODO: wait for event
if overwrite is None: if overwrite is None:
yield from http.delete_channel_permissions(self.id, target.id, reason=reason) await http.delete_channel_permissions(self.id, target.id, reason=reason)
elif isinstance(overwrite, PermissionOverwrite): elif isinstance(overwrite, PermissionOverwrite):
(allow, deny) = overwrite.pair() (allow, deny) = overwrite.pair()
yield from http.edit_channel_permissions(self.id, target.id, allow.value, deny.value, perm_type, reason=reason) await http.edit_channel_permissions(self.id, target.id, allow.value, deny.value, perm_type, reason=reason)
else: else:
raise InvalidArgument('Invalid overwrite type provided.') raise InvalidArgument('Invalid overwrite type provided.')
@asyncio.coroutine async def create_invite(self, *, reason=None, **fields):
def create_invite(self, *, reason=None, **fields):
"""|coro| """|coro|
Creates an instant invite. Creates an instant invite.
@ -624,11 +619,10 @@ class GuildChannel:
The invite that was created. The invite that was created.
""" """
data = yield from self._state.http.create_invite(self.id, reason=reason, **fields) data = await self._state.http.create_invite(self.id, reason=reason, **fields)
return Invite.from_incomplete(data=data, state=self._state) return Invite.from_incomplete(data=data, state=self._state)
@asyncio.coroutine async def invites(self):
def invites(self):
"""|coro| """|coro|
Returns a list of all active instant invites from this channel. Returns a list of all active instant invites from this channel.
@ -649,7 +643,7 @@ class GuildChannel:
""" """
state = self._state state = self._state
data = yield from state.http.invites_from_channel(self.id) data = await state.http.invites_from_channel(self.id)
result = [] result = []
for invite in data: for invite in data:
@ -676,13 +670,11 @@ class Messageable(metaclass=abc.ABCMeta):
__slots__ = () __slots__ = ()
@asyncio.coroutine
@abc.abstractmethod @abc.abstractmethod
def _get_channel(self): async def _get_channel(self):
raise NotImplementedError raise NotImplementedError
@asyncio.coroutine async def send(self, content=None, *, tts=False, embed=None, file=None, files=None, delete_after=None, nonce=None):
def send(self, content=None, *, tts=False, embed=None, file=None, files=None, delete_after=None, nonce=None):
"""|coro| """|coro|
Sends a message to the destination with the content given. Sends a message to the destination with the content given.
@ -735,7 +727,7 @@ class Messageable(metaclass=abc.ABCMeta):
The message that was sent. The message that was sent.
""" """
channel = yield from self._get_channel() channel = await self._get_channel()
state = self._state state = self._state
content = str(content) if content is not None else None content = str(content) if content is not None else None
if embed is not None: if embed is not None:
@ -749,7 +741,7 @@ class Messageable(metaclass=abc.ABCMeta):
raise InvalidArgument('file parameter must be File') raise InvalidArgument('file parameter must be File')
try: try:
data = yield from state.http.send_files(channel.id, files=[(file.open_file(), file.filename)], data = await state.http.send_files(channel.id, files=[(file.open_file(), file.filename)],
content=content, tts=tts, embed=embed, nonce=nonce) content=content, tts=tts, embed=embed, nonce=nonce)
finally: finally:
file.close() file.close()
@ -760,28 +752,26 @@ class Messageable(metaclass=abc.ABCMeta):
try: try:
param = [(f.open_file(), f.filename) for f in files] param = [(f.open_file(), f.filename) for f in files]
data = yield from state.http.send_files(channel.id, files=param, content=content, tts=tts, data = await state.http.send_files(channel.id, files=param, content=content, tts=tts,
embed=embed, nonce=nonce) embed=embed, nonce=nonce)
finally: finally:
for f in files: for f in files:
f.close() f.close()
else: else:
data = yield from state.http.send_message(channel.id, content, tts=tts, embed=embed, nonce=nonce) data = await state.http.send_message(channel.id, content, tts=tts, embed=embed, nonce=nonce)
ret = state.create_message(channel=channel, data=data) ret = state.create_message(channel=channel, data=data)
if delete_after is not None: if delete_after is not None:
@asyncio.coroutine async def delete():
def delete(): await asyncio.sleep(delete_after, loop=state.loop)
yield from asyncio.sleep(delete_after, loop=state.loop)
try: try:
yield from ret.delete() await ret.delete()
except: except:
pass pass
compat.create_task(delete(), loop=state.loop) asyncio.ensure_future(delete(), loop=state.loop)
return ret return ret
@asyncio.coroutine async def trigger_typing(self):
def trigger_typing(self):
"""|coro| """|coro|
Triggers a *typing* indicator to the destination. Triggers a *typing* indicator to the destination.
@ -789,8 +779,8 @@ class Messageable(metaclass=abc.ABCMeta):
*Typing* indicator will go away after 10 seconds, or after a message is sent. *Typing* indicator will go away after 10 seconds, or after a message is sent.
""" """
channel = yield from self._get_channel() channel = await self._get_channel()
yield from self._state.http.send_typing(channel.id) await self._state.http.send_typing(channel.id)
def typing(self): def typing(self):
"""Returns a context manager that allows you to type for an indefinite period of time. """Returns a context manager that allows you to type for an indefinite period of time.
@ -811,8 +801,7 @@ class Messageable(metaclass=abc.ABCMeta):
""" """
return Typing(self) return Typing(self)
@asyncio.coroutine async def get_message(self, id):
def get_message(self, id):
"""|coro| """|coro|
Retrieves a single :class:`Message` from the destination. Retrieves a single :class:`Message` from the destination.
@ -839,12 +828,11 @@ class Messageable(metaclass=abc.ABCMeta):
Retrieving the message failed. Retrieving the message failed.
""" """
channel = yield from self._get_channel() channel = await self._get_channel()
data = yield from self._state.http.get_message(channel.id, id) data = await self._state.http.get_message(channel.id, id)
return self._state.create_message(channel=channel, data=data) return self._state.create_message(channel=channel, data=data)
@asyncio.coroutine async def pins(self):
def pins(self):
"""|coro| """|coro|
Returns a :class:`list` of :class:`Message` that are currently pinned. Returns a :class:`list` of :class:`Message` that are currently pinned.
@ -855,9 +843,9 @@ class Messageable(metaclass=abc.ABCMeta):
Retrieving the pinned messages failed. Retrieving the pinned messages failed.
""" """
channel = yield from self._get_channel() channel = await self._get_channel()
state = self._state state = self._state
data = yield from state.http.pins_from(channel.id) data = await state.http.pins_from(channel.id)
return [state.create_message(channel=channel, data=m) for m in data] return [state.create_message(channel=channel, data=m) for m in data]
def history(self, *, limit=100, before=None, after=None, around=None, reverse=None): def history(self, *, limit=100, before=None, after=None, around=None, reverse=None):
@ -916,19 +904,6 @@ class Messageable(metaclass=abc.ABCMeta):
messages = await channel.history(limit=123).flatten() messages = await channel.history(limit=123).flatten()
# messages is now a list of Message... # messages is now a list of Message...
Python 3.4 Usage ::
count = 0
iterator = channel.history(limit=200)
while True:
try:
message = yield from iterator.next()
except discord.NoMoreItems:
break
else:
if message.author == client.user:
counter += 1
""" """
return HistoryIterator(self, limit=limit, before=before, after=after, around=around, reverse=reverse) return HistoryIterator(self, limit=limit, before=before, after=after, around=around, reverse=reverse)
@ -951,8 +926,7 @@ class Connectable(metaclass=abc.ABCMeta):
def _get_voice_state_pair(self): def _get_voice_state_pair(self):
raise NotImplementedError raise NotImplementedError
@asyncio.coroutine async def connect(self, *, timeout=60.0, reconnect=True):
def connect(self, *, timeout=60.0, reconnect=True):
"""|coro| """|coro|
Connects to voice and creates a :class:`VoiceClient` to establish Connects to voice and creates a :class:`VoiceClient` to establish
@ -991,10 +965,10 @@ class Connectable(metaclass=abc.ABCMeta):
state._add_voice_client(key_id, voice) state._add_voice_client(key_id, voice)
try: try:
yield from voice.connect(reconnect=reconnect) await voice.connect(reconnect=reconnect)
except asyncio.TimeoutError as e: except asyncio.TimeoutError as e:
try: try:
yield from voice.disconnect(force=True) await voice.disconnect(force=True)
except: except:
# we don't care if disconnect failed because connection failed # we don't care if disconnect failed because connection failed
pass pass

85
discord/channel.py
View File

@ -37,10 +37,9 @@ import asyncio
__all__ = ('TextChannel', 'VoiceChannel', 'DMChannel', 'CategoryChannel', 'GroupChannel', '_channel_factory') __all__ = ('TextChannel', 'VoiceChannel', 'DMChannel', 'CategoryChannel', 'GroupChannel', '_channel_factory')
@asyncio.coroutine async def _single_delete_strategy(messages):
def _single_delete_strategy(messages):
for m in messages: for m in messages:
yield from m.delete() await m.delete()
class TextChannel(discord.abc.Messageable, discord.abc.GuildChannel, Hashable): class TextChannel(discord.abc.Messageable, discord.abc.GuildChannel, Hashable):
"""Represents a Discord guild text channel. """Represents a Discord guild text channel.
@ -100,8 +99,7 @@ class TextChannel(discord.abc.Messageable, discord.abc.GuildChannel, Hashable):
self.nsfw = data.get('nsfw', False) self.nsfw = data.get('nsfw', False)
self._fill_overwrites(data) self._fill_overwrites(data)
@asyncio.coroutine async def _get_channel(self):
def _get_channel(self):
return self return self
def permissions_for(self, member): def permissions_for(self, member):
@ -124,8 +122,7 @@ class TextChannel(discord.abc.Messageable, discord.abc.GuildChannel, Hashable):
n = self.name n = self.name
return self.nsfw or n == 'nsfw' or n[:5] == 'nsfw-' return self.nsfw or n == 'nsfw' or n[:5] == 'nsfw-'
@asyncio.coroutine async def edit(self, *, reason=None, **options):
def edit(self, *, reason=None, **options):
"""|coro| """|coro|
Edits the channel. Edits the channel.
@ -161,10 +158,9 @@ class TextChannel(discord.abc.Messageable, discord.abc.GuildChannel, Hashable):
HTTPException HTTPException
Editing the channel failed. Editing the channel failed.
""" """
yield from self._edit(options, reason=reason) await self._edit(options, reason=reason)
@asyncio.coroutine async def delete_messages(self, messages):
def delete_messages(self, messages):
"""|coro| """|coro|
Deletes a list of messages. This is similar to :meth:`Message.delete` Deletes a list of messages. This is similar to :meth:`Message.delete`
@ -205,17 +201,16 @@ class TextChannel(discord.abc.Messageable, discord.abc.GuildChannel, Hashable):
if len(messages) == 1: if len(messages) == 1:
message_id = messages[0].id message_id = messages[0].id
yield from self._state.http.delete_message(self.id, message_id) await self._state.http.delete_message(self.id, message_id)
return return
if len(messages) > 100: if len(messages) > 100:
raise ClientException('Can only bulk delete messages up to 100 messages') raise ClientException('Can only bulk delete messages up to 100 messages')
message_ids = [m.id for m in messages] message_ids = [m.id for m in messages]
yield from self._state.http.delete_messages(self.id, message_ids) await self._state.http.delete_messages(self.id, message_ids)
@asyncio.coroutine async def purge(self, *, limit=100, check=None, before=None, after=None, around=None, reverse=False, bulk=True):
def purge(self, *, limit=100, check=None, before=None, after=None, around=None, reverse=False, bulk=True):
"""|coro| """|coro|
Purges a list of messages that meet the criteria given by the predicate Purges a list of messages that meet the criteria given by the predicate
@ -289,34 +284,34 @@ class TextChannel(discord.abc.Messageable, discord.abc.GuildChannel, Hashable):
while True: while True:
try: try:
msg = yield from iterator.next() msg = await iterator.next()
except NoMoreItems: except NoMoreItems:
# no more messages to poll # no more messages to poll
if count >= 2: if count >= 2:
# more than 2 messages -> bulk delete # more than 2 messages -> bulk delete
to_delete = ret[-count:] to_delete = ret[-count:]
yield from strategy(to_delete) await strategy(to_delete)
elif count == 1: elif count == 1:
# delete a single message # delete a single message
yield from ret[-1].delete() await ret[-1].delete()
return ret return ret
else: else:
if count == 100: if count == 100:
# we've reached a full 'queue' # we've reached a full 'queue'
to_delete = ret[-100:] to_delete = ret[-100:]
yield from strategy(to_delete) await strategy(to_delete)
count = 0 count = 0
yield from asyncio.sleep(1) await asyncio.sleep(1)
if check(msg): if check(msg):
if msg.id < minimum_time: if msg.id < minimum_time:
# older than 14 days old # older than 14 days old
if count == 1: if count == 1:
yield from ret[-1].delete() await ret[-1].delete()
elif count >= 2: elif count >= 2:
to_delete = ret[-count:] to_delete = ret[-count:]
yield from strategy(to_delete) await strategy(to_delete)
count = 0 count = 0
strategy = _single_delete_strategy strategy = _single_delete_strategy
@ -324,8 +319,7 @@ class TextChannel(discord.abc.Messageable, discord.abc.GuildChannel, Hashable):
count += 1 count += 1
ret.append(msg) ret.append(msg)
@asyncio.coroutine async def webhooks(self):
def webhooks(self):
"""|coro| """|coro|
Gets the list of webhooks from this channel. Gets the list of webhooks from this channel.
@ -343,11 +337,10 @@ class TextChannel(discord.abc.Messageable, discord.abc.GuildChannel, Hashable):
The webhooks for this channel. The webhooks for this channel.
""" """
data = yield from self._state.http.channel_webhooks(self.id) data = await self._state.http.channel_webhooks(self.id)
return [Webhook.from_state(d, state=self._state) for d in data] return [Webhook.from_state(d, state=self._state) for d in data]
@asyncio.coroutine async def create_webhook(self, *, name=None, avatar=None):
def create_webhook(self, *, name=None, avatar=None):
"""|coro| """|coro|
Creates a webhook for this channel. Creates a webhook for this channel.
@ -381,7 +374,7 @@ class TextChannel(discord.abc.Messageable, discord.abc.GuildChannel, Hashable):
if name is not None: if name is not None:
name = str(name) name = str(name)
data = yield from self._state.http.create_webhook(self.id, name=name, avatar=avatar) data = await self._state.http.create_webhook(self.id, name=name, avatar=avatar)
return Webhook.from_state(data, state=self._state) return Webhook.from_state(data, state=self._state)
class VoiceChannel(discord.abc.Connectable, discord.abc.GuildChannel, Hashable): class VoiceChannel(discord.abc.Connectable, discord.abc.GuildChannel, Hashable):
@ -461,8 +454,7 @@ class VoiceChannel(discord.abc.Connectable, discord.abc.GuildChannel, Hashable):
ret.append(member) ret.append(member)
return ret return ret
@asyncio.coroutine async def edit(self, *, reason=None, **options):
def edit(self, *, reason=None, **options):
"""|coro| """|coro|
Edits the channel. Edits the channel.
@ -497,7 +489,7 @@ class VoiceChannel(discord.abc.Connectable, discord.abc.GuildChannel, Hashable):
Editing the channel failed. Editing the channel failed.
""" """
yield from self._edit(options, reason=reason) await self._edit(options, reason=reason)
class CategoryChannel(discord.abc.GuildChannel, Hashable): class CategoryChannel(discord.abc.GuildChannel, Hashable):
"""Represents a Discord channel category. """Represents a Discord channel category.
@ -558,8 +550,7 @@ class CategoryChannel(discord.abc.GuildChannel, Hashable):
n = self.name n = self.name
return self.nsfw or n == 'nsfw' or n[:5] == 'nsfw-' return self.nsfw or n == 'nsfw' or n[:5] == 'nsfw-'
@asyncio.coroutine async def edit(self, *, reason=None, **options):
def edit(self, *, reason=None, **options):
"""|coro| """|coro|
Edits the channel. Edits the channel.
@ -593,11 +584,11 @@ class CategoryChannel(discord.abc.GuildChannel, Hashable):
except KeyError: except KeyError:
pass pass
else: else:
yield from self._move(position, reason=reason) await self._move(position, reason=reason)
self.position = position self.position = position
if options: if options:
data = yield from self._state.http.edit_channel(self.id, reason=reason, **options) data = await self._state.http.edit_channel(self.id, reason=reason, **options)
self._update(self.guild, data) self._update(self.guild, data)
@property @property
@ -652,8 +643,7 @@ class DMChannel(discord.abc.Messageable, Hashable):
self.me = me self.me = me
self.id = int(data['id']) self.id = int(data['id'])
@asyncio.coroutine async def _get_channel(self):
def _get_channel(self):
return self return self
def __str__(self): def __str__(self):
@ -756,8 +746,7 @@ class GroupChannel(discord.abc.Messageable, Hashable):
else: else:
self.owner = utils.find(lambda u: u.id == owner_id, self.recipients) self.owner = utils.find(lambda u: u.id == owner_id, self.recipients)
@asyncio.coroutine async def _get_channel(self):
def _get_channel(self):
return self return self
def __str__(self): def __str__(self):
@ -820,8 +809,7 @@ class GroupChannel(discord.abc.Messageable, Hashable):
return base return base
@asyncio.coroutine async def add_recipients(self, *recipients):
def add_recipients(self, *recipients):
"""|coro| """|coro|
Adds recipients to this group. Adds recipients to this group.
@ -846,10 +834,9 @@ class GroupChannel(discord.abc.Messageable, Hashable):
req = self._state.http.add_group_recipient req = self._state.http.add_group_recipient
for recipient in recipients: for recipient in recipients:
yield from req(self.id, recipient.id) await req(self.id, recipient.id)
@asyncio.coroutine async def remove_recipients(self, *recipients):
def remove_recipients(self, *recipients):
"""|coro| """|coro|
Removes recipients from this group. Removes recipients from this group.
@ -869,10 +856,9 @@ class GroupChannel(discord.abc.Messageable, Hashable):
req = self._state.http.remove_group_recipient req = self._state.http.remove_group_recipient
for recipient in recipients: for recipient in recipients:
yield from req(self.id, recipient.id) await req(self.id, recipient.id)
@asyncio.coroutine async def edit(self, **fields):
def edit(self, **fields):
"""|coro| """|coro|
Edits the group. Edits the group.
@ -900,11 +886,10 @@ class GroupChannel(discord.abc.Messageable, Hashable):
if icon_bytes is not None: if icon_bytes is not None:
fields['icon'] = utils._bytes_to_base64_data(icon_bytes) fields['icon'] = utils._bytes_to_base64_data(icon_bytes)
data = yield from self._state.http.edit_group(self.id, **fields) data = await self._state.http.edit_group(self.id, **fields)
self._update_group(data) self._update_group(data)
@asyncio.coroutine async def leave(self):
def leave(self):
"""|coro| """|coro|
Leave the group. Leave the group.
@ -917,7 +902,7 @@ class GroupChannel(discord.abc.Messageable, Hashable):
Leaving the group failed. Leaving the group failed.
""" """
yield from self._state.http.leave_group(self.id) await self._state.http.leave_group(self.id)
def _channel_factory(channel_type): def _channel_factory(channel_type):
value = try_enum(ChannelType, channel_type) value = try_enum(ChannelType, channel_type)

128
discord/client.py
View File

@ -48,7 +48,6 @@ import sys, re
import signal import signal
from collections import namedtuple from collections import namedtuple
PY35 = sys.version_info >= (3, 5)
log = logging.getLogger(__name__) log = logging.getLogger(__name__)
AppInfo = namedtuple('AppInfo', 'id name description icon owner') AppInfo = namedtuple('AppInfo', 'id name description icon owner')
@ -139,12 +138,10 @@ class Client:
# internals # internals
@asyncio.coroutine async def _syncer(self, guilds):
def _syncer(self, guilds): await self.ws.request_sync(guilds)
yield from self.ws.request_sync(guilds)
@asyncio.coroutine async def _chunker(self, guild):
def _chunker(self, guild):
try: try:
guild_id = guild.id guild_id = guild.id
except AttributeError: except AttributeError:
@ -159,7 +156,7 @@ class Client:
} }
} }
yield from self.ws.send_as_json(payload) await self.ws.send_as_json(payload)
def handle_ready(self): def handle_ready(self):
self._ready.set() self._ready.set()
@ -218,15 +215,14 @@ class Client:
""":obj:`bool`: Specifies if the client's internal cache is ready for use.""" """:obj:`bool`: Specifies if the client's internal cache is ready for use."""
return self._ready.is_set() return self._ready.is_set()
@asyncio.coroutine async def _run_event(self, coro, event_name, *args, **kwargs):
def _run_event(self, coro, event_name, *args, **kwargs):
try: try:
yield from coro(*args, **kwargs) await coro(*args, **kwargs)
except asyncio.CancelledError: except asyncio.CancelledError:
pass pass
except Exception: except Exception:
try: try:
yield from self.on_error(event_name, *args, **kwargs) await self.on_error(event_name, *args, **kwargs)
except asyncio.CancelledError: except asyncio.CancelledError:
pass pass
@ -276,10 +272,9 @@ class Client:
except AttributeError: except AttributeError:
pass pass
else: else:
compat.create_task(self._run_event(coro, method, *args, **kwargs), loop=self.loop) asyncio.ensure_future(self._run_event(coro, method, *args, **kwargs), loop=self.loop)
@asyncio.coroutine async def on_error(self, event_method, *args, **kwargs):
def on_error(self, event_method, *args, **kwargs):
"""|coro| """|coro|
The default error handler provided by the client. The default error handler provided by the client.
@ -291,8 +286,7 @@ class Client:
print('Ignoring exception in {}'.format(event_method), file=sys.stderr) print('Ignoring exception in {}'.format(event_method), file=sys.stderr)
traceback.print_exc() traceback.print_exc()
@asyncio.coroutine async def request_offline_members(self, *guilds):
def request_offline_members(self, *guilds):
"""|coro| """|coro|
Requests previously offline members from the guild to be filled up Requests previously offline members from the guild to be filled up
@ -318,12 +312,11 @@ class Client:
if any(not g.large or g.unavailable for g in guilds): if any(not g.large or g.unavailable for g in guilds):
raise InvalidArgument('An unavailable or non-large guild was passed.') raise InvalidArgument('An unavailable or non-large guild was passed.')
yield from self._connection.request_offline_members(guilds) await self._connection.request_offline_members(guilds)
# login state management # login state management
@asyncio.coroutine async def login(self, token, *, bot=True):
def login(self, token, *, bot=True):
"""|coro| """|coro|
Logs in the client with the specified credentials. Logs in the client with the specified credentials.
@ -350,34 +343,31 @@ class Client:
""" """
log.info('logging in using static token') log.info('logging in using static token')
yield from self.http.static_login(token, bot=bot) await self.http.static_login(token, bot=bot)
self._connection.is_bot = bot self._connection.is_bot = bot
@asyncio.coroutine async def logout(self):
def logout(self):
"""|coro| """|coro|
Logs out of Discord and closes all connections. Logs out of Discord and closes all connections.
""" """
yield from self.close() await self.close()
@asyncio.coroutine async def _connect(self):
def _connect(self):
coro = DiscordWebSocket.from_client(self, shard_id=self.shard_id) coro = DiscordWebSocket.from_client(self, shard_id=self.shard_id)
self.ws = yield from asyncio.wait_for(coro, timeout=180.0, loop=self.loop) self.ws = await asyncio.wait_for(coro, timeout=180.0, loop=self.loop)
while True: while True:
try: try:
yield from self.ws.poll_event() await self.ws.poll_event()
except ResumeWebSocket as e: except ResumeWebSocket as e:
log.info('Got a request to RESUME the websocket.') log.info('Got a request to RESUME the websocket.')
coro = DiscordWebSocket.from_client(self, shard_id=self.shard_id, coro = DiscordWebSocket.from_client(self, shard_id=self.shard_id,
session=self.ws.session_id, session=self.ws.session_id,
sequence=self.ws.sequence, sequence=self.ws.sequence,
resume=True) resume=True)
self.ws = yield from asyncio.wait_for(coro, timeout=180.0, loop=self.loop) self.ws = await asyncio.wait_for(coro, timeout=180.0, loop=self.loop)
@asyncio.coroutine async def connect(self, *, reconnect=True):
def connect(self, *, reconnect=True):
"""|coro| """|coro|
Creates a websocket connection and lets the websocket listen Creates a websocket connection and lets the websocket listen
@ -405,7 +395,7 @@ class Client:
backoff = ExponentialBackoff() backoff = ExponentialBackoff()
while not self.is_closed(): while not self.is_closed():
try: try:
yield from self._connect() await self._connect()
except (OSError, except (OSError,
HTTPException, HTTPException,
GatewayNotFound, GatewayNotFound,
@ -416,7 +406,7 @@ class Client:
websockets.WebSocketProtocolError) as e: websockets.WebSocketProtocolError) as e:
if not reconnect: if not reconnect:
yield from self.close() await self.close()
if isinstance(e, ConnectionClosed) and e.code == 1000: if isinstance(e, ConnectionClosed) and e.code == 1000:
# clean close, don't re-raise this # clean close, don't re-raise this
return return
@ -431,15 +421,14 @@ class Client:
# regardless and rely on is_closed instead # regardless and rely on is_closed instead
if isinstance(e, ConnectionClosed): if isinstance(e, ConnectionClosed):
if e.code != 1000: if e.code != 1000:
yield from self.close() await self.close()
raise raise
retry = backoff.delay() retry = backoff.delay()
log.exception("Attempting a reconnect in %.2fs", retry) log.exception("Attempting a reconnect in %.2fs", retry)
yield from asyncio.sleep(retry, loop=self.loop) await asyncio.sleep(retry, loop=self.loop)
@asyncio.coroutine async def close(self):
def close(self):
"""|coro| """|coro|
Closes the connection to discord. Closes the connection to discord.
@ -451,16 +440,16 @@ class Client:
for voice in self.voice_clients: for voice in self.voice_clients:
try: try:
yield from voice.disconnect() await voice.disconnect()
except: except:
# if an error happens during disconnects, disregard it. # if an error happens during disconnects, disregard it.
pass pass
if self.ws is not None and self.ws.open: if self.ws is not None and self.ws.open:
yield from self.ws.close() await self.ws.close()
yield from self.http.close() await self.http.close()
self._ready.clear() self._ready.clear()
def clear(self): def clear(self):
@ -475,8 +464,7 @@ class Client:
self._connection.clear() self._connection.clear()
self.http.recreate() self.http.recreate()
@asyncio.coroutine async def start(self, *args, **kwargs):
def start(self, *args, **kwargs):
"""|coro| """|coro|
A shorthand coroutine for :meth:`login` + :meth:`connect`. A shorthand coroutine for :meth:`login` + :meth:`connect`.
@ -484,8 +472,8 @@ class Client:
bot = kwargs.pop('bot', True) bot = kwargs.pop('bot', True)
reconnect = kwargs.pop('reconnect', True) reconnect = kwargs.pop('reconnect', True)
yield from self.login(*args, bot=bot) await self.login(*args, bot=bot)
yield from self.connect(reconnect=reconnect) await self.connect(reconnect=reconnect)
def _do_cleanup(self): def _do_cleanup(self):
log.info('Cleaning up event loop.') log.info('Cleaning up event loop.')
@ -493,7 +481,7 @@ class Client:
if loop.is_closed(): if loop.is_closed():
return # we're already cleaning up return # we're already cleaning up
task = compat.create_task(self.close(), loop=loop) task = asyncio.ensure_future(self.close(), loop=loop)
def _silence_gathered(fut): def _silence_gathered(fut):
try: try:
@ -558,7 +546,7 @@ class Client:
loop.add_signal_handler(signal.SIGINT, self._do_cleanup) loop.add_signal_handler(signal.SIGINT, self._do_cleanup)
loop.add_signal_handler(signal.SIGTERM, self._do_cleanup) loop.add_signal_handler(signal.SIGTERM, self._do_cleanup)
task = compat.create_task(self.start(*args, **kwargs), loop=loop) task = asyncio.ensure_future(self.start(*args, **kwargs), loop=loop)
def stop_loop_on_finish(fut): def stop_loop_on_finish(fut):
loop.stop() loop.stop()
@ -661,13 +649,12 @@ class Client:
# listeners/waiters # listeners/waiters
@asyncio.coroutine async def wait_until_ready(self):
def wait_until_ready(self):
"""|coro| """|coro|
Waits until the client's internal cache is all ready. Waits until the client's internal cache is all ready.
""" """
yield from self._ready.wait() await self._ready.wait()
def wait_for(self, event, *, check=None, timeout=None): def wait_for(self, event, *, check=None, timeout=None):
"""|coro| """|coro|
@ -751,7 +738,7 @@ class Client:
:ref:`event reference <discord-api-events>`. :ref:`event reference <discord-api-events>`.
""" """
future = compat.create_future(self.loop) future = self.loop.create_future()
if check is None: if check is None:
def _check(*args): def _check(*args):
return True return True
@ -782,8 +769,7 @@ class Client:
Using the basic :meth:`event` decorator: :: Using the basic :meth:`event` decorator: ::
@client.event @client.event
@asyncio.coroutine async def on_ready():
def on_ready():
print('Ready!') print('Ready!')
Saving characters by using the :meth:`async_event` decorator: :: Saving characters by using the :meth:`async_event` decorator: ::
@ -808,8 +794,7 @@ class Client:
return self.event(coro) return self.event(coro)
@asyncio.coroutine async def change_presence(self, *, activity=None, status=None, afk=False):
def change_presence(self, *, activity=None, status=None, afk=False):
"""|coro| """|coro|
Changes the client's presence. Changes the client's presence.
@ -851,7 +836,7 @@ class Client:
status_enum = status status_enum = status
status = str(status) status = str(status)
yield from self.ws.change_presence(activity=activity, status=status, afk=afk) await self.ws.change_presence(activity=activity, status=status, afk=afk)
for guild in self._connection.guilds: for guild in self._connection.guilds:
me = guild.me me = guild.me
@ -863,8 +848,7 @@ class Client:
# Guild stuff # Guild stuff
@asyncio.coroutine async def create_guild(self, name, region=None, icon=None):
def create_guild(self, name, region=None, icon=None):
"""|coro| """|coro|
Creates a :class:`Guild`. Creates a :class:`Guild`.
@ -903,13 +887,12 @@ class Client:
else: else:
region = region.value region = region.value
data = yield from self.http.create_guild(name, region, icon) data = await self.http.create_guild(name, region, icon)
return Guild(data=data, state=self._connection) return Guild(data=data, state=self._connection)
# Invite management # Invite management
@asyncio.coroutine async def get_invite(self, url):
def get_invite(self, url):
"""|coro| """|coro|
Gets an :class:`Invite` from a discord.gg URL or ID. Gets an :class:`Invite` from a discord.gg URL or ID.
@ -939,11 +922,10 @@ class Client:
""" """
invite_id = self._resolve_invite(url) invite_id = self._resolve_invite(url)
data = yield from self.http.get_invite(invite_id) data = await self.http.get_invite(invite_id)
return Invite.from_incomplete(state=self._connection, data=data) return Invite.from_incomplete(state=self._connection, data=data)
@asyncio.coroutine async def delete_invite(self, invite):
def delete_invite(self, invite):
"""|coro| """|coro|
Revokes an :class:`Invite`, URL, or ID to an invite. Revokes an :class:`Invite`, URL, or ID to an invite.
@ -967,12 +949,11 @@ class Client:
""" """
invite_id = self._resolve_invite(invite) invite_id = self._resolve_invite(invite)
yield from self.http.delete_invite(invite_id) await self.http.delete_invite(invite_id)
# Miscellaneous stuff # Miscellaneous stuff
@asyncio.coroutine async def application_info(self):
def application_info(self):
"""|coro| """|coro|
Retrieve's the bot's application information. Retrieve's the bot's application information.
@ -987,13 +968,12 @@ class Client:
HTTPException HTTPException
Retrieving the information failed somehow. Retrieving the information failed somehow.
""" """
data = yield from self.http.application_info() data = await self.http.application_info()
return AppInfo(id=int(data['id']), name=data['name'], return AppInfo(id=int(data['id']), name=data['name'],
description=data['description'], icon=data['icon'], description=data['description'], icon=data['icon'],
owner=User(state=self._connection, data=data['owner'])) owner=User(state=self._connection, data=data['owner']))
@asyncio.coroutine async def get_user_info(self, user_id):
def get_user_info(self, user_id):
"""|coro| """|coro|
Retrieves a :class:`User` based on their ID. This can only Retrieves a :class:`User` based on their ID. This can only
@ -1018,11 +998,10 @@ class Client:
HTTPException HTTPException
Fetching the user failed. Fetching the user failed.
""" """
data = yield from self.http.get_user_info(user_id) data = await self.http.get_user_info(user_id)
return User(state=self._connection, data=data) return User(state=self._connection, data=data)
@asyncio.coroutine async def get_user_profile(self, user_id):
def get_user_profile(self, user_id):
"""|coro| """|coro|
Gets an arbitrary user's profile. This can only be used by non-bot accounts. Gets an arbitrary user's profile. This can only be used by non-bot accounts.
@ -1046,7 +1025,7 @@ class Client:
""" """
state = self._connection state = self._connection
data = yield from self.http.get_user_profile(user_id) data = await self.http.get_user_profile(user_id)
def transform(d): def transform(d):
return state._get_guild(int(d['id'])) return state._get_guild(int(d['id']))
@ -1060,8 +1039,7 @@ class Client:
user=User(data=user, state=state), user=User(data=user, state=state),
connected_accounts=data['connected_accounts']) connected_accounts=data['connected_accounts'])
@asyncio.coroutine async def get_webhook_info(self, webhook_id):
def get_webhook_info(self, webhook_id):
"""|coro| """|coro|
Retrieves a :class:`Webhook` with the specified ID. Retrieves a :class:`Webhook` with the specified ID.
@ -1080,5 +1058,5 @@ class Client:
:class:`Webhook` :class:`Webhook`
The webhook you requested. The webhook you requested.
""" """
data = yield from self.http.get_webhook(webhook_id) data = await self.http.get_webhook(webhook_id)
return Webhook.from_state(data, state=self._connection) return Webhook.from_state(data, state=self._connection)

140
discord/compat.py
View File

@ -1,140 +0,0 @@
# -*- coding: utf-8 -*-
"""
The MIT License (MIT)
Copyright (c) 2015-2017 Rapptz
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
"""
import concurrent.futures
import asyncio
try:
create_task = asyncio.ensure_future
except AttributeError:
create_task = getattr(asyncio, 'async')
try:
_create_future = asyncio.AbstractEventLoop.create_future
except AttributeError:
def create_future(loop):
return asyncio.Future(loop=loop)
else:
def create_future(loop):
return loop.create_future()
try:
run_coroutine_threadsafe = asyncio.run_coroutine_threadsafe
except AttributeError:
# the following code is slightly modified from the
# official asyncio repository that could be found here:
# https://github.com/python/asyncio/blob/master/asyncio/futures.py
# with a commit hash of 5c7efbcdfbe6a5c25b4cd5df22d9a15ab4062c8e
# this portion is licensed under Apache license 2.0
def _set_concurrent_future_state(concurrent, source):
"""Copy state from a future to a concurrent.futures.Future."""
assert source.done()
if source.cancelled():
concurrent.cancel()
if not concurrent.set_running_or_notify_cancel():
return
exception = source.exception()
if exception is not None:
concurrent.set_exception(exception)
else:
result = source.result()
concurrent.set_result(result)
def _copy_future_state(source, dest):
"""Internal helper to copy state from another Future.
The other Future may be a concurrent.futures.Future.
"""
assert source.done()
if dest.cancelled():
return
assert not dest.done()
if source.cancelled():
dest.cancel()
else:
exception = source.exception()
if exception is not None:
dest.set_exception(exception)
else:
result = source.result()
dest.set_result(result)
def _chain_future(source, destination):
"""Chain two futures so that when one completes, so does the other.
The result (or exception) of source will be copied to destination.
If destination is cancelled, source gets cancelled too.
Compatible with both asyncio.Future and concurrent.futures.Future.
"""
if not isinstance(source, (asyncio.Future, concurrent.futures.Future)):
raise TypeError('A future is required for source argument')
if not isinstance(destination, (asyncio.Future, concurrent.futures.Future)):
raise TypeError('A future is required for destination argument')
source_loop = source._loop if isinstance(source, asyncio.Future) else None
dest_loop = destination._loop if isinstance(destination, asyncio.Future) else None
def _set_state(future, other):
if isinstance(future, asyncio.Future):
_copy_future_state(other, future)
else:
_set_concurrent_future_state(future, other)
def _call_check_cancel(destination):
if destination.cancelled():
if source_loop is None or source_loop is dest_loop:
source.cancel()
else:
source_loop.call_soon_threadsafe(source.cancel)
def _call_set_state(source):
if dest_loop is None or dest_loop is source_loop:
_set_state(destination, source)
else:
dest_loop.call_soon_threadsafe(_set_state, destination, source)
destination.add_done_callback(_call_check_cancel)
source.add_done_callback(_call_set_state)
def run_coroutine_threadsafe(coro, loop):
"""Submit a coroutine object to a given event loop.
Return a concurrent.futures.Future to access the result.
"""
if not asyncio.iscoroutine(coro):
raise TypeError('A coroutine object is required')
future = concurrent.futures.Future()
def callback():
try:
_chain_future(create_task(coro, loop=loop), future)
except Exception as exc:
if future.set_running_or_notify_cancel():
future.set_exception(exc)
raise
loop.call_soon_threadsafe(callback)
return future

19
discord/context_managers.py
View File

@ -40,18 +40,17 @@ class Typing:
self.loop = messageable._state.loop self.loop = messageable._state.loop
self.messageable = messageable self.messageable = messageable
@asyncio.coroutine async def do_typing(self):
def do_typing(self):
try: try:
channel = self._channel channel = self._channel
except AttributeError: except AttributeError:
channel = yield from self.messageable._get_channel() channel = await self.messageable._get_channel()
typing = channel._state.http.send_typing typing = channel._state.http.send_typing
while True: while True:
yield from typing(channel.id) await typing(channel.id)
yield from asyncio.sleep(5) await asyncio.sleep(5)
def __enter__(self): def __enter__(self):
self.task = create_task(self.do_typing(), loop=self.loop) self.task = create_task(self.do_typing(), loop=self.loop)
@ -61,12 +60,10 @@ class Typing:
def __exit__(self, exc_type, exc, tb): def __exit__(self, exc_type, exc, tb):
self.task.cancel() self.task.cancel()
@asyncio.coroutine async def __aenter__(self):
def __aenter__(self): self._channel = channel = await self.messageable._get_channel()
self._channel = channel = yield from self.messageable._get_channel() await channel._state.http.send_typing(channel.id)
yield from channel._state.http.send_typing(channel.id)
return self.__enter__() return self.__enter__()
@asyncio.coroutine async def __aexit__(self, exc_type, exc, tb):
def __aexit__(self, exc_type, exc, tb):
self.task.cancel() self.task.cancel()

10
discord/emoji.py
View File

@ -203,8 +203,7 @@ class Emoji(Hashable):
""":class:`Guild`: The guild this emoji belongs to.""" """:class:`Guild`: The guild this emoji belongs to."""
return self._state._get_guild(self.guild_id) return self._state._get_guild(self.guild_id)
@asyncio.coroutine async def delete(self, *, reason=None):
def delete(self, *, reason=None):
"""|coro| """|coro|
Deletes the custom emoji. Deletes the custom emoji.
@ -227,10 +226,9 @@ class Emoji(Hashable):
An error occurred deleting the emoji. An error occurred deleting the emoji.
""" """
yield from self._state.http.delete_custom_emoji(self.guild.id, self.id, reason=reason) await self._state.http.delete_custom_emoji(self.guild.id, self.id, reason=reason)
@asyncio.coroutine async def edit(self, *, name, reason=None):
def edit(self, *, name, reason=None):
"""|coro| """|coro|
Edits the custom emoji. Edits the custom emoji.
@ -255,4 +253,4 @@ class Emoji(Hashable):
An error occurred editing the emoji. An error occurred editing the emoji.
""" """
yield from self._state.http.edit_custom_emoji(self.guild.id, self.id, name=name, reason=reason) await self._state.http.edit_custom_emoji(self.guild.id, self.id, name=name, reason=reason)

4
discord/errors.py
View File

@ -40,9 +40,7 @@ class ClientException(DiscordException):
class NoMoreItems(DiscordException): class NoMoreItems(DiscordException):
"""Exception that is thrown when an async iteration operation has no more """Exception that is thrown when an async iteration operation has no more
items. This is mainly exposed for Python 3.4 support where `StopAsyncIteration` items."""
is not provided.
"""
pass pass
class GatewayNotFound(DiscordException): class GatewayNotFound(DiscordException):

72
discord/ext/commands/bot.py
View File

@ -91,8 +91,7 @@ _mention_pattern = re.compile('|'.join(_mentions_transforms.keys()))
def _is_submodule(parent, child): def _is_submodule(parent, child):
return parent == child or child.startswith(parent + ".") return parent == child or child.startswith(parent + ".")
@asyncio.coroutine async def _default_help_command(ctx, *commands : str):
def _default_help_command(ctx, *commands : str):
"""Shows this message.""" """Shows this message."""
bot = ctx.bot bot = ctx.bot
destination = ctx.message.author if bot.pm_help else ctx.message.channel 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. # help by itself just lists our own commands.
if len(commands) == 0: 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: elif len(commands) == 1:
# try to see if it is a cog name # try to see if it is a cog name
name = _mention_pattern.sub(repl, commands[0]) name = _mention_pattern.sub(repl, commands[0])
@ -112,15 +111,15 @@ def _default_help_command(ctx, *commands : str):
else: else:
command = bot.all_commands.get(name) command = bot.all_commands.get(name)
if command is None: if command is None:
yield from destination.send(bot.command_not_found.format(name)) await destination.send(bot.command_not_found.format(name))
return return
pages = yield from bot.formatter.format_help_for(ctx, command) pages = await bot.formatter.format_help_for(ctx, command)
else: else:
name = _mention_pattern.sub(repl, commands[0]) name = _mention_pattern.sub(repl, commands[0])
command = bot.all_commands.get(name) command = bot.all_commands.get(name)
if command is None: if command is None:
yield from destination.send(bot.command_not_found.format(name)) await destination.send(bot.command_not_found.format(name))
return return
for key in commands[1:]: for key in commands[1:]:
@ -128,13 +127,13 @@ def _default_help_command(ctx, *commands : str):
key = _mention_pattern.sub(repl, key) key = _mention_pattern.sub(repl, key)
command = command.all_commands.get(key) command = command.all_commands.get(key)
if command is None: if command is None:
yield from destination.send(bot.command_not_found.format(key)) await destination.send(bot.command_not_found.format(key))
return return
except AttributeError: 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 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: if bot.pm_help is None:
characters = sum(map(lambda l: len(l), pages)) characters = sum(map(lambda l: len(l), pages))
@ -143,7 +142,7 @@ def _default_help_command(ctx, *commands : str):
destination = ctx.message.author destination = ctx.message.author
for page in pages: for page in pages:
yield from destination.send(page) await destination.send(page)
class BotBase(GroupMixin): class BotBase(GroupMixin):
def __init__(self, command_prefix, formatter=None, description=None, pm_help=False, **options): def __init__(self, command_prefix, formatter=None, description=None, pm_help=False, **options):
@ -189,10 +188,9 @@ class BotBase(GroupMixin):
ev = 'on_' + event_name ev = 'on_' + event_name
for event in self.extra_events.get(ev, []): for event in self.extra_events.get(ev, []):
coro = self._run_event(event, event_name, *args, **kwargs) 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 async def close(self):
def close(self):
for extension in tuple(self.extensions): for extension in tuple(self.extensions):
try: try:
self.unload_extension(extension) self.unload_extension(extension)
@ -205,10 +203,9 @@ class BotBase(GroupMixin):
except: except:
pass pass
yield from super().close() await super().close()
@asyncio.coroutine async def on_command_error(self, context, exception):
def on_command_error(self, context, exception):
"""|coro| """|coro|
The default command error handler provided by the bot. The default command error handler provided by the bot.
@ -335,17 +332,15 @@ class BotBase(GroupMixin):
self.add_check(func, call_once=True) self.add_check(func, call_once=True)
return func return func
@asyncio.coroutine async def can_run(self, ctx, *, call_once=False):
def can_run(self, ctx, *, call_once=False):
data = self._check_once if call_once else self._checks data = self._check_once if call_once else self._checks
if len(data) == 0: if len(data) == 0:
return True 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 async def is_owner(self, user):
def is_owner(self, user):
"""Checks if a :class:`.User` or :class:`.Member` is the owner of """Checks if a :class:`.User` or :class:`.Member` is the owner of
this bot. this bot.
@ -359,7 +354,7 @@ class BotBase(GroupMixin):
""" """
if self.owner_id is None: 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 self.owner_id = owner_id = app.owner.id
return user.id == owner_id return user.id == owner_id
return user.id == self.owner_id return user.id == self.owner_id
@ -773,8 +768,7 @@ class BotBase(GroupMixin):
# command processing # command processing
@asyncio.coroutine async def get_prefix(self, message):
def get_prefix(self, message):
"""|coro| """|coro|
Retrieves the prefix the bot is listening to Retrieves the prefix the bot is listening to
@ -801,9 +795,7 @@ class BotBase(GroupMixin):
""" """
prefix = ret = self.command_prefix prefix = ret = self.command_prefix
if callable(prefix): if callable(prefix):
ret = prefix(self, message) ret = await discord.utils.maybe_coroutine(prefix, self, ret)
if asyncio.iscoroutine(ret):
ret = yield from ret
if isinstance(ret, (list, tuple)): if isinstance(ret, (list, tuple)):
ret = [p for p in ret if p] ret = [p for p in ret if p]
@ -813,8 +805,7 @@ class BotBase(GroupMixin):
return ret return ret
@asyncio.coroutine async def get_context(self, message, *, cls=Context):
def get_context(self, message, *, cls=Context):
"""|coro| """|coro|
Returns the invocation context from the message. Returns the invocation context from the message.
@ -850,7 +841,7 @@ class BotBase(GroupMixin):
if self._skip_check(message.author.id, self.user.id): if self._skip_check(message.author.id, self.user.id):
return ctx return ctx
prefix = yield from self.get_prefix(message) prefix = await self.get_prefix(message)
invoked_prefix = prefix invoked_prefix = prefix
if isinstance(prefix, str): if isinstance(prefix, str):
@ -867,8 +858,7 @@ class BotBase(GroupMixin):
ctx.command = self.all_commands.get(invoker) ctx.command = self.all_commands.get(invoker)
return ctx return ctx
@asyncio.coroutine async def invoke(self, ctx):
def invoke(self, ctx):
"""|coro| """|coro|
Invokes the command given under the invocation context and Invokes the command given under the invocation context and
@ -882,18 +872,17 @@ class BotBase(GroupMixin):
if ctx.command is not None: if ctx.command is not None:
self.dispatch('command', ctx) self.dispatch('command', ctx)
try: try:
if (yield from self.can_run(ctx, call_once=True)): if (await self.can_run(ctx, call_once=True)):
yield from ctx.command.invoke(ctx) await ctx.command.invoke(ctx)
except CommandError as e: except CommandError as e:
yield from ctx.command.dispatch_error(ctx, e) await ctx.command.dispatch_error(ctx, e)
else: else:
self.dispatch('command_completion', ctx) self.dispatch('command_completion', ctx)
elif ctx.invoked_with: elif ctx.invoked_with:
exc = CommandNotFound('Command "{}" is not found'.format(ctx.invoked_with)) exc = CommandNotFound('Command "{}" is not found'.format(ctx.invoked_with))
self.dispatch('command_error', ctx, exc) self.dispatch('command_error', ctx, exc)
@asyncio.coroutine async def process_commands(self, message):
def process_commands(self, message):
"""|coro| """|coro|
This function processes the commands that have been registered This function processes the commands that have been registered
@ -912,12 +901,11 @@ class BotBase(GroupMixin):
message : discord.Message message : discord.Message
The message to process commands for. The message to process commands for.
""" """
ctx = yield from self.get_context(message) ctx = await self.get_context(message)
yield from self.invoke(ctx) await self.invoke(ctx)
@asyncio.coroutine async def on_message(self, message):
def on_message(self, message): await self.process_commands(message)
yield from self.process_commands(message)
class Bot(BotBase, discord.Client): class Bot(BotBase, discord.Client):
"""Represents a discord bot. """Represents a discord bot.

13
discord/ext/commands/context.py
View File

@ -86,8 +86,7 @@ class Context(discord.abc.Messageable):
self.command_failed = attrs.pop('command_failed', False) self.command_failed = attrs.pop('command_failed', False)
self._state = self.message._state self._state = self.message._state
@asyncio.coroutine async def invoke(self, *args, **kwargs):
def invoke(self, *args, **kwargs):
"""|coro| """|coro|
Calls a command with the arguments given. Calls a command with the arguments given.
@ -125,11 +124,10 @@ class Context(discord.abc.Messageable):
arguments.append(self) arguments.append(self)
arguments.extend(args[1:]) arguments.extend(args[1:])
ret = yield from command.callback(*arguments, **kwargs) ret = await command.callback(*arguments, **kwargs)
return ret return ret
@asyncio.coroutine async def reinvoke(self, *, call_hooks=False, restart=True):
def reinvoke(self, *, call_hooks=False, restart=True):
"""|coro| """|coro|
Calls the command again. Calls the command again.
@ -174,7 +172,7 @@ class Context(discord.abc.Messageable):
to_call = cmd to_call = cmd
try: try:
yield from to_call.reinvoke(self, call_hooks=call_hooks) await to_call.reinvoke(self, call_hooks=call_hooks)
finally: finally:
self.command = cmd self.command = cmd
view.index = index view.index = index
@ -188,8 +186,7 @@ class Context(discord.abc.Messageable):
"""Checks if the invocation context is valid to be invoked with.""" """Checks if the invocation context is valid to be invoked with."""
return self.prefix is not None and self.command is not None return self.prefix is not None and self.command is not None
@asyncio.coroutine async def _get_channel(self):
def _get_channel(self):
return self.channel return self.channel
@property @property

41
discord/ext/commands/converter.py
View File

@ -57,8 +57,7 @@ class Converter:
method to do its conversion logic. This method must be a coroutine. method to do its conversion logic. This method must be a coroutine.
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
"""|coro| """|coro|
The method to override to do conversion logic. The method to override to do conversion logic.
@ -99,8 +98,7 @@ class MemberConverter(IDConverter):
5. Lookup by nickname 5. Lookup by nickname
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
message = ctx.message message = ctx.message
bot = ctx.bot bot = ctx.bot
match = self._get_id_match(argument) or re.match(r'<@!?([0-9]+)>$', argument) 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 3. Lookup by name#discrim
4. Lookup by name 4. Lookup by name
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
match = self._get_id_match(argument) or re.match(r'<@!?([0-9]+)>$', argument) match = self._get_id_match(argument) or re.match(r'<@!?([0-9]+)>$', argument)
result = None result = None
state = ctx._state state = ctx._state
@ -176,8 +173,7 @@ class TextChannelConverter(IDConverter):
2. Lookup by mention. 2. Lookup by mention.
3. Lookup by name 3. Lookup by name
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
bot = ctx.bot bot = ctx.bot
match = self._get_id_match(argument) or re.match(r'<#([0-9]+)>$', argument) match = self._get_id_match(argument) or re.match(r'<#([0-9]+)>$', argument)
@ -216,8 +212,7 @@ class VoiceChannelConverter(IDConverter):
2. Lookup by mention. 2. Lookup by mention.
3. Lookup by name 3. Lookup by name
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
bot = ctx.bot bot = ctx.bot
match = self._get_id_match(argument) or re.match(r'<#([0-9]+)>$', argument) match = self._get_id_match(argument) or re.match(r'<#([0-9]+)>$', argument)
result = None result = None
@ -255,8 +250,7 @@ class CategoryChannelConverter(IDConverter):
2. Lookup by mention. 2. Lookup by mention.
3. Lookup by name 3. Lookup by name
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
bot = ctx.bot bot = ctx.bot
match = self._get_id_match(argument) or re.match(r'<#([0-9]+)>$', argument) 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. - The ``_`` in the name can be optionally replaced with spaces.
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
arg = argument.replace('0x', '').lower() arg = argument.replace('0x', '').lower()
if arg[0] == '#': if arg[0] == '#':
@ -323,8 +316,7 @@ class RoleConverter(IDConverter):
2. Lookup by mention. 2. Lookup by mention.
3. Lookup by name 3. Lookup by name
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
guild = ctx.message.guild guild = ctx.message.guild
if not guild: if not guild:
raise NoPrivateMessage() raise NoPrivateMessage()
@ -338,8 +330,7 @@ class RoleConverter(IDConverter):
class GameConverter(Converter): class GameConverter(Converter):
"""Converts to :class:`Game`.""" """Converts to :class:`Game`."""
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
return discord.Game(name=argument) return discord.Game(name=argument)
class InviteConverter(Converter): class InviteConverter(Converter):
@ -347,10 +338,9 @@ class InviteConverter(Converter):
This is done via an HTTP request using :meth:`.Bot.get_invite`. This is done via an HTTP request using :meth:`.Bot.get_invite`.
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
try: try:
invite = yield from ctx.bot.get_invite(argument) invite = await ctx.bot.get_invite(argument)
return invite return invite
except Exception as e: except Exception as e:
raise BadArgument('Invite is invalid or expired') from 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. 2. Lookup by extracting ID from the emoji.
3. Lookup by name 3. Lookup by name
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
match = self._get_id_match(argument) or re.match(r'<a?:[a-zA-Z0-9\_]+:([0-9]+)>$', argument) match = self._get_id_match(argument) or re.match(r'<a?:[a-zA-Z0-9\_]+:([0-9]+)>$', argument)
result = None result = None
bot = ctx.bot bot = ctx.bot
@ -403,8 +392,7 @@ class PartialEmojiConverter(Converter):
This is done by extracting the animated flag, name and ID from the emoji. This is done by extracting the animated flag, name and ID from the emoji.
""" """
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
match = re.match(r'<(a?):([a-zA-Z0-9\_]+):([0-9]+)>$', argument) match = re.match(r'<(a?):([a-zA-Z0-9\_]+):([0-9]+)>$', argument)
if match: if match:
@ -436,8 +424,7 @@ class clean_content(Converter):
self.use_nicknames = use_nicknames self.use_nicknames = use_nicknames
self.escape_markdown = escape_markdown self.escape_markdown = escape_markdown
@asyncio.coroutine async def convert(self, ctx, argument):
def convert(self, ctx, argument):
message = ctx.message message = ctx.message
transformations = {} transformations = {}

140
discord/ext/commands/core.py
View File

@ -41,10 +41,9 @@ __all__ = [ 'Command', 'Group', 'GroupMixin', 'command', 'group',
def wrap_callback(coro): def wrap_callback(coro):
@functools.wraps(coro) @functools.wraps(coro)
@asyncio.coroutine async def wrapped(*args, **kwargs):
def wrapped(*args, **kwargs):
try: try:
ret = yield from coro(*args, **kwargs) ret = await coro(*args, **kwargs)
except CommandError: except CommandError:
raise raise
except asyncio.CancelledError: except asyncio.CancelledError:
@ -56,10 +55,9 @@ def wrap_callback(coro):
def hooked_wrapped_callback(command, ctx, coro): def hooked_wrapped_callback(command, ctx, coro):
@functools.wraps(coro) @functools.wraps(coro)
@asyncio.coroutine async def wrapped(*args, **kwargs):
def wrapped(*args, **kwargs):
try: try:
ret = yield from coro(*args, **kwargs) ret = await coro(*args, **kwargs)
except CommandError: except CommandError:
ctx.command_failed = True ctx.command_failed = True
raise raise
@ -70,7 +68,7 @@ def hooked_wrapped_callback(command, ctx, coro):
ctx.command_failed = True ctx.command_failed = True
raise CommandInvokeError(e) from e raise CommandInvokeError(e) from e
finally: finally:
yield from command.call_after_hooks(ctx) await command.call_after_hooks(ctx)
return ret return ret
return wrapped return wrapped
@ -182,8 +180,7 @@ class Command:
self._before_invoke = None self._before_invoke = None
self._after_invoke = None self._after_invoke = None
@asyncio.coroutine async def dispatch_error(self, ctx, error):
def dispatch_error(self, ctx, error):
ctx.command_failed = True ctx.command_failed = True
cog = self.instance cog = self.instance
try: try:
@ -193,9 +190,9 @@ class Command:
else: else:
injected = wrap_callback(coro) injected = wrap_callback(coro)
if cog is not None: if cog is not None:
yield from injected(cog, ctx, error) await injected(cog, ctx, error)
else: else:
yield from injected(ctx, error) await injected(ctx, error)
try: try:
local = getattr(cog, '_{0.__class__.__name__}__error'.format(cog)) local = getattr(cog, '_{0.__class__.__name__}__error'.format(cog))
@ -203,7 +200,7 @@ class Command:
pass pass
else: else:
wrapped = wrap_callback(local) wrapped = wrap_callback(local)
yield from wrapped(ctx, error) await wrapped(ctx, error)
finally: finally:
ctx.bot.dispatch('command_error', ctx, error) ctx.bot.dispatch('command_error', ctx, error)
@ -212,8 +209,7 @@ class Command:
self.instance = instance self.instance = instance
return self return self
@asyncio.coroutine async def do_conversion(self, ctx, converter, argument):
def do_conversion(self, ctx, converter, argument):
if converter is bool: if converter is bool:
return _convert_to_bool(argument) return _convert_to_bool(argument)
@ -228,15 +224,15 @@ class Command:
if inspect.isclass(converter): if inspect.isclass(converter):
if issubclass(converter, converters.Converter): if issubclass(converter, converters.Converter):
instance = converter() instance = converter()
ret = yield from instance.convert(ctx, argument) ret = await instance.convert(ctx, argument)
return ret return ret
else: else:
method = getattr(converter, 'convert', None) method = getattr(converter, 'convert', None)
if method is not None and inspect.ismethod(method): if method is not None and inspect.ismethod(method):
ret = yield from method(ctx, argument) ret = await method(ctx, argument)
return ret return ret
elif isinstance(converter, converters.Converter): elif isinstance(converter, converters.Converter):
ret = yield from converter.convert(ctx, argument) ret = await converter.convert(ctx, argument)
return ret return ret
return converter(argument) return converter(argument)
@ -250,8 +246,7 @@ class Command:
converter = str converter = str
return converter return converter
@asyncio.coroutine async def transform(self, ctx, param):
def transform(self, ctx, param):
required = param.default is param.empty required = param.default is param.empty
converter = self._get_converter(param) converter = self._get_converter(param)
consume_rest_is_special = param.kind == param.KEYWORD_ONLY and not self.rest_is_raw 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) argument = quoted_word(view)
try: try:
return (yield from self.do_conversion(ctx, converter, argument)) return (await self.do_conversion(ctx, converter, argument))
except CommandError as e: except CommandError as e:
raise e raise e
except Exception as e: except Exception as e:
@ -354,8 +349,7 @@ class Command:
def __str__(self): def __str__(self):
return self.qualified_name return self.qualified_name
@asyncio.coroutine async def _parse_arguments(self, ctx):
def _parse_arguments(self, ctx):
ctx.args = [ctx] if self.instance is None else [self.instance, ctx] ctx.args = [ctx] if self.instance is None else [self.instance, ctx]
ctx.kwargs = {} ctx.kwargs = {}
args = ctx.args args = ctx.args
@ -382,21 +376,21 @@ class Command:
for name, param in iterator: for name, param in iterator:
if param.kind == param.POSITIONAL_OR_KEYWORD: if param.kind == param.POSITIONAL_OR_KEYWORD:
transformed = yield from self.transform(ctx, param) transformed = await self.transform(ctx, param)
args.append(transformed) args.append(transformed)
elif param.kind == param.KEYWORD_ONLY: elif param.kind == param.KEYWORD_ONLY:
# kwarg only param denotes "consume rest" semantics # kwarg only param denotes "consume rest" semantics
if self.rest_is_raw: if self.rest_is_raw:
converter = self._get_converter(param) converter = self._get_converter(param)
argument = view.read_rest() argument = view.read_rest()
kwargs[name] = yield from self.do_conversion(ctx, converter, argument) kwargs[name] = await self.do_conversion(ctx, converter, argument)
else: else:
kwargs[name] = yield from self.transform(ctx, param) kwargs[name] = await self.transform(ctx, param)
break break
elif param.kind == param.VAR_POSITIONAL: elif param.kind == param.VAR_POSITIONAL:
while not view.eof: while not view.eof:
try: try:
transformed = yield from self.transform(ctx, param) transformed = await self.transform(ctx, param)
args.append(transformed) args.append(transformed)
except RuntimeError: except RuntimeError:
break break
@ -405,24 +399,22 @@ class Command:
if not view.eof: if not view.eof:
raise TooManyArguments('Too many arguments passed to ' + self.qualified_name) raise TooManyArguments('Too many arguments passed to ' + self.qualified_name)
@asyncio.coroutine async def _verify_checks(self, ctx):
def _verify_checks(self, ctx):
if not self.enabled: if not self.enabled:
raise DisabledCommand('{0.name} command is disabled'.format(self)) 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)) raise CheckFailure('The check functions for command {0.qualified_name} failed.'.format(self))
@asyncio.coroutine async def call_before_hooks(self, ctx):
def call_before_hooks(self, ctx):
# now that we're done preparing we can call the pre-command hooks # now that we're done preparing we can call the pre-command hooks
# first, call the command local hook: # first, call the command local hook:
cog = self.instance cog = self.instance
if self._before_invoke is not None: if self._before_invoke is not None:
if cog is None: if cog is None:
yield from self._before_invoke(ctx) await self._before_invoke(ctx)
else: else:
yield from self._before_invoke(cog, ctx) await self._before_invoke(cog, ctx)
# call the cog local hook if applicable: # call the cog local hook if applicable:
try: try:
@ -430,37 +422,35 @@ class Command:
except AttributeError: except AttributeError:
pass pass
else: else:
yield from hook(ctx) await hook(ctx)
# call the bot global hook if necessary # call the bot global hook if necessary
hook = ctx.bot._before_invoke hook = ctx.bot._before_invoke
if hook is not None: if hook is not None:
yield from hook(ctx) await hook(ctx)
@asyncio.coroutine async def call_after_hooks(self, ctx):
def call_after_hooks(self, ctx):
cog = self.instance cog = self.instance
if self._after_invoke is not None: if self._after_invoke is not None:
if cog is None: if cog is None:
yield from self._after_invoke(ctx) await self._after_invoke(ctx)
else: else:
yield from self._after_invoke(cog, ctx) await self._after_invoke(cog, ctx)
try: try:
hook = getattr(cog, '_{0.__class__.__name__}__after_invoke'.format(cog)) hook = getattr(cog, '_{0.__class__.__name__}__after_invoke'.format(cog))
except AttributeError: except AttributeError:
pass pass
else: else:
yield from hook(ctx) await hook(ctx)
hook = ctx.bot._after_invoke hook = ctx.bot._after_invoke
if hook is not None: if hook is not None:
yield from hook(ctx) await hook(ctx)
@asyncio.coroutine async def prepare(self, ctx):
def prepare(self, ctx):
ctx.command = self ctx.command = self
yield from self._verify_checks(ctx) await self._verify_checks(ctx)
if self._buckets.valid: if self._buckets.valid:
bucket = self._buckets.get_bucket(ctx.message) bucket = self._buckets.get_bucket(ctx.message)
@ -468,8 +458,8 @@ class Command:
if retry_after: if retry_after:
raise CommandOnCooldown(bucket, retry_after) raise CommandOnCooldown(bucket, retry_after)
yield from self._parse_arguments(ctx) await self._parse_arguments(ctx)
yield from self.call_before_hooks(ctx) await self.call_before_hooks(ctx)
def is_on_cooldown(self, ctx): def is_on_cooldown(self, ctx):
"""Checks whether the command is currently on cooldown. """Checks whether the command is currently on cooldown.
@ -502,34 +492,32 @@ class Command:
bucket = self._buckets.get_bucket(ctx.message) bucket = self._buckets.get_bucket(ctx.message)
bucket.reset() bucket.reset()
@asyncio.coroutine async def invoke(self, ctx):
def invoke(self, ctx): await self.prepare(ctx)
yield from self.prepare(ctx)
# terminate the invoked_subcommand chain. # terminate the invoked_subcommand chain.
# since we're in a regular command (and not a group) then # since we're in a regular command (and not a group) then
# the invoked subcommand is None. # the invoked subcommand is None.
ctx.invoked_subcommand = None ctx.invoked_subcommand = None
injected = hooked_wrapped_callback(self, ctx, self.callback) injected = hooked_wrapped_callback(self, ctx, self.callback)
yield from injected(*ctx.args, **ctx.kwargs) await injected(*ctx.args, **ctx.kwargs)
@asyncio.coroutine async def reinvoke(self, ctx, *, call_hooks=False):
def reinvoke(self, ctx, *, call_hooks=False):
ctx.command = self ctx.command = self
yield from self._parse_arguments(ctx) await self._parse_arguments(ctx)
if call_hooks: if call_hooks:
yield from self.call_before_hooks(ctx) await self.call_before_hooks(ctx)
ctx.invoked_subcommand = None ctx.invoked_subcommand = None
try: try:
yield from self.callback(*ctx.args, **ctx.kwargs) await self.callback(*ctx.args, **ctx.kwargs)
except: except:
ctx.command_failed = True ctx.command_failed = True
raise raise
finally: finally:
if call_hooks: if call_hooks:
yield from self.call_after_hooks(ctx) await self.call_after_hooks(ctx)
def error(self, coro): def error(self, coro):
"""A decorator that registers a coroutine as a local error handler. """A decorator that registers a coroutine as a local error handler.
@ -667,8 +655,7 @@ class Command:
return ' '.join(result) return ' '.join(result)
@asyncio.coroutine async def can_run(self, ctx):
def can_run(self, ctx):
"""|coro| """|coro|
Checks if the command can be executed by checking all the predicates Checks if the command can be executed by checking all the predicates
@ -695,7 +682,7 @@ class Command:
ctx.command = self ctx.command = self
try: 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)) raise CheckFailure('The global check functions for command {0.qualified_name} failed.'.format(self))
cog = self.instance cog = self.instance
@ -705,7 +692,7 @@ class Command:
except AttributeError: except AttributeError:
pass pass
else: else:
ret = yield from discord.utils.maybe_coroutine(local_check, ctx) ret = await discord.utils.maybe_coroutine(local_check, ctx)
if not ret: if not ret:
return False return False
@ -714,7 +701,7 @@ class Command:
# since we have no checks, then we just return True. # since we have no checks, then we just return True.
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: finally:
ctx.command = original ctx.command = original
@ -903,11 +890,10 @@ class Group(GroupMixin, Command):
self.invoke_without_command = attrs.pop('invoke_without_command', False) self.invoke_without_command = attrs.pop('invoke_without_command', False)
super().__init__(**attrs) super().__init__(**attrs)
@asyncio.coroutine async def invoke(self, ctx):
def invoke(self, ctx):
early_invoke = not self.invoke_without_command early_invoke = not self.invoke_without_command
if early_invoke: if early_invoke:
yield from self.prepare(ctx) await self.prepare(ctx)
view = ctx.view view = ctx.view
previous = view.index previous = view.index
@ -920,26 +906,25 @@ class Group(GroupMixin, Command):
if early_invoke: if early_invoke:
injected = hooked_wrapped_callback(self, ctx, self.callback) 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: if trigger and ctx.invoked_subcommand:
ctx.invoked_with = trigger ctx.invoked_with = trigger
yield from ctx.invoked_subcommand.invoke(ctx) await ctx.invoked_subcommand.invoke(ctx)
elif not early_invoke: elif not early_invoke:
# undo the trigger parsing # undo the trigger parsing
view.index = previous view.index = previous
view.previous = previous view.previous = previous
yield from super().invoke(ctx) await super().invoke(ctx)
@asyncio.coroutine async def reinvoke(self, ctx, *, call_hooks=False):
def reinvoke(self, ctx, *, call_hooks=False):
early_invoke = not self.invoke_without_command early_invoke = not self.invoke_without_command
if early_invoke: if early_invoke:
ctx.command = self ctx.command = self
yield from self._parse_arguments(ctx) await self._parse_arguments(ctx)
if call_hooks: if call_hooks:
yield from self.call_before_hooks(ctx) await self.call_before_hooks(ctx)
view = ctx.view view = ctx.view
previous = view.index previous = view.index
@ -952,22 +937,22 @@ class Group(GroupMixin, Command):
if early_invoke: if early_invoke:
try: try:
yield from self.callback(*ctx.args, **ctx.kwargs) await self.callback(*ctx.args, **ctx.kwargs)
except: except:
ctx.command_failed = True ctx.command_failed = True
raise raise
finally: finally:
if call_hooks: if call_hooks:
yield from self.call_after_hooks(ctx) await self.call_after_hooks(ctx)
if trigger and ctx.invoked_subcommand: if trigger and ctx.invoked_subcommand:
ctx.invoked_with = trigger 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: elif not early_invoke:
# undo the trigger parsing # undo the trigger parsing
view.index = previous view.index = previous
view.previous = previous view.previous = previous
yield from super().reinvoke(ctx, call_hooks=call_hooks) await super().reinvoke(ctx, call_hooks=call_hooks)
# Decorators # Decorators
@ -1279,9 +1264,8 @@ def is_owner():
from :exc:`.CheckFailure`. from :exc:`.CheckFailure`.
""" """
@asyncio.coroutine async def predicate(ctx):
def predicate(ctx): if not (await ctx.bot.is_owner(ctx.author)):
if not (yield from ctx.bot.is_owner(ctx.author)):
raise NotOwner('You do not own this bot.') raise NotOwner('You do not own this bot.')
return True return True

20
discord/ext/commands/formatter.py
View File

@ -199,8 +199,7 @@ class HelpFormatter:
return "Type {0}{1} command for more info on a command.\n" \ 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) "You can also type {0}{1} category for more info on a category.".format(self.clean_prefix, command_name)
@asyncio.coroutine async def filter_command_list(self):
def filter_command_list(self):
"""Returns a filtered list of commands based on the two attributes """Returns a filtered list of commands based on the two attributes
provided, :attr:`show_check_failure` and :attr:`show_hidden`. provided, :attr:`show_check_failure` and :attr:`show_hidden`.
Also filters based on if :meth:`~.HelpFormatter.is_cog` is valid. Also filters based on if :meth:`~.HelpFormatter.is_cog` is valid.
@ -224,14 +223,13 @@ class HelpFormatter:
return True return True
@asyncio.coroutine async def predicate(tup):
def predicate(tup):
if sane_no_suspension_point_predicate(tup) is False: if sane_no_suspension_point_predicate(tup) is False:
return False return False
cmd = tup[1] cmd = tup[1]
try: try:
return (yield from cmd.can_run(self.context)) return (await cmd.can_run(self.context))
except CommandError: except CommandError:
return False return False
@ -242,7 +240,7 @@ class HelpFormatter:
# Gotta run every check and verify it # Gotta run every check and verify it
ret = [] ret = []
for elem in iterator: for elem in iterator:
valid = yield from predicate(elem) valid = await predicate(elem)
if valid: if valid:
ret.append(elem) ret.append(elem)
@ -258,8 +256,7 @@ class HelpFormatter:
shortened = self.shorten(entry) shortened = self.shorten(entry)
self._paginator.add_line(shortened) self._paginator.add_line(shortened)
@asyncio.coroutine async def format_help_for(self, context, command_or_bot):
def format_help_for(self, context, command_or_bot):
"""Formats the help page and handles the actual heavy lifting of how """Formats the help page and handles the actual heavy lifting of how
the help command looks like. To change the behaviour, override the the help command looks like. To change the behaviour, override the
:meth:`~.HelpFormatter.format` method. :meth:`~.HelpFormatter.format` method.
@ -278,10 +275,9 @@ class HelpFormatter:
""" """
self.context = context self.context = context
self.command = command_or_bot self.command = command_or_bot
return (yield from self.format()) return (await self.format())
@asyncio.coroutine async def format(self):
def format(self):
"""Handles the actual behaviour involved with formatting. """Handles the actual behaviour involved with formatting.
To change the behaviour, this method should be overridden. To change the behaviour, this method should be overridden.
@ -323,7 +319,7 @@ class HelpFormatter:
# last place sorting position. # last place sorting position.
return cog + ':' if cog is not None else '\u200bNo Category:' 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(): if self.is_bot():
data = sorted(filtered, key=category) data = sorted(filtered, key=category)
for category, commands in itertools.groupby(data, key=category): for category, commands in itertools.groupby(data, key=category):

152
discord/gateway.py
View File

@ -71,7 +71,7 @@ class KeepAliveHandler(threading.Thread):
if self._last_ack + self.heartbeat_timeout < time.monotonic(): if self._last_ack + self.heartbeat_timeout < time.monotonic():
log.warn("Shard ID %s has stopped responding to the gateway. Closing and restarting." % self.shard_id) log.warn("Shard ID %s has stopped responding to the gateway. Closing and restarting." % self.shard_id)
coro = self.ws.close(4000) coro = self.ws.close(4000)
f = compat.run_coroutine_threadsafe(coro, loop=self.ws.loop) f = asyncio.run_coroutine_threadsafe(coro, loop=self.ws.loop)
try: try:
f.result() f.result()
@ -84,7 +84,7 @@ class KeepAliveHandler(threading.Thread):
data = self.get_payload() data = self.get_payload()
log.debug(self.msg, data['d']) log.debug(self.msg, data['d'])
coro = self.ws.send_as_json(data) coro = self.ws.send_as_json(data)
f = compat.run_coroutine_threadsafe(coro, loop=self.ws.loop) f = asyncio.run_coroutine_threadsafe(coro, loop=self.ws.loop)
try: try:
# block until sending is complete # block until sending is complete
f.result() f.result()
@ -190,14 +190,13 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
self._buffer = bytearray() self._buffer = bytearray()
@classmethod @classmethod
@asyncio.coroutine async def from_client(cls, client, *, shard_id=None, session=None, sequence=None, resume=False):
def from_client(cls, client, *, shard_id=None, session=None, sequence=None, resume=False):
"""Creates a main websocket for Discord from a :class:`Client`. """Creates a main websocket for Discord from a :class:`Client`.
This is for internal use only. This is for internal use only.
""" """
gateway = yield from client.http.get_gateway() gateway = await client.http.get_gateway()
ws = yield from websockets.connect(gateway, loop=client.loop, klass=cls) ws = await websockets.connect(gateway, loop=client.loop, klass=cls)
# dynamically add attributes needed # dynamically add attributes needed
ws.token = client.http.token ws.token = client.http.token
@ -215,19 +214,19 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
log.info('Created websocket connected to %s', gateway) log.info('Created websocket connected to %s', gateway)
# poll event for OP Hello # poll event for OP Hello
yield from ws.poll_event() await ws.poll_event()
if not resume: if not resume:
yield from ws.identify() await ws.identify()
return ws return ws
yield from ws.resume() await ws.resume()
try: try:
yield from ws.ensure_open() await ws.ensure_open()
except websockets.exceptions.ConnectionClosed: except websockets.exceptions.ConnectionClosed:
# ws got closed so let's just do a regular IDENTIFY connect. # ws got closed so let's just do a regular IDENTIFY connect.
log.info('RESUME failed (the websocket decided to close) for Shard ID %s. Retrying.', shard_id) log.info('RESUME failed (the websocket decided to close) for Shard ID %s. Retrying.', shard_id)
return (yield from cls.from_client(client, shard_id=shard_id)) return (await cls.from_client(client, shard_id=shard_id))
else: else:
return ws return ws
@ -251,13 +250,12 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
A future to wait for. A future to wait for.
""" """
future = compat.create_future(self.loop) future = self.loop.create_future()
entry = EventListener(event=event, predicate=predicate, result=result, future=future) entry = EventListener(event=event, predicate=predicate, result=result, future=future)
self._dispatch_listeners.append(entry) self._dispatch_listeners.append(entry)
return future return future
@asyncio.coroutine async def identify(self):
def identify(self):
"""Sends the IDENTIFY packet.""" """Sends the IDENTIFY packet."""
payload = { payload = {
'op': self.IDENTIFY, 'op': self.IDENTIFY,
@ -291,11 +289,10 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
'afk': False 'afk': False
} }
yield from self.send_as_json(payload) await self.send_as_json(payload)
log.info('Shard ID %s has sent the IDENTIFY payload.', self.shard_id) log.info('Shard ID %s has sent the IDENTIFY payload.', self.shard_id)
@asyncio.coroutine async def resume(self):
def resume(self):
"""Sends the RESUME packet.""" """Sends the RESUME packet."""
payload = { payload = {
'op': self.RESUME, 'op': self.RESUME,
@ -306,11 +303,10 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
} }
} }
yield from self.send_as_json(payload) await self.send_as_json(payload)
log.info('Shard ID %s has sent the RESUME payload.', self.shard_id) log.info('Shard ID %s has sent the RESUME payload.', self.shard_id)
@asyncio.coroutine async def received_message(self, msg):
def received_message(self, msg):
self._dispatch('socket_raw_receive', msg) self._dispatch('socket_raw_receive', msg)
if isinstance(msg, bytes): if isinstance(msg, bytes):
@ -342,7 +338,7 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
# so we terminate our connection and raise an # so we terminate our connection and raise an
# internal exception signalling to reconnect. # internal exception signalling to reconnect.
log.info('Received RECONNECT opcode.') log.info('Received RECONNECT opcode.')
yield from self.close() await self.close()
raise ResumeWebSocket(self.shard_id) raise ResumeWebSocket(self.shard_id)
if op == self.HEARTBEAT_ACK: if op == self.HEARTBEAT_ACK:
@ -351,27 +347,27 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
if op == self.HEARTBEAT: if op == self.HEARTBEAT:
beat = self._keep_alive.get_payload() beat = self._keep_alive.get_payload()
yield from self.send_as_json(beat) await self.send_as_json(beat)
return return
if op == self.HELLO: if op == self.HELLO:
interval = data['heartbeat_interval'] / 1000.0 interval = data['heartbeat_interval'] / 1000.0
self._keep_alive = KeepAliveHandler(ws=self, interval=interval, shard_id=self.shard_id) self._keep_alive = KeepAliveHandler(ws=self, interval=interval, shard_id=self.shard_id)
# send a heartbeat immediately # send a heartbeat immediately
yield from self.send_as_json(self._keep_alive.get_payload()) await self.send_as_json(self._keep_alive.get_payload())
self._keep_alive.start() self._keep_alive.start()
return return
if op == self.INVALIDATE_SESSION: if op == self.INVALIDATE_SESSION:
if data == True: if data == True:
yield from asyncio.sleep(5.0, loop=self.loop) await asyncio.sleep(5.0, loop=self.loop)
yield from self.close() await self.close()
raise ResumeWebSocket(self.shard_id) raise ResumeWebSocket(self.shard_id)
self.sequence = None self.sequence = None
self.session_id = None self.session_id = None
log.info('Shard ID %s session has been invalidated.' % self.shard_id) log.info('Shard ID %s session has been invalidated.' % self.shard_id)
yield from self.identify() await self.identify()
return return
if op != self.DISPATCH: if op != self.DISPATCH:
@ -435,8 +431,7 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
def _can_handle_close(self, code): def _can_handle_close(self, code):
return code not in (1000, 4004, 4010, 4011) return code not in (1000, 4004, 4010, 4011)
@asyncio.coroutine async def poll_event(self):
def poll_event(self):
"""Polls for a DISPATCH event and handles the general gateway loop. """Polls for a DISPATCH event and handles the general gateway loop.
Raises Raises
@ -445,8 +440,8 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
The websocket connection was terminated for unhandled reasons. The websocket connection was terminated for unhandled reasons.
""" """
try: try:
msg = yield from self.recv() msg = await self.recv()
yield from self.received_message(msg) await self.received_message(msg)
except websockets.exceptions.ConnectionClosed as e: except websockets.exceptions.ConnectionClosed as e:
if self._can_handle_close(e.code): if self._can_handle_close(e.code):
log.info('Websocket closed with %s (%s), attempting a reconnect.', e.code, e.reason) log.info('Websocket closed with %s (%s), attempting a reconnect.', e.code, e.reason)
@ -455,21 +450,18 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
log.info('Websocket closed with %s (%s), cannot reconnect.', e.code, e.reason) log.info('Websocket closed with %s (%s), cannot reconnect.', e.code, e.reason)
raise ConnectionClosed(e, shard_id=self.shard_id) from e raise ConnectionClosed(e, shard_id=self.shard_id) from e
@asyncio.coroutine async def send(self, data):
def send(self, data):
self._dispatch('socket_raw_send', data) self._dispatch('socket_raw_send', data)
yield from super().send(data) await super().send(data)
@asyncio.coroutine async def send_as_json(self, data):
def send_as_json(self, data):
try: try:
yield from super().send(utils.to_json(data)) await super().send(utils.to_json(data))
except websockets.exceptions.ConnectionClosed as e: except websockets.exceptions.ConnectionClosed as e:
if not self._can_handle_close(e.code): if not self._can_handle_close(e.code):
raise ConnectionClosed(e, shard_id=self.shard_id) from e raise ConnectionClosed(e, shard_id=self.shard_id) from e
@asyncio.coroutine async def change_presence(self, *, activity=None, status=None, afk=False, since=0.0):
def change_presence(self, *, activity=None, status=None, afk=False, since=0.0):
if activity is not None: if activity is not None:
if not isinstance(activity, _ActivityTag): if not isinstance(activity, _ActivityTag):
raise InvalidArgument('activity must be one of Game, Streaming, or Activity.') raise InvalidArgument('activity must be one of Game, Streaming, or Activity.')
@ -490,18 +482,16 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
sent = utils.to_json(payload) sent = utils.to_json(payload)
log.debug('Sending "%s" to change status', sent) log.debug('Sending "%s" to change status', sent)
yield from self.send(sent) await self.send(sent)
@asyncio.coroutine async def request_sync(self, guild_ids):
def request_sync(self, guild_ids):
payload = { payload = {
'op': self.GUILD_SYNC, 'op': self.GUILD_SYNC,
'd': list(guild_ids) 'd': list(guild_ids)
} }
yield from self.send_as_json(payload) await self.send_as_json(payload)
@asyncio.coroutine async def voice_state(self, guild_id, channel_id, self_mute=False, self_deaf=False):
def voice_state(self, guild_id, channel_id, self_mute=False, self_deaf=False):
payload = { payload = {
'op': self.VOICE_STATE, 'op': self.VOICE_STATE,
'd': { 'd': {
@ -513,14 +503,13 @@ class DiscordWebSocket(websockets.client.WebSocketClientProtocol):
} }
log.debug('Updating our voice state to %s.', payload) log.debug('Updating our voice state to %s.', payload)
yield from self.send_as_json(payload) await self.send_as_json(payload)
@asyncio.coroutine async def close_connection(self, *args, **kwargs):
def close_connection(self, *args, **kwargs):
if self._keep_alive: if self._keep_alive:
self._keep_alive.stop() self._keep_alive.stop()
yield from super().close_connection(*args, **kwargs) await super().close_connection(*args, **kwargs)
class DiscordVoiceWebSocket(websockets.client.WebSocketClientProtocol): class DiscordVoiceWebSocket(websockets.client.WebSocketClientProtocol):
"""Implements the websocket protocol for handling voice connections. """Implements the websocket protocol for handling voice connections.
@ -565,13 +554,11 @@ class DiscordVoiceWebSocket(websockets.client.WebSocketClientProtocol):
self.max_size = None self.max_size = None
self._keep_alive = None self._keep_alive = None
@asyncio.coroutine async def send_as_json(self, data):
def send_as_json(self, data):
log.debug('Sending voice websocket frame: %s.', data) log.debug('Sending voice websocket frame: %s.', data)
yield from self.send(utils.to_json(data)) await self.send(utils.to_json(data))
@asyncio.coroutine async def resume(self):
def resume(self):
state = self._connection state = self._connection
payload = { payload = {
'op': self.RESUME, 'op': self.RESUME,
@ -581,10 +568,9 @@ class DiscordVoiceWebSocket(websockets.client.WebSocketClientProtocol):
'session_id': state.session_id 'session_id': state.session_id
} }
} }
yield from self.send_as_json(payload) await self.send_as_json(payload)
@asyncio.coroutine async def identify(self):
def identify(self):
state = self._connection state = self._connection
payload = { payload = {
'op': self.IDENTIFY, 'op': self.IDENTIFY,
@ -595,27 +581,25 @@ class DiscordVoiceWebSocket(websockets.client.WebSocketClientProtocol):
'token': state.token 'token': state.token
} }
} }
yield from self.send_as_json(payload) await self.send_as_json(payload)
@classmethod @classmethod
@asyncio.coroutine async def from_client(cls, client, *, resume=False):
def from_client(cls, client, *, resume=False):
"""Creates a voice websocket for the :class:`VoiceClient`.""" """Creates a voice websocket for the :class:`VoiceClient`."""
gateway = 'wss://' + client.endpoint + '/?v=3' gateway = 'wss://' + client.endpoint + '/?v=3'
ws = yield from websockets.connect(gateway, loop=client.loop, klass=cls) ws = await websockets.connect(gateway, loop=client.loop, klass=cls)
ws.gateway = gateway ws.gateway = gateway
ws._connection = client ws._connection = client
ws._max_heartbeat_timeout = 60.0 ws._max_heartbeat_timeout = 60.0
if resume: if resume:
yield from ws.resume() await ws.resume()
else: else:
yield from ws.identify() await ws.identify()
return ws return ws
@asyncio.coroutine async def select_protocol(self, ip, port):
def select_protocol(self, ip, port):
payload = { payload = {
'op': self.SELECT_PROTOCOL, 'op': self.SELECT_PROTOCOL,
'd': { 'd': {
@ -628,10 +612,9 @@ class DiscordVoiceWebSocket(websockets.client.WebSocketClientProtocol):
} }
} }
yield from self.send_as_json(payload) await self.send_as_json(payload)
@asyncio.coroutine async def speak(self, is_speaking=True):
def speak(self, is_speaking=True):
payload = { payload = {
'op': self.SPEAKING, 'op': self.SPEAKING,
'd': { 'd': {
@ -640,10 +623,9 @@ class DiscordVoiceWebSocket(websockets.client.WebSocketClientProtocol):
} }
} }
yield from self.send_as_json(payload) await self.send_as_json(payload)
@asyncio.coroutine async def received_message(self, msg):
def received_message(self, msg):
log.debug('Voice websocket frame received: %s', msg) log.debug('Voice websocket frame received: %s', msg)
op = msg['op'] op = msg['op']
data = msg.get('d') data = msg.get('d')
@ -652,17 +634,16 @@ class DiscordVoiceWebSocket(websockets.client.WebSocketClientProtocol):
interval = data['heartbeat_interval'] / 1000.0 interval = data['heartbeat_interval'] / 1000.0
self._keep_alive = VoiceKeepAliveHandler(ws=self, interval=interval) self._keep_alive = VoiceKeepAliveHandler(ws=self, interval=interval)
self._keep_alive.start() self._keep_alive.start()
yield from self.initial_connection(data) await self.initial_connection(data)
elif op == self.HEARTBEAT_ACK: elif op == self.HEARTBEAT_ACK:
self._keep_alive.ack() self._keep_alive.ack()
elif op == self.INVALIDATE_SESSION: elif op == self.INVALIDATE_SESSION:
log.info('Voice RESUME failed.') log.info('Voice RESUME failed.')
yield from self.identify() await self.identify()
elif op == self.SESSION_DESCRIPTION: elif op == self.SESSION_DESCRIPTION:
yield from self.load_secret_key(data) await self.load_secret_key(data)
@asyncio.coroutine async def initial_connection(self, data):
def initial_connection(self, data):
state = self._connection state = self._connection
state.ssrc = data['ssrc'] state.ssrc = data['ssrc']
state.voice_port = data['port'] state.voice_port = data['port']
@ -670,7 +651,7 @@ class DiscordVoiceWebSocket(websockets.client.WebSocketClientProtocol):
packet = bytearray(70) packet = bytearray(70)
struct.pack_into('>I', packet, 0, state.ssrc) struct.pack_into('>I', packet, 0, state.ssrc)
state.socket.sendto(packet, (state.endpoint_ip, state.voice_port)) state.socket.sendto(packet, (state.endpoint_ip, state.voice_port))
recv = yield from self.loop.sock_recv(state.socket, 70) recv = await self.loop.sock_recv(state.socket, 70)
log.debug('received packet in initial_connection: %s', recv) log.debug('received packet in initial_connection: %s', recv)
# the ip is ascii starting at the 4th byte and ending at the first null # the ip is ascii starting at the 4th byte and ending at the first null
@ -683,28 +664,25 @@ class DiscordVoiceWebSocket(websockets.client.WebSocketClientProtocol):
state.port = struct.unpack_from('<H', recv, len(recv) - 2)[0] state.port = struct.unpack_from('<H', recv, len(recv) - 2)[0]
log.debug('detected ip: %s port: %s', state.ip, state.port) log.debug('detected ip: %s port: %s', state.ip, state.port)
yield from self.select_protocol(state.ip, state.port) await self.select_protocol(state.ip, state.port)
log.info('selected the voice protocol for use') log.info('selected the voice protocol for use')
@asyncio.coroutine async def load_secret_key(self, data):
def load_secret_key(self, data):
log.info('received secret key for voice connection') log.info('received secret key for voice connection')
self._connection.secret_key = data.get('secret_key') self._connection.secret_key = data.get('secret_key')
yield from self.speak() await self.speak()
@asyncio.coroutine async def poll_event(self):
def poll_event(self):
try: try:
msg = yield from asyncio.wait_for(self.recv(), timeout=30.0, loop=self.loop) msg = await asyncio.wait_for(self.recv(), timeout=30.0, loop=self.loop)
yield from self.received_message(json.loads(msg)) await self.received_message(json.loads(msg))
except websockets.exceptions.ConnectionClosed as e: except websockets.exceptions.ConnectionClosed as e:
raise ConnectionClosed(e, shard_id=None) from e raise ConnectionClosed(e, shard_id=None) from e
@asyncio.coroutine async def close_connection(self, *args, **kwargs):
def close_connection(self, *args, **kwargs):
if self._keep_alive: if self._keep_alive:
self._keep_alive.stop() self._keep_alive.stop()
yield from super().close_connection(*args, **kwargs) await super().close_connection(*args, **kwargs)

89
discord/guild.py
View File

@ -543,8 +543,7 @@ class Guild(Hashable):
return self._state.http.create_channel(self.id, name, channel_type.value, parent_id=parent_id, return self._state.http.create_channel(self.id, name, channel_type.value, parent_id=parent_id,
permission_overwrites=perms, reason=reason) permission_overwrites=perms, reason=reason)
@asyncio.coroutine async def create_text_channel(self, name, *, overwrites=None, category=None, reason=None):
def create_text_channel(self, name, *, overwrites=None, category=None, reason=None):
"""|coro| """|coro|
Creates a :class:`TextChannel` for the guild. Creates a :class:`TextChannel` for the guild.
@ -606,28 +605,26 @@ class Guild(Hashable):
:class:`TextChannel` :class:`TextChannel`
The channel that was just created. The channel that was just created.
""" """
data = yield from self._create_channel(name, overwrites, ChannelType.text, category, reason=reason) data = await self._create_channel(name, overwrites, ChannelType.text, category, reason=reason)
channel = TextChannel(state=self._state, guild=self, data=data) channel = TextChannel(state=self._state, guild=self, data=data)
# temporarily add to the cache # temporarily add to the cache
self._channels[channel.id] = channel self._channels[channel.id] = channel
return channel return channel
@asyncio.coroutine async def create_voice_channel(self, name, *, overwrites=None, category=None, reason=None):
def create_voice_channel(self, name, *, overwrites=None, category=None, reason=None):
"""|coro| """|coro|
Same as :meth:`create_text_channel` except makes a :class:`VoiceChannel` instead. Same as :meth:`create_text_channel` except makes a :class:`VoiceChannel` instead.
""" """
data = yield from self._create_channel(name, overwrites, ChannelType.voice, category, reason=reason) data = await self._create_channel(name, overwrites, ChannelType.voice, category, reason=reason)
channel = VoiceChannel(state=self._state, guild=self, data=data) channel = VoiceChannel(state=self._state, guild=self, data=data)
# temporarily add to the cache # temporarily add to the cache
self._channels[channel.id] = channel self._channels[channel.id] = channel
return channel return channel
@asyncio.coroutine async def create_category(self, name, *, overwrites=None, reason=None):
def create_category(self, name, *, overwrites=None, reason=None):
"""|coro| """|coro|
Same as :meth:`create_text_channel` except makes a :class:`CategoryChannel` instead. Same as :meth:`create_text_channel` except makes a :class:`CategoryChannel` instead.
@ -637,7 +634,7 @@ class Guild(Hashable):
The ``category`` parameter is not supported in this function since categories The ``category`` parameter is not supported in this function since categories
cannot have categories. cannot have categories.
""" """
data = yield from self._create_channel(name, overwrites, ChannelType.category, reason=reason) data = await self._create_channel(name, overwrites, ChannelType.category, reason=reason)
channel = CategoryChannel(state=self._state, guild=self, data=data) channel = CategoryChannel(state=self._state, guild=self, data=data)
# temporarily add to the cache # temporarily add to the cache
@ -646,8 +643,7 @@ class Guild(Hashable):
create_category_channel = create_category create_category_channel = create_category
@asyncio.coroutine async def leave(self):
def leave(self):
"""|coro| """|coro|
Leaves the guild. Leaves the guild.
@ -662,10 +658,9 @@ class Guild(Hashable):
HTTPException HTTPException
Leaving the guild failed. Leaving the guild failed.
""" """
yield from self._state.http.leave_guild(self.id) await self._state.http.leave_guild(self.id)
@asyncio.coroutine async def delete(self):
def delete(self):
"""|coro| """|coro|
Deletes the guild. You must be the guild owner to delete the Deletes the guild. You must be the guild owner to delete the
@ -679,10 +674,9 @@ class Guild(Hashable):
You do not have permissions to delete the guild. You do not have permissions to delete the guild.
""" """
yield from self._state.http.delete_guild(self.id) await self._state.http.delete_guild(self.id)
@asyncio.coroutine async def edit(self, *, reason=None, **fields):
def edit(self, *, reason=None, **fields):
"""|coro| """|coro|
Edits the guild. Edits the guild.
@ -748,7 +742,7 @@ class Guild(Hashable):
except KeyError: except KeyError:
pass pass
else: else:
yield from http.change_vanity_code(self.id, vanity_code, reason=reason) await http.change_vanity_code(self.id, vanity_code, reason=reason)
try: try:
splash_bytes = fields['splash'] splash_bytes = fields['splash']
@ -798,7 +792,7 @@ class Guild(Hashable):
fields['verification_level'] = level.value fields['verification_level'] = level.value
yield from http.edit_guild(self.id, reason=reason, **fields) await http.edit_guild(self.id, reason=reason, **fields)
@asyncio.coroutine @asyncio.coroutine
def get_ban(self, user): def get_ban(self, user):
@ -836,8 +830,7 @@ class Guild(Hashable):
reason=data['reason'] reason=data['reason']
) )
@asyncio.coroutine async def bans(self):
def bans(self):
"""|coro| """|coro|
Retrieves all the users that are banned from the guild. Retrieves all the users that are banned from the guild.
@ -863,13 +856,12 @@ class Guild(Hashable):
A list of BanEntry objects. A list of BanEntry objects.
""" """
data = yield from self._state.http.get_bans(self.id) data = await self._state.http.get_bans(self.id)
return [BanEntry(user=User(state=self._state, data=e['user']), return [BanEntry(user=User(state=self._state, data=e['user']),
reason=e['reason']) reason=e['reason'])
for e in data] for e in data]
@asyncio.coroutine async def prune_members(self, *, days, reason=None):
def prune_members(self, *, days, reason=None):
"""|coro| """|coro|
Prunes the guild from its inactive members. Prunes the guild from its inactive members.
@ -908,11 +900,10 @@ class Guild(Hashable):
if not isinstance(days, int): if not isinstance(days, int):
raise InvalidArgument('Expected int for ``days``, received {0.__class__.__name__} instead.'.format(days)) raise InvalidArgument('Expected int for ``days``, received {0.__class__.__name__} instead.'.format(days))
data = yield from self._state.http.prune_members(self.id, days, reason=reason) data = await self._state.http.prune_members(self.id, days, reason=reason)
return data['pruned'] return data['pruned']
@asyncio.coroutine async def webhooks(self):
def webhooks(self):
"""|coro| """|coro|
Gets the list of webhooks from this guild. Gets the list of webhooks from this guild.
@ -930,11 +921,10 @@ class Guild(Hashable):
The webhooks for this guild. The webhooks for this guild.
""" """
data = yield from self._state.http.guild_webhooks(self.id) data = await self._state.http.guild_webhooks(self.id)
return [Webhook.from_state(d, state=self._state) for d in data] return [Webhook.from_state(d, state=self._state) for d in data]
@asyncio.coroutine async def estimate_pruned_members(self, *, days):
def estimate_pruned_members(self, *, days):
"""|coro| """|coro|
Similar to :meth:`prune_members` except instead of actually Similar to :meth:`prune_members` except instead of actually
@ -964,11 +954,10 @@ class Guild(Hashable):
if not isinstance(days, int): if not isinstance(days, int):
raise InvalidArgument('Expected int for ``days``, received {0.__class__.__name__} instead.'.format(days)) raise InvalidArgument('Expected int for ``days``, received {0.__class__.__name__} instead.'.format(days))
data = yield from self._state.http.estimate_pruned_members(self.id, days) data = await self._state.http.estimate_pruned_members(self.id, days)
return data['pruned'] return data['pruned']
@asyncio.coroutine async def invites(self):
def invites(self):
"""|coro| """|coro|
Returns a list of all active instant invites from the guild. Returns a list of all active instant invites from the guild.
@ -989,7 +978,7 @@ class Guild(Hashable):
The list of invites that are currently active. The list of invites that are currently active.
""" """
data = yield from self._state.http.invites_from(self.id) data = await self._state.http.invites_from(self.id)
result = [] result = []
for invite in data: for invite in data:
channel = self.get_channel(int(invite['channel']['id'])) channel = self.get_channel(int(invite['channel']['id']))
@ -999,8 +988,7 @@ class Guild(Hashable):
return result return result
@asyncio.coroutine async def create_custom_emoji(self, *, name, image, reason=None):
def create_custom_emoji(self, *, name, image, reason=None):
"""|coro| """|coro|
Creates a custom :class:`Emoji` for the guild. Creates a custom :class:`Emoji` for the guild.
@ -1036,11 +1024,10 @@ class Guild(Hashable):
""" """
img = utils._bytes_to_base64_data(image) img = utils._bytes_to_base64_data(image)
data = yield from self._state.http.create_custom_emoji(self.id, name, img, reason=reason) data = await self._state.http.create_custom_emoji(self.id, name, img, reason=reason)
return self._state.store_emoji(self, data) return self._state.store_emoji(self, data)
@asyncio.coroutine async def create_role(self, *, reason=None, **fields):
def create_role(self, *, reason=None, **fields):
"""|coro| """|coro|
Creates a :class:`Role` for the guild. Creates a :class:`Role` for the guild.
@ -1102,14 +1089,13 @@ class Guild(Hashable):
if key not in valid_keys: if key not in valid_keys:
raise InvalidArgument('%r is not a valid field.' % key) raise InvalidArgument('%r is not a valid field.' % key)
data = yield from self._state.http.create_role(self.id, reason=reason, **fields) data = await self._state.http.create_role(self.id, reason=reason, **fields)
role = Role(guild=self, data=data, state=self._state) role = Role(guild=self, data=data, state=self._state)
# TODO: add to cache # TODO: add to cache
return role return role
@asyncio.coroutine async def kick(self, user, *, reason=None):
def kick(self, user, *, reason=None):
"""|coro| """|coro|
Kicks a user from the guild. Kicks a user from the guild.
@ -1133,10 +1119,9 @@ class Guild(Hashable):
HTTPException HTTPException
Kicking failed. Kicking failed.
""" """
yield from self._state.http.kick(user.id, self.id, reason=reason) await self._state.http.kick(user.id, self.id, reason=reason)
@asyncio.coroutine async def ban(self, user, *, reason=None, delete_message_days=1):
def ban(self, user, *, reason=None, delete_message_days=1):
"""|coro| """|coro|
Bans a user from the guild. Bans a user from the guild.
@ -1163,10 +1148,9 @@ class Guild(Hashable):
HTTPException HTTPException
Banning failed. Banning failed.
""" """
yield from self._state.http.ban(user.id, self.id, delete_message_days, reason=reason) await self._state.http.ban(user.id, self.id, delete_message_days, reason=reason)
@asyncio.coroutine async def unban(self, user, *, reason=None):
def unban(self, user, *, reason=None):
"""|coro| """|coro|
Unbans a user from the guild. Unbans a user from the guild.
@ -1190,10 +1174,9 @@ class Guild(Hashable):
HTTPException HTTPException
Unbanning failed. Unbanning failed.
""" """
yield from self._state.http.unban(user.id, self.id, reason=reason) await self._state.http.unban(user.id, self.id, reason=reason)
@asyncio.coroutine async def vanity_invite(self):
def vanity_invite(self):
"""|coro| """|coro|
Returns the guild's special vanity invite. Returns the guild's special vanity invite.
@ -1218,11 +1201,11 @@ class Guild(Hashable):
""" """
# we start with { code: abc } # we start with { code: abc }
payload = yield from self._state.http.get_vanity_code(self.id) payload = await self._state.http.get_vanity_code(self.id)
# get the vanity URL channel since default channels aren't # get the vanity URL channel since default channels aren't
# reliable or a thing anymore # reliable or a thing anymore
data = yield from self._state.http.get_invite(payload['code']) data = await self._state.http.get_invite(payload['code'])
payload['guild'] = self payload['guild'] = self
payload['channel'] = self.get_channel(int(data['channel']['id'])) payload['channel'] = self.get_channel(int(data['channel']['id']))

61
discord/http.py
View File

@ -38,9 +38,8 @@ log = logging.getLogger(__name__)
from .errors import HTTPException, Forbidden, NotFound, LoginFailure, GatewayNotFound from .errors import HTTPException, Forbidden, NotFound, LoginFailure, GatewayNotFound
from . import __version__, utils from . import __version__, utils
@asyncio.coroutine async def json_or_text(response):
def json_or_text(response): text = await response.text(encoding='utf-8')
text = yield from response.text(encoding='utf-8')
if response.headers['content-type'] == 'application/json': if response.headers['content-type'] == 'application/json':
return json.loads(text) return json.loads(text)
return text return text
@ -106,8 +105,7 @@ class HTTPClient:
if self._session.closed: if self._session.closed:
self._session = aiohttp.ClientSession(connector=self.connector, loop=self.loop) self._session = aiohttp.ClientSession(connector=self.connector, loop=self.loop)
@asyncio.coroutine async def request(self, route, *, header_bypass_delay=None, **kwargs):
def request(self, route, *, header_bypass_delay=None, **kwargs):
bucket = route.bucket bucket = route.bucket
method = route.method method = route.method
url = route.url url = route.url
@ -148,16 +146,16 @@ class HTTPClient:
if not self._global_over.is_set(): if not self._global_over.is_set():
# wait until the global lock is complete # wait until the global lock is complete
yield from self._global_over.wait() await self._global_over.wait()
yield from lock await lock
with MaybeUnlock(lock) as maybe_lock: with MaybeUnlock(lock) as maybe_lock:
for tries in range(5): for tries in range(5):
r = yield from self._session.request(method, url, **kwargs) async with self._session.request(method, url, **kwargs) as r:
log.debug('%s %s with %s has returned %s', method, url, kwargs.get('data'), r.status) log.debug('%s %s with %s has returned %s', method, url, kwargs.get('data'), r.status)
try:
# even errors have text involved in them so this is safe to call # even errors have text involved in them so this is safe to call
data = yield from json_or_text(r) data = await json_or_text(r)
# check if we have rate limit header information # check if we have rate limit header information
remaining = r.headers.get('X-Ratelimit-Remaining') remaining = r.headers.get('X-Ratelimit-Remaining')
@ -191,7 +189,7 @@ class HTTPClient:
log.info('Global rate limit has been hit. Retrying in %.2f seconds.', retry_after) log.info('Global rate limit has been hit. Retrying in %.2f seconds.', retry_after)
self._global_over.clear() self._global_over.clear()
yield from asyncio.sleep(retry_after, loop=self.loop) await asyncio.sleep(retry_after, loop=self.loop)
log.debug('Done sleeping for the rate limit. Retrying...') log.debug('Done sleeping for the rate limit. Retrying...')
# release the global lock now that the # release the global lock now that the
@ -204,7 +202,7 @@ class HTTPClient:
# we've received a 500 or 502, unconditional retry # we've received a 500 or 502, unconditional retry
if r.status in {500, 502}: if r.status in {500, 502}:
yield from asyncio.sleep(1 + tries * 2, loop=self.loop) await asyncio.sleep(1 + tries * 2, loop=self.loop)
continue continue
# the usual error cases # the usual error cases
@ -214,32 +212,25 @@ class HTTPClient:
raise NotFound(r, data) raise NotFound(r, data)
else: else:
raise HTTPException(r, data) raise HTTPException(r, data)
finally:
# clean-up just in case
yield from r.release()
# We've run out of retries, raise. # We've run out of retries, raise.
raise HTTPException(r, data) raise HTTPException(r, data)
@asyncio.coroutine async def get_attachment(self, url):
def get_attachment(self, url): async with self._session.get(url) as resp:
resp = yield from self._session.get(url)
try:
if resp.status == 200: if resp.status == 200:
return (yield from resp.read()) return (await resp.read())
elif resp.status == 404: elif resp.status == 404:
raise NotFound(resp, 'attachment not found') raise NotFound(resp, 'attachment not found')
elif resp.status == 403: elif resp.status == 403:
raise Forbidden(resp, 'cannot retrieve attachment') raise Forbidden(resp, 'cannot retrieve attachment')
else: else:
raise HTTPException(resp, 'failed to get attachment') raise HTTPException(resp, 'failed to get attachment')
finally:
yield from resp.release()
# state management # state management
@asyncio.coroutine async def close(self):
def close(self): await self._session.close()
yield from self._session.close()
def _token(self, token, *, bot=True): def _token(self, token, *, bot=True):
self.token = token self.token = token
@ -248,13 +239,12 @@ class HTTPClient:
# login management # login management
@asyncio.coroutine async def static_login(self, token, *, bot):
def static_login(self, token, *, bot):
old_token, old_bot = self.token, self.bot_token old_token, old_bot = self.token, self.bot_token
self._token(token, bot=bot) self._token(token, bot=bot)
try: try:
data = yield from self.request(Route('GET', '/users/@me')) data = await self.request(Route('GET', '/users/@me'))
except HTTPException as e: except HTTPException as e:
self._token(old_token, bot=old_bot) self._token(old_token, bot=old_bot)
if e.response.status == 401: if e.response.status == 401:
@ -349,11 +339,10 @@ class HTTPClient:
return self.request(r, data=form) return self.request(r, data=form)
@asyncio.coroutine async def ack_message(self, channel_id, message_id):
def ack_message(self, channel_id, message_id):
r = Route('POST', '/channels/{channel_id}/messages/{message_id}/ack', channel_id=channel_id, r = Route('POST', '/channels/{channel_id}/messages/{message_id}/ack', channel_id=channel_id,
message_id=message_id) message_id=message_id)
data = yield from self.request(r, json={'token': self._ack_token}) data = await self.request(r, json={'token': self._ack_token})
self._ack_token = data['token'] self._ack_token = data['token']
def ack_guild(self, guild_id): def ack_guild(self, guild_id):
@ -751,10 +740,9 @@ class HTTPClient:
def application_info(self): def application_info(self):
return self.request(Route('GET', '/oauth2/applications/@me')) return self.request(Route('GET', '/oauth2/applications/@me'))
@asyncio.coroutine async def get_gateway(self, *, encoding='json', v=6, zlib=True):
def get_gateway(self, *, encoding='json', v=6, zlib=True):
try: try:
data = yield from self.request(Route('GET', '/gateway')) data = await self.request(Route('GET', '/gateway'))
except HTTPException as e: except HTTPException as e:
raise GatewayNotFound() from e raise GatewayNotFound() from e
if zlib: if zlib:
@ -763,10 +751,9 @@ class HTTPClient:
value = '{0}?encoding={1}&v={2}' value = '{0}?encoding={1}&v={2}'
return value.format(data['url'], encoding, v) return value.format(data['url'], encoding, v)
@asyncio.coroutine async def get_bot_gateway(self, *, encoding='json', v=6, zlib=True):
def get_bot_gateway(self, *, encoding='json', v=6, zlib=True):
try: try:
data = yield from self.request(Route('GET', '/gateway/bot')) data = await self.request(Route('GET', '/gateway/bot'))
except HTTPException as e: except HTTPException as e:
raise GatewayNotFound() from e raise GatewayNotFound() from e

5
discord/invite.py
View File

@ -134,8 +134,7 @@ class Invite(Hashable):
"""A property that retrieves the invite URL.""" """A property that retrieves the invite URL."""
return 'http://discord.gg/' + self.code return 'http://discord.gg/' + self.code
@asyncio.coroutine async def delete(self, *, reason=None):
def delete(self, *, reason=None):
"""|coro| """|coro|
Revokes the instant invite. Revokes the instant invite.
@ -157,4 +156,4 @@ class Invite(Hashable):
Revoking the invite failed. Revoking the invite failed.
""" """
yield from self._state.http.delete_invite(self.code, reason=reason) await self._state.http.delete_invite(self.code, reason=reason)

114
discord/iterators.py
View File

@ -33,8 +33,6 @@ from .utils import time_snowflake, maybe_coroutine
from .object import Object from .object import Object
from .audit_logs import AuditLogEntry from .audit_logs import AuditLogEntry
PY35 = sys.version_info >= (3, 5)
class _AsyncIterator: class _AsyncIterator:
__slots__ = () __slots__ = ()
@ -52,15 +50,14 @@ class _AsyncIterator:
return self.find(predicate) return self.find(predicate)
@asyncio.coroutine async def find(self, predicate):
def find(self, predicate):
while True: while True:
try: try:
elem = yield from self.next() elem = await self.next()
except NoMoreItems: except NoMoreItems:
return None return None
ret = yield from maybe_coroutine(predicate, elem) ret = await maybe_coroutine(predicate, elem)
if ret: if ret:
return elem return elem
@ -70,26 +67,22 @@ class _AsyncIterator:
def filter(self, predicate): def filter(self, predicate):
return _FilteredAsyncIterator(self, predicate) return _FilteredAsyncIterator(self, predicate)
@asyncio.coroutine async def flatten(self):
def flatten(self):
ret = [] ret = []
while True: while True:
try: try:
item = yield from self.next() item = await self.next()
except NoMoreItems: except NoMoreItems:
return ret return ret
else: else:
ret.append(item) ret.append(item)
if PY35: async def __aiter__(self):
@asyncio.coroutine
def __aiter__(self):
return self return self
@asyncio.coroutine async def __anext__(self):
def __anext__(self):
try: try:
msg = yield from self.next() msg = await self.next()
except NoMoreItems: except NoMoreItems:
raise StopAsyncIteration() raise StopAsyncIteration()
else: else:
@ -103,11 +96,10 @@ class _MappedAsyncIterator(_AsyncIterator):
self.iterator = iterator self.iterator = iterator
self.func = func self.func = func
@asyncio.coroutine async def next(self):
def next(self):
# this raises NoMoreItems and will propagate appropriately # this raises NoMoreItems and will propagate appropriately
item = yield from self.iterator.next() item = await self.iterator.next()
return (yield from maybe_coroutine(self.func, item)) return (await maybe_coroutine(self.func, item))
class _FilteredAsyncIterator(_AsyncIterator): class _FilteredAsyncIterator(_AsyncIterator):
def __init__(self, iterator, predicate): def __init__(self, iterator, predicate):
@ -118,14 +110,13 @@ class _FilteredAsyncIterator(_AsyncIterator):
self.predicate = predicate self.predicate = predicate
@asyncio.coroutine async def next(self):
def next(self):
getter = self.iterator.next getter = self.iterator.next
pred = self.predicate pred = self.predicate
while True: while True:
# propagate NoMoreItems similar to _MappedAsyncIterator # propagate NoMoreItems similar to _MappedAsyncIterator
item = yield from getter() item = await getter()
ret = yield from maybe_coroutine(pred, item) ret = await maybe_coroutine(pred, item)
if ret: if ret:
return item return item
@ -142,18 +133,16 @@ class ReactionIterator(_AsyncIterator):
self.channel_id = message.channel.id self.channel_id = message.channel.id
self.users = asyncio.Queue(loop=state.loop) self.users = asyncio.Queue(loop=state.loop)
@asyncio.coroutine async def next(self):
def next(self):
if self.users.empty(): if self.users.empty():
yield from self.fill_users() await self.fill_users()
try: try:
return self.users.get_nowait() return self.users.get_nowait()
except asyncio.QueueEmpty: except asyncio.QueueEmpty:
raise NoMoreItems() raise NoMoreItems()
@asyncio.coroutine async def fill_users(self):
def fill_users(self):
# this is a hack because >circular imports< # this is a hack because >circular imports<
from .user import User from .user import User
@ -161,7 +150,7 @@ class ReactionIterator(_AsyncIterator):
retrieve = self.limit if self.limit <= 100 else 100 retrieve = self.limit if self.limit <= 100 else 100
after = self.after.id if self.after else None after = self.after.id if self.after else None
data = yield from self.getter(self.message.id, self.channel_id, self.emoji, retrieve, after=after) data = await self.getter(self.message.id, self.channel_id, self.emoji, retrieve, after=after)
if data: if data:
self.limit -= retrieve self.limit -= retrieve
@ -169,15 +158,15 @@ class ReactionIterator(_AsyncIterator):
if self.guild is None: if self.guild is None:
for element in reversed(data): for element in reversed(data):
yield from self.users.put(User(state=self.state, data=element)) await self.users.put(User(state=self.state, data=element))
else: else:
for element in reversed(data): for element in reversed(data):
member_id = int(element['id']) member_id = int(element['id'])
member = self.guild.get_member(member_id) member = self.guild.get_member(member_id)
if member is not None: if member is not None:
yield from self.users.put(member) await self.users.put(member)
else: else:
yield from self.users.put(User(state=self.state, data=element)) await self.users.put(User(state=self.state, data=element))
class HistoryIterator(_AsyncIterator): class HistoryIterator(_AsyncIterator):
"""Iterator for receiving a channel's message history. """Iterator for receiving a channel's message history.
@ -270,10 +259,9 @@ class HistoryIterator(_AsyncIterator):
else: else:
self._retrieve_messages = self._retrieve_messages_before_strategy self._retrieve_messages = self._retrieve_messages_before_strategy
@asyncio.coroutine async def next(self):
def next(self):
if self.messages.empty(): if self.messages.empty():
yield from self.fill_messages() await self.fill_messages()
try: try:
return self.messages.get_nowait() return self.messages.get_nowait()
@ -292,15 +280,14 @@ class HistoryIterator(_AsyncIterator):
self.retrieve = r self.retrieve = r
return r > 0 return r > 0
@asyncio.coroutine async def flatten(self):
def flatten(self):
# this is similar to fill_messages except it uses a list instead # this is similar to fill_messages except it uses a list instead
# of a queue to place the messages in. # of a queue to place the messages in.
result = [] result = []
channel = yield from self.messageable._get_channel() channel = await self.messageable._get_channel()
self.channel = channel self.channel = channel
while self._get_retrieve(): while self._get_retrieve():
data = yield from self._retrieve_messages(self.retrieve) data = await self._retrieve_messages(self.retrieve)
if len(data) < 100: if len(data) < 100:
self.limit = 0 # terminate the infinite loop self.limit = 0 # terminate the infinite loop
@ -313,15 +300,14 @@ class HistoryIterator(_AsyncIterator):
result.append(self.state.create_message(channel=channel, data=element)) result.append(self.state.create_message(channel=channel, data=element))
return result return result
@asyncio.coroutine async def fill_messages(self):
def fill_messages(self):
if not hasattr(self, 'channel'): if not hasattr(self, 'channel'):
# do the required set up # do the required set up
channel = yield from self.messageable._get_channel() channel = await self.messageable._get_channel()
self.channel = channel self.channel = channel
if self._get_retrieve(): if self._get_retrieve():
data = yield from self._retrieve_messages(self.retrieve) data = await self._retrieve_messages(self.retrieve)
if self.limit is None and len(data) < 100: if self.limit is None and len(data) < 100:
self.limit = 0 # terminate the infinite loop self.limit = 0 # terminate the infinite loop
@ -332,41 +318,37 @@ class HistoryIterator(_AsyncIterator):
channel = self.channel channel = self.channel
for element in data: for element in data:
yield from self.messages.put(self.state.create_message(channel=channel, data=element)) await self.messages.put(self.state.create_message(channel=channel, data=element))
@asyncio.coroutine async def _retrieve_messages(self, retrieve):
def _retrieve_messages(self, retrieve):
"""Retrieve messages and update next parameters.""" """Retrieve messages and update next parameters."""
pass pass
@asyncio.coroutine async def _retrieve_messages_before_strategy(self, retrieve):
def _retrieve_messages_before_strategy(self, retrieve):
"""Retrieve messages using before parameter.""" """Retrieve messages using before parameter."""
before = self.before.id if self.before else None before = self.before.id if self.before else None
data = yield from self.logs_from(self.channel.id, retrieve, before=before) data = await self.logs_from(self.channel.id, retrieve, before=before)
if len(data): if len(data):
if self.limit is not None: if self.limit is not None:
self.limit -= retrieve self.limit -= retrieve
self.before = Object(id=int(data[-1]['id'])) self.before = Object(id=int(data[-1]['id']))
return data return data
@asyncio.coroutine async def _retrieve_messages_after_strategy(self, retrieve):
def _retrieve_messages_after_strategy(self, retrieve):
"""Retrieve messages using after parameter.""" """Retrieve messages using after parameter."""
after = self.after.id if self.after else None after = self.after.id if self.after else None
data = yield from self.logs_from(self.channel.id, retrieve, after=after) data = await self.logs_from(self.channel.id, retrieve, after=after)
if len(data): if len(data):
if self.limit is not None: if self.limit is not None:
self.limit -= retrieve self.limit -= retrieve
self.after = Object(id=int(data[0]['id'])) self.after = Object(id=int(data[0]['id']))
return data return data
@asyncio.coroutine async def _retrieve_messages_around_strategy(self, retrieve):
def _retrieve_messages_around_strategy(self, retrieve):
"""Retrieve messages using around parameter.""" """Retrieve messages using around parameter."""
if self.around: if self.around:
around = self.around.id if self.around else None around = self.around.id if self.around else None
data = yield from self.logs_from(self.channel.id, retrieve, around=around) data = await self.logs_from(self.channel.id, retrieve, around=around)
self.around = None self.around = None
return data return data
return [] return []
@ -411,10 +393,9 @@ class AuditLogIterator(_AsyncIterator):
else: else:
self._strategy = self._before_strategy self._strategy = self._before_strategy
@asyncio.coroutine async def _before_strategy(self, retrieve):
def _before_strategy(self, retrieve):
before = self.before.id if self.before else None before = self.before.id if self.before else None
data = yield from self.request(self.guild.id, limit=retrieve, user_id=self.user_id, data = await self.request(self.guild.id, limit=retrieve, user_id=self.user_id,
action_type=self.action_type, before=before) action_type=self.action_type, before=before)
entries = data.get('audit_log_entries', []) entries = data.get('audit_log_entries', [])
@ -424,10 +405,9 @@ class AuditLogIterator(_AsyncIterator):
self.before = Object(id=int(entries[-1]['id'])) self.before = Object(id=int(entries[-1]['id']))
return data.get('users', []), entries return data.get('users', []), entries
@asyncio.coroutine async def _after_strategy(self, retrieve):
def _after_strategy(self, retrieve):
after = self.after.id if self.after else None after = self.after.id if self.after else None
data = yield from self.request(self.guild.id, limit=retrieve, user_id=self.user_id, data = await self.request(self.guild.id, limit=retrieve, user_id=self.user_id,
action_type=self.action_type, after=after) action_type=self.action_type, after=after)
entries = data.get('audit_log_entries', []) entries = data.get('audit_log_entries', [])
if len(data) and entries: if len(data) and entries:
@ -436,10 +416,9 @@ class AuditLogIterator(_AsyncIterator):
self.after = Object(id=int(entries[0]['id'])) self.after = Object(id=int(entries[0]['id']))
return data.get('users', []), entries return data.get('users', []), entries
@asyncio.coroutine async def next(self):
def next(self):
if self.entries.empty(): if self.entries.empty():
yield from self._fill() await self._fill()
try: try:
return self.entries.get_nowait() return self.entries.get_nowait()
@ -458,12 +437,11 @@ class AuditLogIterator(_AsyncIterator):
self.retrieve = r self.retrieve = r
return r > 0 return r > 0
@asyncio.coroutine async def _fill(self):
def _fill(self):
from .user import User from .user import User
if self._get_retrieve(): if self._get_retrieve():
users, data = yield from self._strategy(self.retrieve) users, data = await self._strategy(self.retrieve)
if self.limit is None and len(data) < 100: if self.limit is None and len(data) < 100:
self.limit = 0 # terminate the infinite loop self.limit = 0 # terminate the infinite loop
@ -481,4 +459,4 @@ class AuditLogIterator(_AsyncIterator):
if element['action_type'] is None: if element['action_type'] is None:
continue continue
yield from self.entries.put(AuditLogEntry(data=element, users=self._users, guild=self.guild)) await self.entries.put(AuditLogEntry(data=element, users=self._users, guild=self.guild))

46
discord/member.py
View File

@ -183,9 +183,8 @@ class Member(discord.abc.Messageable, _BaseUser):
def __hash__(self): def __hash__(self):
return hash(self._user.id) return hash(self._user.id)
@asyncio.coroutine async def _get_channel(self):
def _get_channel(self): ch = await self.create_dm()
ch = yield from self.create_dm()
return ch return ch
def _update_roles(self, data): def _update_roles(self, data):
@ -341,32 +340,28 @@ class Member(discord.abc.Messageable, _BaseUser):
"""Optional[:class:`VoiceState`]: Returns the member's current voice state.""" """Optional[:class:`VoiceState`]: Returns the member's current voice state."""
return self.guild._voice_state_for(self._user.id) return self.guild._voice_state_for(self._user.id)
@asyncio.coroutine async def ban(self, **kwargs):
def ban(self, **kwargs):
"""|coro| """|coro|
Bans this member. Equivalent to :meth:`Guild.ban` Bans this member. Equivalent to :meth:`Guild.ban`
""" """
yield from self.guild.ban(self, **kwargs) await self.guild.ban(self, **kwargs)
@asyncio.coroutine async def unban(self, *, reason=None):
def unban(self, *, reason=None):
"""|coro| """|coro|
Unbans this member. Equivalent to :meth:`Guild.unban` Unbans this member. Equivalent to :meth:`Guild.unban`
""" """
yield from self.guild.unban(self, reason=reason) await self.guild.unban(self, reason=reason)
@asyncio.coroutine async def kick(self, *, reason=None):
def kick(self, *, reason=None):
"""|coro| """|coro|
Kicks this member. Equivalent to :meth:`Guild.kick` Kicks this member. Equivalent to :meth:`Guild.kick`
""" """
yield from self.guild.kick(self, reason=reason) await self.guild.kick(self, reason=reason)
@asyncio.coroutine async def edit(self, *, reason=None, **fields):
def edit(self, *, reason=None, **fields):
"""|coro| """|coro|
Edits the member's data. Edits the member's data.
@ -423,7 +418,7 @@ class Member(discord.abc.Messageable, _BaseUser):
else: else:
nick = nick if nick else '' nick = nick if nick else ''
if self._state.self_id == self.id: if self._state.self_id == self.id:
yield from http.change_my_nickname(guild_id, nick, reason=reason) await http.change_my_nickname(guild_id, nick, reason=reason)
else: else:
payload['nick'] = nick payload['nick'] = nick
@ -449,12 +444,11 @@ class Member(discord.abc.Messageable, _BaseUser):
else: else:
payload['roles'] = tuple(r.id for r in roles) payload['roles'] = tuple(r.id for r in roles)
yield from http.edit_member(guild_id, self.id, reason=reason, **payload) await http.edit_member(guild_id, self.id, reason=reason, **payload)
# TODO: wait for WS event for modify-in-place behaviour # TODO: wait for WS event for modify-in-place behaviour
@asyncio.coroutine async def move_to(self, channel, *, reason=None):
def move_to(self, channel, *, reason=None):
"""|coro| """|coro|
Moves a member to a new voice channel (they must be connected first). Moves a member to a new voice channel (they must be connected first).
@ -471,10 +465,9 @@ class Member(discord.abc.Messageable, _BaseUser):
reason: Optional[str] reason: Optional[str]
The reason for doing this action. Shows up on the audit log. The reason for doing this action. Shows up on the audit log.
""" """
yield from self.edit(voice_channel=channel, reason=reason) await self.edit(voice_channel=channel, reason=reason)
@asyncio.coroutine async def add_roles(self, *roles, reason=None, atomic=True):
def add_roles(self, *roles, reason=None, atomic=True):
"""|coro| """|coro|
Gives the member a number of :class:`Role`\s. Gives the member a number of :class:`Role`\s.
@ -504,16 +497,15 @@ class Member(discord.abc.Messageable, _BaseUser):
if not atomic: if not atomic:
new_roles = utils._unique(Object(id=r.id) for s in (self.roles[1:], roles) for r in s) new_roles = utils._unique(Object(id=r.id) for s in (self.roles[1:], roles) for r in s)
yield from self.edit(roles=new_roles, reason=reason) await self.edit(roles=new_roles, reason=reason)
else: else:
req = self._state.http.add_role req = self._state.http.add_role
guild_id = self.guild.id guild_id = self.guild.id
user_id = self.id user_id = self.id
for role in roles: for role in roles:
yield from req(guild_id, user_id, role.id, reason=reason) await req(guild_id, user_id, role.id, reason=reason)
@asyncio.coroutine async def remove_roles(self, *roles, reason=None, atomic=True):
def remove_roles(self, *roles, reason=None, atomic=True):
"""|coro| """|coro|
Removes :class:`Role`\s from this member. Removes :class:`Role`\s from this member.
@ -549,10 +541,10 @@ class Member(discord.abc.Messageable, _BaseUser):
except ValueError: except ValueError:
pass pass
yield from self.edit(roles=new_roles, reason=reason) await self.edit(roles=new_roles, reason=reason)
else: else:
req = self._state.http.remove_role req = self._state.http.remove_role
guild_id = self.guild.id guild_id = self.guild.id
user_id = self.id user_id = self.id
for role in roles: for role in roles:
yield from req(guild_id, user_id, role.id, reason=reason) await req(guild_id, user_id, role.id, reason=reason)

51
discord/message.py
View File

@ -71,8 +71,7 @@ class Attachment:
self.proxy_url = data.get('proxy_url') self.proxy_url = data.get('proxy_url')
self._http = state.http self._http = state.http
@asyncio.coroutine async def save(self, fp, *, seek_begin=True):
def save(self, fp, *, seek_begin=True):
"""|coro| """|coro|
Saves this attachment into a file-like object. Saves this attachment into a file-like object.
@ -100,7 +99,7 @@ class Attachment:
The number of bytes written. The number of bytes written.
""" """
data = yield from self._http.get_attachment(self.url) data = await self._http.get_attachment(self.url)
if isinstance(fp, str): if isinstance(fp, str):
with open(fp, 'wb') as f: with open(fp, 'wb') as f:
return f.write(data) return f.write(data)
@ -527,8 +526,7 @@ class Message:
else: else:
return '{0.author.name} started a call \N{EM DASH} Join the call.'.format(self) return '{0.author.name} started a call \N{EM DASH} Join the call.'.format(self)
@asyncio.coroutine async def delete(self):
def delete(self):
"""|coro| """|coro|
Deletes the message. Deletes the message.
@ -544,10 +542,9 @@ class Message:
HTTPException HTTPException
Deleting the message failed. Deleting the message failed.
""" """
yield from self._state.http.delete_message(self.channel.id, self.id) await self._state.http.delete_message(self.channel.id, self.id)
@asyncio.coroutine async def edit(self, **fields):
def edit(self, **fields):
"""|coro| """|coro|
Edits the message. Edits the message.
@ -589,7 +586,7 @@ class Message:
if embed is not None: if embed is not None:
fields['embed'] = embed.to_dict() fields['embed'] = embed.to_dict()
data = yield from self._state.http.edit_message(self.id, self.channel.id, **fields) data = await self._state.http.edit_message(self.id, self.channel.id, **fields)
self._update(channel=self.channel, data=data) self._update(channel=self.channel, data=data)
try: try:
@ -598,18 +595,16 @@ class Message:
pass pass
else: else:
if delete_after is not None: if delete_after is not None:
@asyncio.coroutine async def delete():
def delete(): await asyncio.sleep(delete_after, loop=self._state.loop)
yield from asyncio.sleep(delete_after, loop=self._state.loop)
try: try:
yield from self._state.http.delete_message(self.channel.id, self.id) await self._state.http.delete_message(self.channel.id, self.id)
except: except:
pass pass
compat.create_task(delete(), loop=self._state.loop) asyncio.ensure_future(delete(), loop=self._state.loop)
@asyncio.coroutine async def pin(self):
def pin(self):
"""|coro| """|coro|
Pins the message. Pins the message.
@ -628,11 +623,10 @@ class Message:
having more than 50 pinned messages. having more than 50 pinned messages.
""" """
yield from self._state.http.pin_message(self.channel.id, self.id) await self._state.http.pin_message(self.channel.id, self.id)
self.pinned = True self.pinned = True
@asyncio.coroutine async def unpin(self):
def unpin(self):
"""|coro| """|coro|
Unpins the message. Unpins the message.
@ -650,11 +644,10 @@ class Message:
Unpinning the message failed. Unpinning the message failed.
""" """
yield from self._state.http.unpin_message(self.channel.id, self.id) await self._state.http.unpin_message(self.channel.id, self.id)
self.pinned = False self.pinned = False
@asyncio.coroutine async def add_reaction(self, emoji):
def add_reaction(self, emoji):
"""|coro| """|coro|
Add a reaction to the message. Add a reaction to the message.
@ -694,10 +687,9 @@ class Message:
else: else:
raise InvalidArgument('emoji argument must be str, Emoji, or Reaction not {.__class__.__name__}.'.format(emoji)) raise InvalidArgument('emoji argument must be str, Emoji, or Reaction not {.__class__.__name__}.'.format(emoji))
yield from self._state.http.add_reaction(self.id, self.channel.id, emoji) await self._state.http.add_reaction(self.id, self.channel.id, emoji)
@asyncio.coroutine async def remove_reaction(self, emoji, member):
def remove_reaction(self, emoji, member):
"""|coro| """|coro|
Remove a reaction by the member from the message. Remove a reaction by the member from the message.
@ -742,12 +734,11 @@ class Message:
raise InvalidArgument('emoji argument must be str, Emoji, or Reaction not {.__class__.__name__}.'.format(emoji)) raise InvalidArgument('emoji argument must be str, Emoji, or Reaction not {.__class__.__name__}.'.format(emoji))
if member.id == self._state.self_id: if member.id == self._state.self_id:
yield from self._state.http.remove_own_reaction(self.id, self.channel.id, emoji) await self._state.http.remove_own_reaction(self.id, self.channel.id, emoji)
else: else:
yield from self._state.http.remove_reaction(self.id, self.channel.id, emoji, member.id) await self._state.http.remove_reaction(self.id, self.channel.id, emoji, member.id)
@asyncio.coroutine async def clear_reactions(self):
def clear_reactions(self):
"""|coro| """|coro|
Removes all the reactions from the message. Removes all the reactions from the message.
@ -761,7 +752,7 @@ class Message:
Forbidden Forbidden
You do not have the proper permissions to remove all the reactions. You do not have the proper permissions to remove all the reactions.
""" """
yield from self._state.http.clear_reactions(self.id, self.channel.id) await self._state.http.clear_reactions(self.id, self.channel.id)
def ack(self): def ack(self):
"""|coro| """|coro|

2
discord/reaction.py
View File

@ -137,7 +137,7 @@ class Reaction:
iterator = reaction.users() iterator = reaction.users()
while True: while True:
try: try:
user = yield from iterator.next() user = await iterator.next()
except discord.NoMoreItems: except discord.NoMoreItems:
break break
else: else:

10
discord/relationship.py
View File

@ -52,8 +52,7 @@ class Relationship:
def __repr__(self): def __repr__(self):
return '<Relationship user={0.user!r} type={0.type!r}>'.format(self) return '<Relationship user={0.user!r} type={0.type!r}>'.format(self)
@asyncio.coroutine async def delete(self):
def delete(self):
"""|coro| """|coro|
Deletes the relationship. Deletes the relationship.
@ -64,10 +63,9 @@ class Relationship:
Deleting the relationship failed. Deleting the relationship failed.
""" """
yield from self._state.http.remove_relationship(self.user.id) await self._state.http.remove_relationship(self.user.id)
@asyncio.coroutine async def accept(self):
def accept(self):
"""|coro| """|coro|
Accepts the relationship request. e.g. accepting a Accepts the relationship request. e.g. accepting a
@ -79,4 +77,4 @@ class Relationship:
Accepting the relationship failed. Accepting the relationship failed.
""" """
yield from self._state.http.add_relationship(self.user.id) await self._state.http.add_relationship(self.user.id)

17
discord/role.py
View File

@ -171,8 +171,7 @@ class Role(Hashable):
return [member for member in all_members if self in member.roles] return [member for member in all_members if self in member.roles]
@asyncio.coroutine async def _move(self, position, reason):
def _move(self, position, reason):
if position <= 0: if position <= 0:
raise InvalidArgument("Cannot move role to position 0 or below") raise InvalidArgument("Cannot move role to position 0 or below")
@ -196,10 +195,9 @@ class Role(Hashable):
roles.append(self.id) roles.append(self.id)
payload = [{"id": z[0], "position": z[1]} for z in zip(roles, change_range)] payload = [{"id": z[0], "position": z[1]} for z in zip(roles, change_range)]
yield from http.move_role_position(self.guild.id, payload, reason=reason) await http.move_role_position(self.guild.id, payload, reason=reason)
@asyncio.coroutine async def edit(self, *, reason=None, **fields):
def edit(self, *, reason=None, **fields):
"""|coro| """|coro|
Edits the role. Edits the role.
@ -240,7 +238,7 @@ class Role(Hashable):
position = fields.get('position') position = fields.get('position')
if position is not None: if position is not None:
yield from self._move(position, reason=reason) await self._move(position, reason=reason)
self.position = position self.position = position
try: try:
@ -256,11 +254,10 @@ class Role(Hashable):
'mentionable': fields.get('mentionable', self.mentionable) 'mentionable': fields.get('mentionable', self.mentionable)
} }
data = yield from self._state.http.edit_role(self.guild.id, self.id, reason=reason, **payload) data = await self._state.http.edit_role(self.guild.id, self.id, reason=reason, **payload)
self._update(data) self._update(data)
@asyncio.coroutine async def delete(self, *, reason=None):
def delete(self, *, reason=None):
"""|coro| """|coro|
Deletes the role. Deletes the role.
@ -281,4 +278,4 @@ class Role(Hashable):
Deleting the role failed. Deleting the role failed.
""" """
yield from self._state.http.delete_role(self.guild.id, self.id, reason=reason) await self._state.http.delete_role(self.guild.id, self.id, reason=reason)

91
discord/shard.py
View File

@ -43,7 +43,7 @@ class Shard:
self.ws = ws self.ws = ws
self._client = client self._client = client
self.loop = self._client.loop self.loop = self._client.loop
self._current = compat.create_future(self.loop) self._current = self.loop.create_future()
self._current.set_result(None) # we just need an already done future self._current.set_result(None) # we just need an already done future
self._pending = asyncio.Event(loop=self.loop) self._pending = asyncio.Event(loop=self.loop)
self._pending_task = None self._pending_task = None
@ -58,47 +58,36 @@ class Shard:
def complete_pending_reads(self): def complete_pending_reads(self):
self._pending.set() self._pending.set()
def _pending_reads(self): async def _pending_reads(self):
try: try:
while self.is_pending(): while self.is_pending():
yield from self.poll() await self.poll()
except asyncio.CancelledError: except asyncio.CancelledError:
pass pass
def launch_pending_reads(self): def launch_pending_reads(self):
self._pending_task = compat.create_task(self._pending_reads(), loop=self.loop) self._pending_task = asyncio.ensure_future(self._pending_reads(), loop=self.loop)
def wait(self): def wait(self):
return self._pending_task return self._pending_task
@asyncio.coroutine async def poll(self):
def poll(self):
try: try:
yield from self.ws.poll_event() await self.ws.poll_event()
except ResumeWebSocket as e: except ResumeWebSocket as e:
log.info('Got a request to RESUME the websocket at Shard ID %s.', self.id) log.info('Got a request to RESUME the websocket at Shard ID %s.', self.id)
coro = DiscordWebSocket.from_client(self._client, resume=True, coro = DiscordWebSocket.from_client(self._client, resume=True,
shard_id=self.id, shard_id=self.id,
session=self.ws.session_id, session=self.ws.session_id,
sequence=self.ws.sequence) sequence=self.ws.sequence)
self.ws = yield from asyncio.wait_for(coro, timeout=180.0, loop=self.loop) self.ws = await asyncio.wait_for(coro, timeout=180.0, loop=self.loop)
def get_future(self): def get_future(self):
if self._current.done(): if self._current.done():
self._current = compat.create_task(self.poll(), loop=self.loop) self._current = asyncio.ensure_future(self.poll(), loop=self.loop)
return self._current return self._current
@asyncio.coroutine
def _ensure_coroutine_connect(gateway, loop):
# In 3.5+ websockets.connect does not return a coroutine, but an awaitable.
# The problem is that in 3.5.0 and in some cases 3.5.1, asyncio.ensure_future and
# by proxy, asyncio.wait_for, do not accept awaitables, but rather futures or coroutines.
# By wrapping it up into this function we ensure that it's in a coroutine and not an awaitable
# even for 3.5.0 users.
ws = yield from websockets.connect(gateway, loop=loop, klass=DiscordWebSocket)
return ws
class AutoShardedClient(Client): class AutoShardedClient(Client):
"""A client similar to :class:`Client` except it handles the complications """A client similar to :class:`Client` except it handles the complications
of sharding for the user into a more manageable and transparent single of sharding for the user into a more manageable and transparent single
@ -149,8 +138,7 @@ class AutoShardedClient(Client):
self._connection._get_websocket = _get_websocket self._connection._get_websocket = _get_websocket
@asyncio.coroutine async def _chunker(self, guild, *, shard_id=None):
def _chunker(self, guild, *, shard_id=None):
try: try:
guild_id = guild.id guild_id = guild.id
shard_id = shard_id or guild.shard_id shard_id = shard_id or guild.shard_id
@ -167,7 +155,7 @@ class AutoShardedClient(Client):
} }
ws = self.shards[shard_id].ws ws = self.shards[shard_id].ws
yield from ws.send_as_json(payload) await ws.send_as_json(payload)
@property @property
def latency(self): def latency(self):
@ -189,8 +177,7 @@ class AutoShardedClient(Client):
""" """
return [(shard_id, shard.ws.latency) for shard_id, shard in self.shards.items()] return [(shard_id, shard.ws.latency) for shard_id, shard in self.shards.items()]
@asyncio.coroutine async def request_offline_members(self, *guilds):
def request_offline_members(self, *guilds):
"""|coro| """|coro|
Requests previously offline members from the guild to be filled up Requests previously offline members from the guild to be filled up
@ -219,16 +206,16 @@ class AutoShardedClient(Client):
_guilds = sorted(guilds, key=lambda g: g.shard_id) _guilds = sorted(guilds, key=lambda g: g.shard_id)
for shard_id, sub_guilds in itertools.groupby(_guilds, key=lambda g: g.shard_id): for shard_id, sub_guilds in itertools.groupby(_guilds, key=lambda g: g.shard_id):
sub_guilds = list(sub_guilds) sub_guilds = list(sub_guilds)
yield from self._connection.request_offline_members(sub_guilds, shard_id=shard_id) await self._connection.request_offline_members(sub_guilds, shard_id=shard_id)
@asyncio.coroutine async def launch_shard(self, gateway, shard_id):
def launch_shard(self, gateway, shard_id):
try: try:
ws = yield from asyncio.wait_for(_ensure_coroutine_connect(gateway, self.loop), loop=self.loop, timeout=180.0) coro = websockets.connect(gateway, loop=self.loop, klass=DiscordWebSocket)
ws = await asyncio.wait_for(coro, loop=self.loop, timeout=180.0)
except Exception as e: except Exception as e:
log.info('Failed to connect for shard_id: %s. Retrying...', shard_id) log.info('Failed to connect for shard_id: %s. Retrying...', shard_id)
yield from asyncio.sleep(5.0, loop=self.loop) await asyncio.sleep(5.0, loop=self.loop)
return (yield from self.launch_shard(gateway, shard_id)) return (await self.launch_shard(gateway, shard_id))
ws.token = self.http.token ws.token = self.http.token
ws._connection = self._connection ws._connection = self._connection
@ -240,31 +227,30 @@ class AutoShardedClient(Client):
try: try:
# OP HELLO # OP HELLO
yield from asyncio.wait_for(ws.poll_event(), loop=self.loop, timeout=180.0) await asyncio.wait_for(ws.poll_event(), loop=self.loop, timeout=180.0)
yield from asyncio.wait_for(ws.identify(), loop=self.loop, timeout=180.0) await asyncio.wait_for(ws.identify(), loop=self.loop, timeout=180.0)
except asyncio.TimeoutError: except asyncio.TimeoutError:
log.info('Timed out when connecting for shard_id: %s. Retrying...', shard_id) log.info('Timed out when connecting for shard_id: %s. Retrying...', shard_id)
yield from asyncio.sleep(5.0, loop=self.loop) await asyncio.sleep(5.0, loop=self.loop)
return (yield from self.launch_shard(gateway, shard_id)) return (await self.launch_shard(gateway, shard_id))
# keep reading the shard while others connect # keep reading the shard while others connect
self.shards[shard_id] = ret = Shard(ws, self) self.shards[shard_id] = ret = Shard(ws, self)
ret.launch_pending_reads() ret.launch_pending_reads()
yield from asyncio.sleep(5.0, loop=self.loop) await asyncio.sleep(5.0, loop=self.loop)
@asyncio.coroutine async def launch_shards(self):
def launch_shards(self):
if self.shard_count is None: if self.shard_count is None:
self.shard_count, gateway = yield from self.http.get_bot_gateway() self.shard_count, gateway = await self.http.get_bot_gateway()
else: else:
gateway = yield from self.http.get_gateway() gateway = await self.http.get_gateway()
self._connection.shard_count = self.shard_count self._connection.shard_count = self.shard_count
shard_ids = self.shard_ids if self.shard_ids else range(self.shard_count) shard_ids = self.shard_ids if self.shard_ids else range(self.shard_count)
for shard_id in shard_ids: for shard_id in shard_ids:
yield from self.launch_shard(gateway, shard_id) await self.launch_shard(gateway, shard_id)
shards_to_wait_for = [] shards_to_wait_for = []
for shard in self.shards.values(): for shard in self.shards.values():
@ -272,21 +258,19 @@ class AutoShardedClient(Client):
shards_to_wait_for.append(shard.wait()) shards_to_wait_for.append(shard.wait())
# wait for all pending tasks to finish # wait for all pending tasks to finish
yield from utils.sane_wait_for(shards_to_wait_for, timeout=300.0, loop=self.loop) await utils.sane_wait_for(shards_to_wait_for, timeout=300.0, loop=self.loop)
@asyncio.coroutine async def _connect(self):
def _connect(self): await self.launch_shards()
yield from self.launch_shards()
while True: while True:
pollers = [shard.get_future() for shard in self.shards.values()] pollers = [shard.get_future() for shard in self.shards.values()]
done, pending = yield from asyncio.wait(pollers, loop=self.loop, return_when=asyncio.FIRST_COMPLETED) done, pending = await asyncio.wait(pollers, loop=self.loop, return_when=asyncio.FIRST_COMPLETED)
for f in done: for f in done:
# we wanna re-raise to the main Client.connect handler if applicable # we wanna re-raise to the main Client.connect handler if applicable
f.result() f.result()
@asyncio.coroutine async def close(self):
def close(self):
"""|coro| """|coro|
Closes the connection to discord. Closes the connection to discord.
@ -298,16 +282,15 @@ class AutoShardedClient(Client):
for vc in self.voice_clients: for vc in self.voice_clients:
try: try:
yield from vc.disconnect() await vc.disconnect()
except: except:
pass pass
to_close = [shard.ws.close() for shard in self.shards.values()] to_close = [shard.ws.close() for shard in self.shards.values()]
yield from asyncio.wait(to_close, loop=self.loop) await asyncio.wait(to_close, loop=self.loop)
yield from self.http.close() await self.http.close()
@asyncio.coroutine async def change_presence(self, *, activity=None, status=None, afk=False, shard_id=None):
def change_presence(self, *, activity=None, status=None, afk=False, shard_id=None):
"""|coro| """|coro|
Changes the client's presence. Changes the client's presence.
@ -355,12 +338,12 @@ class AutoShardedClient(Client):
if shard_id is None: if shard_id is None:
for shard in self.shards.values(): for shard in self.shards.values():
yield from shard.ws.change_presence(activity=activity, status=status, afk=afk) await shard.ws.change_presence(activity=activity, status=status, afk=afk)
guilds = self._connection.guilds guilds = self._connection.guilds
else: else:
shard = self.shards[shard_id] shard = self.shards[shard_id]
yield from shard.ws.change_presence(activity=activity, status=status, afk=afk) await shard.ws.change_presence(activity=activity, status=status, afk=afk)
guilds = [g for g in self._connection.guilds if g.shard_id == shard_id] guilds = [g for g in self._connection.guilds if g.shard_id == shard_id]
for guild in guilds: for guild in guilds:

47
discord/state.py
View File

@ -255,8 +255,7 @@ class ConnectionState:
return channel, guild return channel, guild
@asyncio.coroutine async def request_offline_members(self, guilds):
def request_offline_members(self, guilds):
# get all the chunks # get all the chunks
chunks = [] chunks = []
for guild in guilds: for guild in guilds:
@ -265,17 +264,16 @@ class ConnectionState:
# we only want to request ~75 guilds per chunk request. # we only want to request ~75 guilds per chunk request.
splits = [guilds[i:i + 75] for i in range(0, len(guilds), 75)] splits = [guilds[i:i + 75] for i in range(0, len(guilds), 75)]
for split in splits: for split in splits:
yield from self.chunker(split) await self.chunker(split)
# wait for the chunks # wait for the chunks
if chunks: if chunks:
try: try:
yield from utils.sane_wait_for(chunks, timeout=len(chunks) * 30.0, loop=self.loop) await utils.sane_wait_for(chunks, timeout=len(chunks) * 30.0, loop=self.loop)
except asyncio.TimeoutError: except asyncio.TimeoutError:
log.info('Somehow timed out waiting for chunks.') log.info('Somehow timed out waiting for chunks.')
@asyncio.coroutine async def _delay_ready(self):
def _delay_ready(self):
try: try:
launch = self._ready_state.launch launch = self._ready_state.launch
@ -285,11 +283,11 @@ class ConnectionState:
# this snippet of code is basically waiting 2 seconds # this snippet of code is basically waiting 2 seconds
# until the last GUILD_CREATE was sent # until the last GUILD_CREATE was sent
launch.set() launch.set()
yield from asyncio.sleep(2, loop=self.loop) await asyncio.sleep(2, loop=self.loop)
guilds = self._ready_state.guilds guilds = self._ready_state.guilds
if self._fetch_offline: if self._fetch_offline:
yield from self.request_offline_members(guilds) await self.request_offline_members(guilds)
# remove the state # remove the state
try: try:
@ -300,7 +298,7 @@ class ConnectionState:
# call GUILD_SYNC after we're done chunking # call GUILD_SYNC after we're done chunking
if not self.is_bot: if not self.is_bot:
log.info('Requesting GUILD_SYNC for %s guilds', len(self.guilds)) log.info('Requesting GUILD_SYNC for %s guilds', len(self.guilds))
yield from self.syncer([s.id for s in self.guilds]) await self.syncer([s.id for s in self.guilds])
except asyncio.CancelledError: except asyncio.CancelledError:
pass pass
else: else:
@ -336,7 +334,7 @@ class ConnectionState:
self._add_private_channel(factory(me=self.user, data=pm, state=self)) self._add_private_channel(factory(me=self.user, data=pm, state=self))
self.dispatch('connect') self.dispatch('connect')
self._ready_task = compat.create_task(self._delay_ready(), loop=self.loop) self._ready_task = asyncio.ensure_future(self._delay_ready(), loop=self.loop)
def parse_resumed(self, data): def parse_resumed(self, data):
self.dispatch('resumed') self.dispatch('resumed')
@ -617,13 +615,12 @@ class ConnectionState:
return self._add_guild_from_data(data) return self._add_guild_from_data(data)
@asyncio.coroutine async def _chunk_and_dispatch(self, guild, unavailable):
def _chunk_and_dispatch(self, guild, unavailable):
chunks = list(self.chunks_needed(guild)) chunks = list(self.chunks_needed(guild))
yield from self.chunker(guild) await self.chunker(guild)
if chunks: if chunks:
try: try:
yield from utils.sane_wait_for(chunks, timeout=len(chunks), loop=self.loop) await utils.sane_wait_for(chunks, timeout=len(chunks), loop=self.loop)
except asyncio.TimeoutError: except asyncio.TimeoutError:
log.info('Somehow timed out waiting for chunks.') log.info('Somehow timed out waiting for chunks.')
@ -662,7 +659,7 @@ class ConnectionState:
# since we're not waiting for 'useful' READY we'll just # since we're not waiting for 'useful' READY we'll just
# do the chunk request here if wanted # do the chunk request here if wanted
if self._fetch_offline: if self._fetch_offline:
compat.create_task(self._chunk_and_dispatch(guild, unavailable), loop=self.loop) asyncio.ensure_future(self._chunk_and_dispatch(guild, unavailable), loop=self.loop)
return return
# Dispatch available if newly available # Dispatch available if newly available
@ -807,7 +804,7 @@ class ConnectionState:
vc = self._get_voice_client(key_id) vc = self._get_voice_client(key_id)
if vc is not None: if vc is not None:
compat.create_task(vc._create_socket(key_id, data)) asyncio.ensure_future(vc._create_socket(key_id, data))
def parse_typing_start(self, data): def parse_typing_start(self, data):
channel, guild = self._get_guild_channel(data) channel, guild = self._get_guild_channel(data)
@ -886,7 +883,7 @@ class ConnectionState:
return Message(state=self, channel=channel, data=data) return Message(state=self, channel=channel, data=data)
def receive_chunk(self, guild_id): def receive_chunk(self, guild_id):
future = compat.create_future(self.loop) future = self.loop.create_future()
listener = Listener(ListenerType.chunk, future, lambda s: s.id == guild_id) listener = Listener(ListenerType.chunk, future, lambda s: s.id == guild_id)
self._listeners.append(listener) self._listeners.append(listener)
return future return future
@ -896,8 +893,7 @@ class AutoShardedConnectionState(ConnectionState):
super().__init__(*args, **kwargs) super().__init__(*args, **kwargs)
self._ready_task = None self._ready_task = None
@asyncio.coroutine async def request_offline_members(self, guilds, *, shard_id):
def request_offline_members(self, guilds, *, shard_id):
# get all the chunks # get all the chunks
chunks = [] chunks = []
for guild in guilds: for guild in guilds:
@ -906,30 +902,29 @@ class AutoShardedConnectionState(ConnectionState):
# we only want to request ~75 guilds per chunk request. # we only want to request ~75 guilds per chunk request.
splits = [guilds[i:i + 75] for i in range(0, len(guilds), 75)] splits = [guilds[i:i + 75] for i in range(0, len(guilds), 75)]
for split in splits: for split in splits:
yield from self.chunker(split, shard_id=shard_id) await self.chunker(split, shard_id=shard_id)
# wait for the chunks # wait for the chunks
if chunks: if chunks:
try: try:
yield from utils.sane_wait_for(chunks, timeout=len(chunks) * 30.0, loop=self.loop) await utils.sane_wait_for(chunks, timeout=len(chunks) * 30.0, loop=self.loop)
except asyncio.TimeoutError: except asyncio.TimeoutError:
log.info('Somehow timed out waiting for chunks.') log.info('Somehow timed out waiting for chunks.')
@asyncio.coroutine async def _delay_ready(self):
def _delay_ready(self):
launch = self._ready_state.launch launch = self._ready_state.launch
while not launch.is_set(): while not launch.is_set():
# this snippet of code is basically waiting 2 seconds # this snippet of code is basically waiting 2 seconds
# until the last GUILD_CREATE was sent # until the last GUILD_CREATE was sent
launch.set() launch.set()
yield from asyncio.sleep(2.0 * self.shard_count, loop=self.loop) await asyncio.sleep(2.0 * self.shard_count, loop=self.loop)
if self._fetch_offline: if self._fetch_offline:
guilds = sorted(self._ready_state.guilds, key=lambda g: g.shard_id) guilds = sorted(self._ready_state.guilds, key=lambda g: g.shard_id)
for shard_id, sub_guilds in itertools.groupby(guilds, key=lambda g: g.shard_id): for shard_id, sub_guilds in itertools.groupby(guilds, key=lambda g: g.shard_id):
sub_guilds = list(sub_guilds) sub_guilds = list(sub_guilds)
yield from self.request_offline_members(sub_guilds, shard_id=shard_id) await self.request_offline_members(sub_guilds, shard_id=shard_id)
self.dispatch('shard_ready', shard_id) self.dispatch('shard_ready', shard_id)
# remove the state # remove the state
@ -964,4 +959,4 @@ class AutoShardedConnectionState(ConnectionState):
self.dispatch('connect') self.dispatch('connect')
if self._ready_task is None: if self._ready_task is None:
self._ready_task = compat.create_task(self._delay_ready(), loop=self.loop) self._ready_task = asyncio.ensure_future(self._delay_ready(), loop=self.loop)

45
discord/user.py
View File

@ -313,8 +313,7 @@ class ClientUser(BaseUser):
"""Returns a :class:`list` of :class:`User`\s that the user has blocked.""" """Returns a :class:`list` of :class:`User`\s that the user has blocked."""
return [r.user for r in self._relationships.values() if r.type is RelationshipType.blocked] return [r.user for r in self._relationships.values() if r.type is RelationshipType.blocked]
@asyncio.coroutine async def edit(self, **fields):
def edit(self, **fields):
"""|coro| """|coro|
Edits the current profile of the client. Edits the current profile of the client.
@ -387,7 +386,7 @@ class ClientUser(BaseUser):
http = self._state.http http = self._state.http
data = yield from http.edit_profile(**args) data = await http.edit_profile(**args)
if not_bot_account: if not_bot_account:
self.email = data['email'] self.email = data['email']
try: try:
@ -398,8 +397,7 @@ class ClientUser(BaseUser):
# manually update data by calling __init__ explicitly. # manually update data by calling __init__ explicitly.
self.__init__(state=self._state, data=data) self.__init__(state=self._state, data=data)
@asyncio.coroutine async def create_group(self, *recipients):
def create_group(self, *recipients):
"""|coro| """|coro|
Creates a group direct message with the recipients Creates a group direct message with the recipients
@ -434,7 +432,7 @@ class ClientUser(BaseUser):
raise ClientException('You must have two or more recipients to create a group.') raise ClientException('You must have two or more recipients to create a group.')
users = [str(u.id) for u in recipients] users = [str(u.id) for u in recipients]
data = yield from self._state.http.create_group(self.id, users) data = await self._state.http.create_group(self.id, users)
return GroupChannel(me=self, data=data, state=self._state) return GroupChannel(me=self, data=data, state=self._state)
class User(BaseUser, discord.abc.Messageable): class User(BaseUser, discord.abc.Messageable):
@ -477,9 +475,8 @@ class User(BaseUser, discord.abc.Messageable):
def __repr__(self): def __repr__(self):
return '<User id={0.id} name={0.name!r} discriminator={0.discriminator!r} bot={0.bot}>'.format(self) return '<User id={0.id} name={0.name!r} discriminator={0.discriminator!r} bot={0.bot}>'.format(self)
@asyncio.coroutine async def _get_channel(self):
def _get_channel(self): ch = await self.create_dm()
ch = yield from self.create_dm()
return ch return ch
@property @property
@ -491,8 +488,7 @@ class User(BaseUser, discord.abc.Messageable):
""" """
return self._state._get_private_channel_by_user(self.id) return self._state._get_private_channel_by_user(self.id)
@asyncio.coroutine async def create_dm(self):
def create_dm(self):
"""Creates a :class:`DMChannel` with this user. """Creates a :class:`DMChannel` with this user.
This should be rarely called, as this is done transparently for most This should be rarely called, as this is done transparently for most
@ -503,7 +499,7 @@ class User(BaseUser, discord.abc.Messageable):
return found return found
state = self._state state = self._state
data = yield from state.http.start_private_message(self.id) data = await state.http.start_private_message(self.id)
return state.add_dm_channel(data) return state.add_dm_channel(data)
@property @property
@ -525,8 +521,7 @@ class User(BaseUser, discord.abc.Messageable):
return False return False
return r.type is RelationshipType.blocked return r.type is RelationshipType.blocked
@asyncio.coroutine async def block(self):
def block(self):
"""|coro| """|coro|
Blocks the user. Blocks the user.
@ -539,10 +534,9 @@ class User(BaseUser, discord.abc.Messageable):
Blocking the user failed. Blocking the user failed.
""" """
yield from self._state.http.add_relationship(self.id, type=RelationshipType.blocked.value) await self._state.http.add_relationship(self.id, type=RelationshipType.blocked.value)
@asyncio.coroutine async def unblock(self):
def unblock(self):
"""|coro| """|coro|
Unblocks the user. Unblocks the user.
@ -554,10 +548,9 @@ class User(BaseUser, discord.abc.Messageable):
HTTPException HTTPException
Unblocking the user failed. Unblocking the user failed.
""" """
yield from self._state.http.remove_relationship(self.id) await self._state.http.remove_relationship(self.id)
@asyncio.coroutine async def remove_friend(self):
def remove_friend(self):
"""|coro| """|coro|
Removes the user as a friend. Removes the user as a friend.
@ -569,10 +562,9 @@ class User(BaseUser, discord.abc.Messageable):
HTTPException HTTPException
Removing the user as a friend failed. Removing the user as a friend failed.
""" """
yield from self._state.http.remove_relationship(self.id) await self._state.http.remove_relationship(self.id)
@asyncio.coroutine async def send_friend_request(self):
def send_friend_request(self):
"""|coro| """|coro|
Sends the user a friend request. Sends the user a friend request.
@ -584,10 +576,9 @@ class User(BaseUser, discord.abc.Messageable):
HTTPException HTTPException
Sending the friend request failed. Sending the friend request failed.
""" """
yield from self._state.http.send_friend_request(username=self.name, discriminator=self.discriminator) await self._state.http.send_friend_request(username=self.name, discriminator=self.discriminator)
@asyncio.coroutine async def profile(self):
def profile(self):
"""|coro| """|coro|
Gets the user's profile. This can only be used by non-bot accounts. Gets the user's profile. This can only be used by non-bot accounts.
@ -606,7 +597,7 @@ class User(BaseUser, discord.abc.Messageable):
""" """
state = self._state state = self._state
data = yield from state.http.get_user_profile(self.id) data = await state.http.get_user_profile(self.id)
def transform(d): def transform(d):
return state._get_guild(int(d['id'])) return state._get_guild(int(d['id']))

19
discord/utils.py
View File

@ -29,6 +29,7 @@ from .errors import InvalidArgument
import datetime import datetime
from base64 import b64encode from base64 import b64encode
from email.utils import parsedate_to_datetime from email.utils import parsedate_to_datetime
from inspect import isawaitable as _isawaitable
import asyncio import asyncio
import json import json
import warnings, functools import warnings, functools
@ -264,27 +265,23 @@ def _parse_ratelimit_header(request):
reset = datetime.datetime.fromtimestamp(int(request.headers['X-Ratelimit-Reset']), datetime.timezone.utc) reset = datetime.datetime.fromtimestamp(int(request.headers['X-Ratelimit-Reset']), datetime.timezone.utc)
return (reset - now).total_seconds() return (reset - now).total_seconds()
@asyncio.coroutine async def maybe_coroutine(f, *args, **kwargs):
def maybe_coroutine(f, *args, **kwargs):
value = f(*args, **kwargs) value = f(*args, **kwargs)
if asyncio.iscoroutine(value): if _isawaitable(value):
return (yield from value) return (await value)
else: else:
return value return value
@asyncio.coroutine async def async_all(gen, *, check=_isawaitable):
def async_all(gen):
check = asyncio.iscoroutine
for elem in gen: for elem in gen:
if check(elem): if check(elem):
elem = yield from elem elem = await elem
if not elem: if not elem:
return False return False
return True return True
@asyncio.coroutine async def sane_wait_for(futures, *, timeout, loop):
def sane_wait_for(futures, *, timeout, loop): done, pending = await asyncio.wait(futures, timeout=timeout, loop=loop)
done, pending = yield from asyncio.wait(futures, timeout=timeout, loop=loop)
if len(pending) != 0: if len(pending) != 0:
raise asyncio.TimeoutError() raise asyncio.TimeoutError()

61
discord/voice_client.py
View File

@ -129,8 +129,7 @@ class VoiceClient:
# connection related # connection related
@asyncio.coroutine async def start_handshake(self):
def start_handshake(self):
log.info('Starting voice handshake...') log.info('Starting voice handshake...')
key_id, key_name = self.channel._get_voice_client_key() key_id, key_name = self.channel._get_voice_client_key()
@ -140,21 +139,20 @@ class VoiceClient:
self._connections += 1 self._connections += 1
# request joining # request joining
yield from ws.voice_state(guild_id, channel_id) await ws.voice_state(guild_id, channel_id)
try: try:
yield from asyncio.wait_for(self._handshake_complete.wait(), timeout=self.timeout, loop=self.loop) await asyncio.wait_for(self._handshake_complete.wait(), timeout=self.timeout, loop=self.loop)
except asyncio.TimeoutError as e: except asyncio.TimeoutError as e:
yield from self.terminate_handshake(remove=True) await self.terminate_handshake(remove=True)
raise e raise e
log.info('Voice handshake complete. Endpoint found %s (IP: %s)', self.endpoint, self.endpoint_ip) log.info('Voice handshake complete. Endpoint found %s (IP: %s)', self.endpoint, self.endpoint_ip)
@asyncio.coroutine async def terminate_handshake(self, *, remove=False):
def terminate_handshake(self, *, remove=False):
guild_id, channel_id = self.channel._get_voice_state_pair() guild_id, channel_id = self.channel._get_voice_state_pair()
self._handshake_complete.clear() self._handshake_complete.clear()
yield from self.main_ws.voice_state(guild_id, None, self_mute=True) await self.main_ws.voice_state(guild_id, None, self_mute=True)
log.info('The voice handshake is being terminated for Channel ID %s (Guild ID %s)', channel_id, guild_id) log.info('The voice handshake is being terminated for Channel ID %s (Guild ID %s)', channel_id, guild_id)
if remove: if remove:
@ -162,8 +160,7 @@ class VoiceClient:
key_id, _ = self.channel._get_voice_client_key() key_id, _ = self.channel._get_voice_client_key()
self._state._remove_voice_client(key_id) self._state._remove_voice_client(key_id)
@asyncio.coroutine async def _create_socket(self, server_id, data):
def _create_socket(self, server_id, data):
self._connected.clear() self._connected.clear()
self.session_id = self.main_ws.session_id self.session_id = self.main_ws.session_id
self.server_id = server_id self.server_id = server_id
@ -190,13 +187,12 @@ class VoiceClient:
if self._handshake_complete.is_set(): if self._handshake_complete.is_set():
# terminate the websocket and handle the reconnect loop if necessary. # terminate the websocket and handle the reconnect loop if necessary.
self._handshake_complete.clear() self._handshake_complete.clear()
yield from self.ws.close(4000) await self.ws.close(4000)
return return
self._handshake_complete.set() self._handshake_complete.set()
@asyncio.coroutine async def connect(self, *, reconnect=True, _tries=0, do_handshake=True):
def connect(self, *, reconnect=True, _tries=0, do_handshake=True):
log.info('Connecting to voice...') log.info('Connecting to voice...')
try: try:
del self.secret_key del self.secret_key
@ -204,56 +200,54 @@ class VoiceClient:
pass pass
if do_handshake: if do_handshake:
yield from self.start_handshake() await self.start_handshake()
try: try:
self.ws = yield from DiscordVoiceWebSocket.from_client(self) self.ws = await DiscordVoiceWebSocket.from_client(self)
self._connected.clear() self._connected.clear()
while not hasattr(self, 'secret_key'): while not hasattr(self, 'secret_key'):
yield from self.ws.poll_event() await self.ws.poll_event()
self._connected.set() self._connected.set()
except (ConnectionClosed, asyncio.TimeoutError): except (ConnectionClosed, asyncio.TimeoutError):
if reconnect and _tries < 5: if reconnect and _tries < 5:
log.exception('Failed to connect to voice... Retrying...') log.exception('Failed to connect to voice... Retrying...')
yield from asyncio.sleep(1 + _tries * 2.0, loop=self.loop) await asyncio.sleep(1 + _tries * 2.0, loop=self.loop)
yield from self.terminate_handshake() await self.terminate_handshake()
yield from self.connect(reconnect=reconnect, _tries=_tries + 1) await self.connect(reconnect=reconnect, _tries=_tries + 1)
else: else:
raise raise
if self._runner is None: if self._runner is None:
self._runner = self.loop.create_task(self.poll_voice_ws(reconnect)) self._runner = self.loop.create_task(self.poll_voice_ws(reconnect))
@asyncio.coroutine async def poll_voice_ws(self, reconnect):
def poll_voice_ws(self, reconnect):
backoff = ExponentialBackoff() backoff = ExponentialBackoff()
while True: while True:
try: try:
yield from self.ws.poll_event() await self.ws.poll_event()
except (ConnectionClosed, asyncio.TimeoutError) as e: except (ConnectionClosed, asyncio.TimeoutError) as e:
if isinstance(e, ConnectionClosed): if isinstance(e, ConnectionClosed):
if e.code == 1000: if e.code == 1000:
yield from self.disconnect() await self.disconnect()
break break
if not reconnect: if not reconnect:
yield from self.disconnect() await self.disconnect()
raise e raise e
retry = backoff.delay() retry = backoff.delay()
log.exception('Disconnected from voice... Reconnecting in %.2fs.', retry) log.exception('Disconnected from voice... Reconnecting in %.2fs.', retry)
self._connected.clear() self._connected.clear()
yield from asyncio.sleep(retry, loop=self.loop) await asyncio.sleep(retry, loop=self.loop)
yield from self.terminate_handshake() await self.terminate_handshake()
try: try:
yield from self.connect(reconnect=True) await self.connect(reconnect=True)
except asyncio.TimeoutError: except asyncio.TimeoutError:
# at this point we've retried 5 times... let's continue the loop. # at this point we've retried 5 times... let's continue the loop.
log.warning('Could not connect to voice... Retrying...') log.warning('Could not connect to voice... Retrying...')
continue continue
@asyncio.coroutine async def disconnect(self, *, force=False):
def disconnect(self, *, force=False):
"""|coro| """|coro|
Disconnects this voice client from voice. Disconnects this voice client from voice.
@ -266,15 +260,14 @@ class VoiceClient:
try: try:
if self.ws: if self.ws:
yield from self.ws.close() await self.ws.close()
yield from self.terminate_handshake(remove=True) await self.terminate_handshake(remove=True)
finally: finally:
if self.socket: if self.socket:
self.socket.close() self.socket.close()
@asyncio.coroutine async def move_to(self, channel):
def move_to(self, channel):
"""|coro| """|coro|
Moves you to a different voice channel. Moves you to a different voice channel.
@ -285,7 +278,7 @@ class VoiceClient:
The channel to move to. Must be a voice channel. The channel to move to. Must be a voice channel.
""" """
guild_id, _ = self.channel._get_voice_state_pair() guild_id, _ = self.channel._get_voice_state_pair()
yield from self.main_ws.voice_state(guild_id, channel.id) await self.main_ws.voice_state(guild_id, channel.id)
def is_connected(self): def is_connected(self):
""":class:`bool`: Indicates if the voice client is connected to voice.""" """:class:`bool`: Indicates if the voice client is connected to voice."""

21
discord/webhook.py
View File

@ -135,8 +135,7 @@ class AsyncWebhookAdapter(WebhookAdapter):
self.session = session self.session = session
self.loop = session.loop self.loop = session.loop
@asyncio.coroutine async def request(self, verb, url, payload=None, multipart=None):
def request(self, verb, url, payload=None, multipart=None):
headers = {} headers = {}
data = None data = None
if payload: if payload:
@ -152,9 +151,8 @@ class AsyncWebhookAdapter(WebhookAdapter):
data.add_field(key, value) data.add_field(key, value)
for tries in range(5): for tries in range(5):
r = yield from self.session.request(verb, url, headers=headers, data=data) async with self.session.request(verb, url, headers=headers, data=data) as r:
try: data = await r.text(encoding='utf-8')
data = yield from r.text(encoding='utf-8')
if r.headers['Content-Type'] == 'application/json': if r.headers['Content-Type'] == 'application/json':
data = json.loads(data) data = json.loads(data)
@ -162,7 +160,7 @@ class AsyncWebhookAdapter(WebhookAdapter):
remaining = r.headers.get('X-Ratelimit-Remaining') remaining = r.headers.get('X-Ratelimit-Remaining')
if remaining == '0' and r.status != 429: if remaining == '0' and r.status != 429:
delta = utils._parse_ratelimit_header(r) delta = utils._parse_ratelimit_header(r)
yield from asyncio.sleep(delta, loop=self.loop) await asyncio.sleep(delta, loop=self.loop)
if 300 > r.status >= 200: if 300 > r.status >= 200:
return data return data
@ -170,11 +168,11 @@ class AsyncWebhookAdapter(WebhookAdapter):
# we are being rate limited # we are being rate limited
if r.status == 429: if r.status == 429:
retry_after = data['retry_after'] / 1000.0 retry_after = data['retry_after'] / 1000.0
yield from asyncio.sleep(retry_after, loop=self.loop) await asyncio.sleep(retry_after, loop=self.loop)
continue continue
if r.status in (500, 502): if r.status in (500, 502):
yield from asyncio.sleep(1 + tries * 2, loop=self.loop) await asyncio.sleep(1 + tries * 2, loop=self.loop)
continue continue
if r.status == 403: if r.status == 403:
@ -183,12 +181,9 @@ class AsyncWebhookAdapter(WebhookAdapter):
raise NotFound(r, data) raise NotFound(r, data)
else: else:
raise HTTPException(r, data) raise HTTPException(r, data)
finally:
yield from r.release()
@asyncio.coroutine async def handle_execution_response(self, response, *, wait):
def handle_execution_response(self, response, *, wait): data = await response
data = yield from response
if not wait: if not wait:
return data return data

26
docs/api.rst
View File

@ -93,17 +93,8 @@ to handle it, which defaults to print a traceback and ignoring the exception.
.. warning:: .. warning::
All the events must be a |corourl|_. If they aren't, then you might get unexpected All the events must be a |corourl|_. If they aren't, then you might get unexpected
errors. In order to turn a function into a coroutine they must either be ``async def`` errors. In order to turn a function into a coroutine they must be ``async def``
functions or in 3.4 decorated with :func:`asyncio.coroutine`. functions.
The following two functions are examples of coroutine functions: ::
async def on_ready():
pass
@asyncio.coroutine
def on_ready():
pass
.. function:: on_connect() .. function:: on_connect()
@ -1306,22 +1297,11 @@ Some API functions return an "async iterator". An async iterator is something th
capable of being used in an `async for <https://docs.python.org/3/reference/compound_stmts.html#the-async-for-statement>`_ capable of being used in an `async for <https://docs.python.org/3/reference/compound_stmts.html#the-async-for-statement>`_
statement. statement.
These async iterators can be used as follows in 3.5 or higher: :: These async iterators can be used as follows: ::
async for elem in channel.history(): async for elem in channel.history():
# do stuff with elem here # do stuff with elem here
If you are using 3.4 however, you will have to use the more verbose way: ::
iterator = channel.history() # or whatever returns an async iterator
while True:
try:
item = yield from iterator.next()
except discord.NoMoreItems:
break
# do stuff with item here
Certain utilities make working with async iterators easier, detailed below. Certain utilities make working with async iterators easier, detailed below.
.. class:: AsyncIterator .. class:: AsyncIterator

26
docs/faq.rst
View File

@ -15,27 +15,6 @@ Coroutines
Questions regarding coroutines and asyncio belong here. Questions regarding coroutines and asyncio belong here.
I get a SyntaxError around the word ``async``\! What should I do?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
This :exc:`SyntaxError` happens because you're using a Python version lower than 3.5. Python 3.4 uses ``@asyncio.coroutine`` and
``yield from`` instead of ``async def`` and ``await``.
Thus you must do the following instead: ::
async def foo():
await bar()
# into
@asyncio.coroutine
def foo():
yield from bar()
Don't forget to ``import asyncio`` on the top of your files.
**It is heavily recommended that you update to Python 3.5 or higher as it simplifies asyncio massively.**
What is a coroutine? What is a coroutine?
~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~
@ -195,11 +174,6 @@ technically in another thread, we must take caution in calling thread-safe opera
us, :mod:`asyncio` comes with a :func:`asyncio.run_coroutine_threadsafe` function that allows us to call us, :mod:`asyncio` comes with a :func:`asyncio.run_coroutine_threadsafe` function that allows us to call
a coroutine from another thread. a coroutine from another thread.
.. warning::
This function is only part of 3.5.1+ and 3.4.4+. If you are not using these Python versions then use
``discord.compat.run_coroutine_threadsafe``.
However, this function returns a :class:`concurrent.Future` and to actually call it we have to fetch its result. Putting all of However, this function returns a :class:`concurrent.Future` and to actually call it we have to fetch its result. Putting all of
this together we can do the following: :: this together we can do the following: ::

6
docs/intro.rst
View File

@ -11,9 +11,9 @@ in creating applications that utilise the Discord API.
Prerequisites Prerequisites
--------------- ---------------
discord.py works with Python 3.4.2 or higher. Support for earlier versions of Python discord.py works with Python 3.5.2 or higher. Support for earlier versions of Python
is not provided. Python 2.7 or lower is not supported. Python 3.3 is not supported is not provided. Python 2.7 or lower is not supported. Python 3.4 or lower is not supported
due to one of the dependencies (``aiohttp``) not supporting Python 3.3. due to one of the dependencies (``aiohttp``) not supporting Python 3.4.
.. _installing: .. _installing:

13
docs/migrating.rst
View File

@ -14,6 +14,13 @@ new library.
Part of the redesign involves making things more easy to use and natural. Things are done on the Part of the redesign involves making things more easy to use and natural. Things are done on the
:ref:`models <discord_api_models>` instead of requiring a :class:`Client` instance to do any work. :ref:`models <discord_api_models>` instead of requiring a :class:`Client` instance to do any work.
Python Version Change
-----------------------
In order to make development easier and also to allow for our dependencies to upgrade to allow usage of 3.7 or higher,
the library had to remove support for Python versions lower than 3.5.2, which essentially means that **support for Python 3.4
is dropped**.
Major Model Changes Major Model Changes
--------------------- ---------------------
@ -441,14 +448,14 @@ Prior to v1.0, certain functions like ``Client.logs_from`` would return a differ
In v1.0, this change has been reverted and will now return a singular type meeting an abstract concept called In v1.0, this change has been reverted and will now return a singular type meeting an abstract concept called
:class:`AsyncIterator`. :class:`AsyncIterator`.
This allows you to iterate over it like normal in Python 3.5+: :: This allows you to iterate over it like normal: ::
async for message in channel.history(): async for message in channel.history():
print(message) print(message)
Or turn it into a list for either Python 3.4 or 3.5+: :: Or turn it into a list: ::
messages = await channel.history().flatten() # use yield from for 3.4! messages = await channel.history().flatten()
for message in messages: for message in messages:
print(message) print(message)

4
requirements.txt
View File

@ -1,2 +1,2 @@
aiohttp>=2.0.0,<2.3.0 aiohttp>=3.3.0,<3.4.0
websockets>=3.0,<4.0 websockets>=5.0,<6.0

1
setup.py
View File

@ -63,7 +63,6 @@ setup(name='discord.py',
'Intended Audience :: Developers', 'Intended Audience :: Developers',
'Natural Language :: English', 'Natural Language :: English',
'Operating System :: OS Independent', 'Operating System :: OS Independent',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.6',
'Topic :: Internet', 'Topic :: Internet',

Write Preview
Loading…
Cancel
Save