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)