async def test_ratelimit(client, message):
'''
A fast ratelimit test for next patch to validate anything.
'''
guild = message.guild
if guild is None:
return
proxy = client.get_ratelimits_of(RATELIMIT_GROUPS.role_edit, limiter=guild)
if (not proxy.is_alive()) or (not proxy.has_size_set()):
if not guild.cached_permissions_for(client).can_manage_roles:
await client.message_create(
message.channel, 'Current state unknown -> No permissions.')
return
roles = message.guild.role_list
if len(roles) == 1:
await client.message_create(
message.channel, 'Current state unknown -> Need more roles.')
return
role = roles[-2]
if not client.has_higher_role_than(role):
await client.message_create(
message.channel, 'Current state unknown -> No lower role')
return
proxy.keep_alive = True
task = client.loop.create_task(client.role_edit(role,
color=role.color))
future_or_timeout(task, 2.5)
try:
await task
except TimeoutError:
pass
if not proxy.has_info():
await client.message_create(
message.channel, 'Current state unknown -> Need more roles.')
return
next_reset = proxy.next_reset_after
used = proxy.used_count
free = proxy.free_count
proxy = None # allows GC, not needed to turn keep alive to turn off either
await client.message_create(
message.channel,
f'Next reset after : {next_reset!r}, used : {used!r}, free : {free!r}.'
)
return
def __new__(cls, client, event, map_name, length, possibilities):
self = object.__new__(cls)
self.client = client
self.channel = event.channel
self.users = [event.user]
self.map_name = map_name
self.length = length
self.possibilities = possibilities
self.cancelled = False
self.waiter = waiter = Future(KOKORO)
future_or_timeout(waiter, 300.0)
Task(self.start_waiting(), KOKORO)
ACTIVE_GAMES[event.channel.id] = self
return self
async def add_(
client,
event,
link: (str, 'Link to the sticker to add'),
name: (str, 'The sticker\'s name.'),
emoji_value: (str, 'Emoji representation of the sticker.', 'emoji'),
description: (str, 'Description for the sticker.') = None,
):
"""Adds a sticker to the guild. (You must have emoji-council role)"""
if not event.user.has_role(ROLE__NEKO_DUNGEON__EMOJI_MANAGER):
abort(
f'You must have {ROLE__NEKO_DUNGEON__EMOJI_MANAGER:m} role to invoke this command.'
)
name_length = len(name)
if (name_length < 2) or (name_length > 32):
abort(
f'Sticker name\'s length can be in range [2:32], got {name_length!r}, {name!r}.'
)
emoji = parse_emoji(emoji_value)
if emoji is None:
abort(f'{emoji_value} cannot be interpreted as an emoji.')
if emoji.is_custom_emoji():
abort(f'Only unicode can be used, got {emoji:e}')
if (description is not None):
description_length = len(description)
if (description_length > 100):
abort(
f'Sticker description\'s length can be in range [0:100], got {description_length!r}, '
f'{description!r}.')
if not is_url(link):
abort(f'The given link is invalid, got {link!r}.')
yield
while True:
try:
async with client.http.get(link) as response:
response_status = response.status
if response_status != 200:
response_reason = response.reason
if response_reason is None:
error_message = f'Request failed: {response_status}'
else:
error_message = f'Request failed: {response_status} {response_reason}'
break
future = Task(response.read(), KOKORO)
future_or_timeout(future, 15.0)
image = await future
except ConnectionError as err:
error_message = f'Getting image failed: {err.args[0]}'
break
except TimeoutError as err:
error_message = 'Timeout (15s) occurred meanwhile trying to read the response.'
break
except OSError as err:
error_message = f'Getting image failed: {err.strerror}'
break
try:
sticker = await client.sticker_guild_create(
event.guild, name, image, emoji, description)
except ConnectionError as err:
return
except DiscordException as err:
error_message = repr(err)
break
except ValueError as err:
error_message = err.args[0]
break
yield 'The sticker has been successfully created'
await client.message_create(event.channel, sticker=sticker)
return
yield error_message
async def start(self):
client = self.client
player1 = self.player1
player2 = self.player2
player1.other = player2
player2.other = player1
try:
#creating missing channel
player1.channel = await client.channel_private_create(player1.user)
#adding channels to the event to notify us
client.events.message_create.append(player1.channel, self)
client.events.message_create.append(player2.channel, self)
#game starts
self.future = FutureWM(KOKORO, 2)
future_or_timeout(self.future, 300.)
#startup
self.process = self.process_state_0
Task(player1.set_state_0(), KOKORO)
Task(player2.set_state_0(), KOKORO)
try:
await self.future
except TimeoutError:
if not self.future._result:
text1 = text2 ='The time is over, both players timed out'
elif player1 in self.future._result:
text1 = 'The other player timed out'
text2 = 'You timed out'
else:
text1 = 'You timed out'
text2 = 'The other player timed out'
Task(client.message_create(player1.channel, text1), KOKORO)
Task(client.message_create(player2.channel, text2), KOKORO)
return
self.process = self.process_state_1
player1.ships_left[:] = user_profile.ships
player2.ships_left[:] = user_profile.ships
if randint(0, 1):
self.actual = player1
else:
self.actual = player2
await self.actual.set_state_1(True)
await self.actual.other.set_state_1(False)
while self.process is not None:
self.future = Future(KOKORO)
future_or_timeout(self.future, 300.)
try:
result = await self.future
except TimeoutError:
await self.actual.other.set_state_2(True, 'Your opponent timed out!')
await self.actual.set_state_2(False, 'You timed out!')
return
if result:
self.actual = self.actual.other
except BaseException as err:
if isinstance(err, ConnectionError):
return
if isinstance(err, DiscordException) and err.code == ERROR_CODES.invalid_message_send_user:
return
await client.events.error(client, f'{self!r}.start', err)
finally:
self.cancel()
async def runner(self):
client = self.client
channel = self.channel
answers = self.answers
buffer = ReuBytesIO()
embed = Embed(color=KANAKO_COLOR).add_image(
'attachment://guess_me.png').add_footer('')
time_till_notify = CIRCLE_TIME - 10
for index, (question, answer) in enumerate(self.map, 1):
embed.footer.text = f'{index} / {len(self.map)}'
if self.possibilities:
self.options = self.generate_options(answer)
embed.description = '\n'.join([
f'**{index}.: {value}**'
for index, value in enumerate(self.options, 1)
])
try:
await client.message_create(channel,
embed=embed,
file=('guess_me.png',
draw(buffer, question)))
except BaseException as err:
self.cancel()
if isinstance(err, ConnectionError):
return
if isinstance(err, DiscordException):
if err.code in (
ERROR_CODES.unknown_channel, # channel deleted
ERROR_CODES.missing_access, # client removed
ERROR_CODES.
missing_permissions, # permissions changed meanwhile
):
return
await client.events.error(client,
f'{self.__class__.__name__}.runner',
err)
return
circle_start = LOOP_TIME()
self.waiter = waiter = Future(KOKORO)
future_or_timeout(waiter, time_till_notify)
try:
await waiter
except TimeoutError:
Task(self.notify_late_users(), KOKORO)
self.waiter = waiter = Future(KOKORO)
future_or_timeout(waiter, 10)
try:
await waiter
except TimeoutError:
leavers = []
users = self.users
for index in reversed(range(len(users))):
user = users[index]
if user in answers:
continue
leavers.append(user)
del users[index]
for element in self.history:
del element.answers[index]
if len(self.users) == 0:
self.cancel()
embed = Embed(
None,
'No-one gave answer in time, cancelling the game.',
color=KANAKO_COLOR)
else:
embed = Embed(None,
'\n'.join([
'Users timed out:',
*(user.full_name for user in leavers)
]),
color=KANAKO_COLOR)
try:
await client.message_create(channel, embed=embed)
except BaseException as err:
self.cancel()
if isinstance(err, ConnectionError):
return
if isinstance(err, DiscordException):
if err.code in (
ERROR_CODES.
unknown_channel, # channel deleted
ERROR_CODES.
missing_access, # client removed
ERROR_CODES.
missing_permissions, # permissions changed meanwhile
):
return
await client.events.error(
client, f'{self.__class__.__name__}.runner', err)
return
if self.cancelled:
return
self.waiter = None
element = HistoryElement()
element.question = question
element.answer = answer
element.options = self.options
element.answers = [(value[0], value[1] - circle_start)
for value in (answers[user.id]
for user in self.users)]
self.history.append(element)
answers.clear()
embed.title = f'Last answer: {answer}'
self.cancel()
embed = Embed(embed.title, color=KANAKO_COLOR)
try:
await client.message_create(channel, embed=embed)
except BaseException as err:
self.cancel()
if isinstance(err, ConnectionError):
return
if isinstance(err, DiscordException):
if err.code in (
ERROR_CODES.unknown_channel, # channel deleted
ERROR_CODES.missing_access, # client removed
ERROR_CODES.
missing_permissions, # permissions changed meanwhile
):
return
await client.events.error(client,
f'{self.__class__.__name__}.runner', err)
return
await GameStatistics(self)