mirrors/discord.py
1
0
Fork 0
mirror of https://github.com/Rapptz/discord.py.git synced 2025-06-03 18:42:43 +00:00
Code Issues Projects Releases Wiki Activity

Fix all deprecation warnings for 3.8

Browse Source
This commit is contained in:
Rapptz 2019-11-20 02:30:19 -05:00
parent 924398c1ac
commit a6f61dcbde
9 changed files with 43 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
discord/client.py
View File

@ -223,7 +223,7 @@ class Client:
self._connection.shard_count = self.shard_count
self._closed = False
self._ready = asyncio.Event(loop=self.loop)
self._ready = asyncio.Event()
self._connection._get_websocket = lambda g: self.ws
if VoiceClient.warn_nacl:
@ -457,7 +457,7 @@ class Client:
async def _connect(self):
coro = DiscordWebSocket.from_client(self, shard_id=self.shard_id)
self.ws = await asyncio.wait_for(coro, timeout=180.0, loop=self.loop)
self.ws = await asyncio.wait_for(coro, timeout=180.0)
while True:
try:
await self.ws.poll_event()
@ -466,7 +466,7 @@ class Client:
self.dispatch('disconnect')
coro = DiscordWebSocket.from_client(self, shard_id=self.shard_id, session=self.ws.session_id,
sequence=self.ws.sequence, resume=True)
self.ws = await asyncio.wait_for(coro, timeout=180.0, loop=self.loop)
self.ws = await asyncio.wait_for(coro, timeout=180.0)
async def connect(self, *, reconnect=True):
"""|coro|
@ -528,7 +528,7 @@ class Client:
retry = backoff.delay()
log.exception("Attempting a reconnect in %.2fs", retry)
await asyncio.sleep(retry, loop=self.loop)
await asyncio.sleep(retry)
async def close(self):
"""|coro|
@ -866,7 +866,7 @@ class Client:
self._listeners[ev] = listeners
listeners.append((future, check))
return asyncio.wait_for(future, timeout, loop=self.loop)
return asyncio.wait_for(future, timeout)
# event registration

10
discord/http.py
View File

@ -91,7 +91,7 @@ class HTTPClient:
self.connector = connector
self.__session = None # filled in static_login
self._locks = weakref.WeakValueDictionary()
self._global_over = asyncio.Event(loop=self.loop)
self._global_over = asyncio.Event()
self._global_over.set()
self.token = None
self.bot_token = False
@ -104,7 +104,7 @@ class HTTPClient:
def recreate(self):
if self.__session.closed:
self.__session = aiohttp.ClientSession(connector=self.connector, loop=self.loop)
self.__session = aiohttp.ClientSession(connector=self.connector)
async def request(self, route, *, files=None, **kwargs):
bucket = route.bucket
@ -195,7 +195,7 @@ class HTTPClient:
log.warning('Global rate limit has been hit. Retrying in %.2f seconds.', retry_after)
self._global_over.clear()
await asyncio.sleep(retry_after, loop=self.loop)
await asyncio.sleep(retry_after)
log.debug('Done sleeping for the rate limit. Retrying...')
# release the global lock now that the
@ -208,7 +208,7 @@ class HTTPClient:
# we've received a 500 or 502, unconditional retry
if r.status in {500, 502}:
await asyncio.sleep(1 + tries * 2, loop=self.loop)
await asyncio.sleep(1 + tries * 2)
continue
# the usual error cases
@ -248,7 +248,7 @@ class HTTPClient:
async def static_login(self, token, *, bot):
# Necessary to get aiohttp to stop complaining about session creation
self.__session = aiohttp.ClientSession(connector=self.connector, loop=self.loop)
self.__session = aiohttp.ClientSession(connector=self.connector)
old_token, old_bot = self.token, self.bot_token
self._token(token, bot=bot)

10
discord/iterators.py
View File

@ -132,7 +132,7 @@ class ReactionIterator(_AsyncIterator):
self.emoji = emoji
self.guild = message.guild
self.channel_id = message.channel.id
self.users = asyncio.Queue(loop=state.loop)
self.users = asyncio.Queue()
async def next(self):
if self.users.empty():
@ -228,7 +228,7 @@ class HistoryIterator(_AsyncIterator):
self.state = self.messageable._state
self.logs_from = self.state.http.logs_from
self.messages = asyncio.Queue(loop=self.state.loop)
self.messages = asyncio.Queue()
if self.around:
if self.limit is None:
@ -378,7 +378,7 @@ class AuditLogIterator(_AsyncIterator):
self._filter = None # entry dict -> bool
self.entries = asyncio.Queue(loop=self.loop)
self.entries = asyncio.Queue()
if self.reverse:
@ -503,7 +503,7 @@ class GuildIterator(_AsyncIterator):
self.state = self.bot._connection
self.get_guilds = self.bot.http.get_guilds
self.guilds = asyncio.Queue(loop=self.state.loop)
self.guilds = asyncio.Queue()
if self.before and self.after:
self._retrieve_guilds = self._retrieve_guilds_before_strategy
@ -600,7 +600,7 @@ class MemberIterator(_AsyncIterator):
self.state = self.guild._state
self.get_members = self.state.http.get_members
self.members = asyncio.Queue(loop=self.state.loop)
self.members = asyncio.Queue()
async def next(self):
if self.members.empty():

2
discord/message.py
View File

@ -707,7 +707,7 @@ class Message:
"""
if delay is not None:
async def delete():
await asyncio.sleep(delay, loop=self._state.loop)
await asyncio.sleep(delay)
try:
await self._state.http.delete_message(self.channel.id, self.id)
except HTTPException:

22
discord/shard.py
View File

@ -47,7 +47,7 @@ class Shard:
self.loop = self._client.loop
self._current = self.loop.create_future()
self._current.set_result(None) # we just need an already done future
self._pending = asyncio.Event(loop=self.loop)
self._pending = asyncio.Event()
self._pending_task = None
@property
@ -81,7 +81,7 @@ class Shard:
coro = DiscordWebSocket.from_client(self._client, resume=True, shard_id=self.id,
session=self.ws.session_id, sequence=self.ws.sequence)
self._dispatch('disconnect')
self.ws = await asyncio.wait_for(coro, timeout=180.0, loop=self.loop)
self.ws = await asyncio.wait_for(coro, timeout=180.0)
def get_future(self):
if self._current.done():
@ -213,10 +213,10 @@ class AutoShardedClient(Client):
async def launch_shard(self, gateway, shard_id):
try:
coro = websockets.connect(gateway, loop=self.loop, klass=DiscordWebSocket, compression=None)
ws = await asyncio.wait_for(coro, loop=self.loop, timeout=180.0)
ws = await asyncio.wait_for(coro, timeout=180.0)
except Exception:
log.info('Failed to connect for shard_id: %s. Retrying...', shard_id)
await asyncio.sleep(5.0, loop=self.loop)
await asyncio.sleep(5.0)
return await self.launch_shard(gateway, shard_id)
ws.token = self.http.token
@ -230,17 +230,17 @@ class AutoShardedClient(Client):
try:
# OP HELLO
await asyncio.wait_for(ws.poll_event(), loop=self.loop, timeout=180.0)
await asyncio.wait_for(ws.identify(), loop=self.loop, timeout=180.0)
await asyncio.wait_for(ws.poll_event(), timeout=180.0)
await asyncio.wait_for(ws.identify(), timeout=180.0)
except asyncio.TimeoutError:
log.info('Timed out when connecting for shard_id: %s. Retrying...', shard_id)
await asyncio.sleep(5.0, loop=self.loop)
await asyncio.sleep(5.0)
return await self.launch_shard(gateway, shard_id)
# keep reading the shard while others connect
self.shards[shard_id] = ret = Shard(ws, self)
ret.launch_pending_reads()
await asyncio.sleep(5.0, loop=self.loop)
await asyncio.sleep(5.0)
async def launch_shards(self):
if self.shard_count is None:
@ -261,14 +261,14 @@ class AutoShardedClient(Client):
shards_to_wait_for.append(shard.wait())
# wait for all pending tasks to finish
await 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)
async def _connect(self):
await self.launch_shards()
while True:
pollers = [shard.get_future() for shard in self.shards.values()]
done, _ = await asyncio.wait(pollers, loop=self.loop, return_when=asyncio.FIRST_COMPLETED)
done, _ = await asyncio.wait(pollers, return_when=asyncio.FIRST_COMPLETED)
for f in done:
# we wanna re-raise to the main Client.connect handler if applicable
f.result()
@ -291,7 +291,7 @@ class AutoShardedClient(Client):
to_close = [shard.ws.close() for shard in self.shards.values()]
if to_close:
await asyncio.wait(to_close, loop=self.loop)
await asyncio.wait(to_close)
await self.http.close()

12
discord/state.py
View File

@ -304,7 +304,7 @@ class ConnectionState:
# wait for the chunks
if chunks:
try:
await utils.sane_wait_for(chunks, timeout=len(chunks) * 30.0, loop=self.loop)
await utils.sane_wait_for(chunks, timeout=len(chunks) * 30.0)
except asyncio.TimeoutError:
log.info('Somehow timed out waiting for chunks.')
@ -323,7 +323,7 @@ class ConnectionState:
try:
# start the query operation
await ws.request_chunks(guild_id, query, limit)
members = await asyncio.wait_for(future, timeout=5.0, loop=self.loop)
members = await asyncio.wait_for(future, timeout=5.0)
if cache:
for member in members:
@ -344,7 +344,7 @@ class ConnectionState:
# this snippet of code is basically waiting 2 seconds
# until the last GUILD_CREATE was sent
launch.set()
await asyncio.sleep(2, loop=self.loop)
await asyncio.sleep(2)
guilds = next(zip(*self._ready_state.guilds), [])
if self._fetch_offline:
@ -694,7 +694,7 @@ class ConnectionState:
await self.chunker(guild)
if chunks:
try:
await utils.sane_wait_for(chunks, timeout=len(chunks), loop=self.loop)
await utils.sane_wait_for(chunks, timeout=len(chunks))
except asyncio.TimeoutError:
log.info('Somehow timed out waiting for chunks.')
@ -1006,7 +1006,7 @@ class AutoShardedConnectionState(ConnectionState):
# wait for the chunks
if chunks:
try:
await utils.sane_wait_for(chunks, timeout=len(chunks) * 30.0, loop=self.loop)
await utils.sane_wait_for(chunks, timeout=len(chunks) * 30.0)
except asyncio.TimeoutError:
log.info('Somehow timed out waiting for chunks.')
@ -1016,7 +1016,7 @@ class AutoShardedConnectionState(ConnectionState):
# this snippet of code is basically waiting 2 seconds
# until the last GUILD_CREATE was sent
launch.set()
await asyncio.sleep(2.0 * self.shard_count, loop=self.loop)
await asyncio.sleep(2.0 * self.shard_count)
if self._fetch_offline:
guilds = sorted(self._ready_state.guilds, key=lambda g: g[0].shard_id)

4
discord/utils.py
View File

@ -327,8 +327,8 @@ async def async_all(gen, *, check=_isawaitable):
return False
return True
async def sane_wait_for(futures, *, timeout, loop):
done, pending = await asyncio.wait(futures, timeout=timeout, return_when=asyncio.ALL_COMPLETED, loop=loop)
async def sane_wait_for(futures, *, timeout):
done, pending = await asyncio.wait(futures, timeout=timeout, return_when=asyncio.ALL_COMPLETED)
if len(pending) != 0:
raise asyncio.TimeoutError()

10
discord/voice_client.py
View File

@ -101,8 +101,8 @@ class VoiceClient:
self._connected = threading.Event()
self._handshaking = False
self._handshake_check = asyncio.Lock(loop=self.loop)
self._handshake_complete = asyncio.Event(loop=self.loop)
self._handshake_check = asyncio.Lock()
self._handshake_complete = asyncio.Event()
self.mode = None
self._connections = 0
@ -149,7 +149,7 @@ class VoiceClient:
await ws.voice_state(guild_id, channel_id)
try:
await asyncio.wait_for(self._handshake_complete.wait(), timeout=self.timeout, loop=self.loop)
await asyncio.wait_for(self._handshake_complete.wait(), timeout=self.timeout)
except asyncio.TimeoutError:
await self.terminate_handshake(remove=True)
raise
@ -225,7 +225,7 @@ class VoiceClient:
except (ConnectionClosed, asyncio.TimeoutError):
if reconnect and _tries < 5:
log.exception('Failed to connect to voice... Retrying...')
await asyncio.sleep(1 + _tries * 2.0, loop=self.loop)
await asyncio.sleep(1 + _tries * 2.0)
await self.terminate_handshake()
await self.connect(reconnect=reconnect, _tries=_tries + 1)
else:
@ -257,7 +257,7 @@ class VoiceClient:
retry = backoff.delay()
log.exception('Disconnected from voice... Reconnecting in %.2fs.', retry)
self._connected.clear()
await asyncio.sleep(retry, loop=self.loop)
await asyncio.sleep(retry)
await self.terminate_handshake()
try:
await self.connect(reconnect=True)

6
discord/webhook.py
View File

@ -201,7 +201,7 @@ class AsyncWebhookAdapter(WebhookAdapter):
remaining = r.headers.get('X-Ratelimit-Remaining')
if remaining == '0' and r.status != 429:
delta = utils._parse_ratelimit_header(r)
await asyncio.sleep(delta, loop=self.loop)
await asyncio.sleep(delta)
if 300 > r.status >= 200:
return response
@ -209,11 +209,11 @@ class AsyncWebhookAdapter(WebhookAdapter):
# we are being rate limited
if r.status == 429:
retry_after = response['retry_after'] / 1000.0
await asyncio.sleep(retry_after, loop=self.loop)
await asyncio.sleep(retry_after)
continue
if r.status in (500, 502):
await asyncio.sleep(1 + tries * 2, loop=self.loop)
await asyncio.sleep(1 + tries * 2)
continue
if r.status == 403: