def pagination_for_other_libs():
if request.method != 'POST': return 401
data = request.json
pages = []
part = []
index = 0
for element in data['lines']:
if index == 60:
pages.append('\n'.join(part))
part.clear()
index = 0
part.append(f'{element}')
index += 1
pages.append('\n'.join(part))
del part
result = []
limit = len(pages)
index = 0
while index < limit:
embed = Embed('Pagination', color='029320', description=pages[index])
index += 1
embed.add_field(f"{index} pages in total", f'page {index}/{limit}')
result.append(embed)
del pages
pdbot.loop.create_task_threadsafe(
Pagination(pdbot, CHANNELS[int(data['channel'])], result))
async def latest_users(event):
"""Shows the new users of the guild."""
date_limit = datetime.now() - timedelta(days=7)
users = []
guild = event.guild
for user in guild.users.values():
# `joined_at` might be set as `None` if the user is a lurker.
# We can ignore lurkers, so use `created_at` which defaults to Discord epoch.
created_at = user.guild_profiles[guild].created_at
if created_at > date_limit:
users.append((created_at, user))
users.sort(reverse=True)
del users[10:]
embed = Embed('Recently joined users')
if users:
for index, (joined_at, user) in enumerate(users, 1):
created_at = user.created_at
embed.add_field(
f'{index}. {user.full_name}',
f'Id: {user.id}\n'
f'Mention: {user.mention}\n'
'\n'
f'Joined : {joined_at:{DATETIME_FORMAT_CODE}} [*{elapsed_time(joined_at)} ago*]\n'
f'Created : {created_at:{DATETIME_FORMAT_CODE}} [*{elapsed_time(created_at)} ago*]\n'
f'Difference : {elapsed_time(relativedelta(created_at, joined_at))}',
)
else:
embed.description = '*none*'
return InteractionResponse(embed=embed, allowed_mentions=None)
async def command(client, message, content):
card = get_card(content)
if card is None:
await client.message_create(message.channel, embed=Embed(None, '*Nothing found.*', CHESUTO_COLOR))
return
message = await client.message_create(message.channel, embed = Embed(
None, f'Are you sure, to remove {card.name!r}?', CHESUTO_COLOR,))
for emoji in REMOVE_CARD_EMOJIS:
await client.reaction_add(message,emoji)
try:
event = await wait_for_reaction(client, message, ADD_IMAGE_CHECKER, 40.)
except TimeoutError:
emoji = REMOVE_CARD_CANCEL
else:
emoji = event.emoji
await client.message_delete(message)
if emoji is REMOVE_CARD_CANCEL:
content = 'Cancelled.'
else:
card._delete()
await Card.dump_cards(KOKORO)
content = f'{card.name!r} successfully removed.'
message = await client.message_create(message.channel,
embed = Embed(description=content, color=CHESUTO_COLOR))
await sleep(30., KOKORO)
await client.message_delete(message)
return
async def google(client, event, query: (str, 'query')):
yield
success, result_or_error_message = await search(query)
if not success:
yield result_or_error_message
pages = []
limit = len(result_or_error_message)
if limit:
index = 0
while index < limit:
result = result_or_error_message[index]
index += 1
page_embed = Embed(result.title, result.description, Color.random(), result.url). \
add_footer(f'Page {index}/{limit}', client.avatar_url)
image_url = result.image_url
if (image_url is not None):
page_embed.add_thumbnail(image_url)
pages.append(page_embed)
else:
embed = Embed(query, '*no result*')
pages.append(embed)
await Pagination(client, event, pages)
async def answer_booru(client, channel, content, url_base):
if content:
content = content.split()
content.insert(0, url_base)
url = '+'.join(content)
else:
url = url_base
async with client.http.get(url) as response:
result = await response.read()
if response.status != 200:
await client.message_create(channel,
embed=Embed('Booru is unavailable',
color=BOORU_COLOR))
return
soup = BeautifulSoup(result, 'lxml')
urls = [post['file_url'] for post in soup.find_all('post')]
if urls:
await ShuffledShelter(client, channel, urls, True)
return
await client.message_create(
channel,
embed=Embed(
f'Sowwy, but {client.name} could not find anything what matches these tags..',
color=BOORU_COLOR))
async def list_docs(client, message, search_for: str = None):
if (search_for is None) or (len(search_for) < 4):
await list_docs_help(client, message)
return
paths = search_paths(search_for)
if not paths:
embeds = [
Embed(f'No search result for: `{search_for}`', color=WIKI_COLOR)
]
await Pagination(client, message.channel, embeds)
return
results = []
for path in paths:
name = str(path).replace('_', '\_')
results.append((name, path))
embed = Embed(title=f'Search results for `{search_for}`', color=WIKI_COLOR)
await ChooseMenu(client,
message.channel,
results,
list_docs_selecter,
embed=embed,
prefix='@')
async def list_docs_selecter(client, channel, message, name, path):
unit = MAPPED_OBJECTS[path]
lines = []
for name in unit.references:
name = name.replace('_', '\_')
lines.append('**ยค** ' + name)
chunks = chunkify(lines)
title_parts = []
path = unit.path - unit.name
if path:
title_parts.append('*')
title_parts.append(str(path))
title_parts.append('*.')
title_parts.append('**')
title_parts.append(unit.name)
title_parts.append('**')
title = ''.join(title_parts).replace('_', '\_')
if chunks is None:
embeds = [
Embed(title, '*The object has no attributes*', color=WIKI_COLOR)
]
else:
embeds = [Embed(title, chunk, color=WIKI_COLOR) for chunk in chunks]
await Pagination(client, channel, embeds, message=message)
async def answer_booru(client, event, content, url_base, banned):
yield
url = make_url(url_base, set(content.split()), None, banned)
async with client.http.get(url) as response:
result = await response.read()
if response.status != 200:
yield Embed('Error desu.', 'Booru is unavailable', color=BOORU_COLOR)
return
soup = BeautifulSoup(result, 'lxml')
urls = [post['file_url'] for post in soup.find_all('post')]
if not urls:
yield Embed('Error desu.', f'Could not find anything what matches these tags..', color=BOORU_COLOR)
return
guild = event.guild
if (guild is None) or (client not in guild.clients):
image_url = choose(urls)
yield Embed(DEFAULT_TITLE, color=BOORU_COLOR, url=image_url).add_image(image_url)
return
if not urls:
yield Embed('No result')
return
await ShuffledShelter(client, event, urls, True)
return
async def slash_edit(client, event):
"""Editing slashes, bakana!"""
yield InteractionResponse(embed=Embed('Choose your poison.'))
await sleep(2.0, KOKORO)
yield InteractionResponse(embed=Embed('Choose your cake.'), message=None)
await sleep(2.0, KOKORO)
yield InteractionResponse(embed=Embed('Choose your neko.'), message=None)
async def latest_users(
client,
event,
):
"""Shows the new users of the guild."""
if not event.user.has_role(ROLE__NEKO_DUNGEON__MODERATOR):
abort('Hacker trying to hack Discord.')
date_limit = datetime.now() - timedelta(days=7)
users = []
guild = event.guild
for user in guild.users.values():
# Use created at and not `joined_at`, we can ignore lurkers.
created_at = user.guild_profiles[guild].created_at
if created_at > date_limit:
users.append((created_at, user))
users.sort(reverse=True)
del users[10:]
embed = Embed('Recently joined users')
if users:
for index, (joined_at, user) in enumerate(users, 1):
add_user_field(embed, index, joined_at, user)
else:
embed.description = '*none*'
return InteractionResponse(embed=embed, allowed_mentions=None)
async def get_image_embed(client, tags, name, color):
image_urls = IMAGE_URL_CACHE.get(tags, None)
if image_urls is None:
# Request image information
async with client.http.get(SAFE_BOORU + tags) as response:
if response.status != 200:
return Embed('Error', 'Safe-booru unavailable', color=color)
result = await response.read()
# Read response and get image urls.
soup = BeautifulSoup(result, 'lxml')
image_urls = [post['file_url'] for post in soup.find_all('post')]
if not image_urls:
return Embed('Error',
'No images found.\nPlease try again later.',
color=color)
# If we received image urls, cache them
IMAGE_URL_CACHE[tags] = image_urls
image_url = choice(image_urls)
return Embed(name, color=color, url=image_url).add_image(image_url)
async def docs_selecter(client, channel, message, name, path):
unit = MAPPED_OBJECTS[path]
chunks = unit.embed_sized
title_parts = []
path = unit.path - unit.name
if path:
title_parts.append('*')
title_parts.append(str(path))
title_parts.append('*.')
title_parts.append('**')
title_parts.append(unit.name)
title_parts.append('**')
title = ''.join(title_parts).replace('_', '\_')
if chunks is None:
embeds = [
Embed(title,
'*The given object has no description included*',
color=WIKI_COLOR)
]
else:
embeds = [Embed(title, chunk, color=WIKI_COLOR) for chunk in chunks]
await Pagination(client, channel, embeds, message=message)
async def show_auto_react_roles(client, message):
guild = message.guild
if guild is None:
return
managers = client.events.guild_delete.get_waiters(guild,
AutoReactRoleManager,
by_type=True,
is_method=True)
embed = Embed(f'Auto role managers for: {guild}',
color=AUTO_REACT_ROLE_COLOR)
if not managers:
embed.description = '*none*'
await Pagination(client, message.channel, [embed])
return
results = []
for manager in managers:
message_ = manager.message
title = f'{message_.channel:m} {message.id}'
results.append((title, manager), )
await ChooseMenu(client,
message.channel,
results,
select_auto_react_role_gui,
embed=embed,
prefix='ยค')
async def list_of_cogs(client, message, content):
cogs = []
for i in os.listdir(os.path.join('cogs', 'hata')):
if i.endswith('.py'):
cogs.append(i[:-3])
pages = []
part = []
index = 0
for element in cogs:
if index == 15:
pages.append('\n'.join(part))
part.clear()
index = 0
part.append(f'**>>** {element}')
index += 1
pages.append('\n'.join(part))
del part
result = []
limit = len(pages)
index = 0
while index < limit:
embed = Embed('Cogs:', color='029320', description=pages[index])
index += 1
embed.add_field('Cog-list', f'page {index} out of {limit}')
result.append(embed)
del pages
await Pagination(client, message.channel, result)
async def retardify(client, event,
text : ('str', 'Some text to retardify.'),
):
"""Translates the given text to retard language."""
if text:
description_parts = []
chance = 0.5
for char in text:
if random() > chance:
if chance > 0.5:
chance = 1.0-(chance*0.5)
else:
chance = 0.5
char = char.lower()
else:
if chance <= 0.5:
chance = chance*0.5
else:
chance = 0.5
char = char.upper()
description_parts.append(char)
description = ''.join(description_parts)
else:
description = 'Nothing to retardify.'
embed = Embed(description=description)
user = event.user
embed.add_author(user.avatar_url, user.full_name)
await client.interaction_response_message_create(event, embed=embed, allowed_mentions=None)
async def rule(client, message, rule_number):
"""
Gives you the rule that you want
"""
the_rule = SERVER_RULES.get(rule_number)
embed = Embed(color=BLUE)
embed.add_field(f'RULE {rule_number}', the_rule or "Does not Exist")
return embed
def createpage0(self, guild):
embed = Embed(f'Roles of **{guild.name}**:',
'\n'.join([role.mention for role in self.roles]),
color=(guild.icon_hash & 0xFFFFFF if
(guild.icon_type is ICON_TYPE_NONE) else
(guild.id >> 22) & 0xFFFFFF))
embed.add_footer(f'Page 1 / {len(self.cache)}')
self.cache[0] = embed
async def add_emoji(client,
event,
emoji: ('str', 'The emoji to add.'),
name: ('str',
'Custom name to add the emoji with.') = None):
"""Adds an emoji to the guild."""
if not client.is_owner(event.user):
abort('Owner only!')
emoji = parse_emoji(emoji)
if emoji is None:
abort('That\'s not an emoji.')
if emoji.is_unicode_emoji():
abort('Cannot add unicode emojis')
if name is None:
name = emoji.name
else:
if len(name) > 32:
abort('Name length can be max 32.')
embed = Embed('Are you sure to add this emoji?').add_field(
'Name:', name).add_image(emoji.url)
message = yield InteractionResponse(embed=embed,
components=ADD_EMOJI_COMPONENTS)
try:
component_interaction = await wait_for_component_interaction(
message,
timeout=300.0,
check=functools.partial(check_is_user_same, event.user))
except TimeoutError:
component_interaction = None
cancelled = True
else:
if component_interaction.interaction == ADD_EMOJI_BUTTON_CANCEL:
cancelled = True
else:
cancelled = False
if cancelled:
embed.title = 'Adding emoji has been cancelled.'
else:
embed.title = 'Emoji has been added!'
async with client.http.get(emoji.url) as response:
emoji_data = await response.read()
await client.emoji_create(event.guild, name, emoji_data)
yield InteractionResponse(embed=embed,
components=None,
message=message,
event=component_interaction)
def create_embed(guild, name, url, hash_value):
if url is None:
color = (guild.id >> 22) & 0xFFFFFF
embed = Embed(f'{guild.name} has no {name}', color=color)
else:
color = hash_value & 0xFFFFFF
embed = Embed(f'{guild.name}\'s {name}', color=color,
url=url).add_image(url)
return embed
async def avatar(client, message, user : Converter('user', flags=ConverterFlag.user_default.update_by_keys(everywhere=True), default_code='message.author')):
color = user.avatar&0xffffff
if color==0:
color = user.default_avatar.color
url=user.avatar_url_as(size=4096)
embed=Embed(f'{user:f}\'s avatar', color=color, url=url)
embed.add_image(url)
await client.message_create(message.channel, embed=embed)
async def snake_box(ctx, content, executable, config):
code, is_exception = parse_code_content(content)
if is_exception and (code is None):
await eval_description(ctx)
return
user_id = ctx.author.id
if user_id in ACTIVE_EXECUTORS:
await ctx.send(embed=Embed('You have an eval job queued up', 'Please be patient.', color=SNEKBOX_COLOR))
return
if is_exception:
await ctx.send(embed=Embed('Parsing error', code, color=SNEKBOX_COLOR))
return
with ctx.keep_typing(), EvalUserLock(user_id) as user_lock:
async with EVAL_LOCK:
process = await KOKORO.subprocess_exec(NSJAIL_EXECUTABLE,
'--config', config,
f'--cgroup_mem_max={MEM_MAX}',
'--cgroup_mem_mount', str(CGROUP_MEMORY_PARENT.parent),
'--cgroup_mem_parent', CGROUP_MEMORY_PARENT.name,
'--cgroup_pids_max=1',
'--cgroup_pids_mount', str(CGROUP_PIDS_PARENT.parent),
'--cgroup_pids_parent', CGROUP_PIDS_PARENT.name,
'--', executable, '-Iqu', '-c', code,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
)
user_lock.register_input_source(ctx.client, ctx.message.channel, process)
try:
await process.wait(timeout=MAX_TIMEOUT)
except TimeoutExpired:
await process.kill()
return_code = process.return_code
if return_code is None or return_code == 255:
title = f'Your eval job has failed! Returncode: {return_code!r}'
description = 'A fatal NsJail error occurred'
else:
if return_code == 137:
title = f'Your eval job timed out or ran out of memory. Returncode: {return_code!r}'
else:
title = f'Your eval job has completed with return code {return_code}.'
output = await process.stdout.read()
description = build_output(output, return_code)
author = ctx.message.author
embed = Embed(title, description, color=SNEKBOX_COLOR).add_author(author.avatar_url, author.full_name)
await Closer(ctx.client, ctx.message.channel, embed, check=partial_func(check_reactor, author))
async def github_profile(
client,
event,
user: ('str', 'The user\'s name to get'),
):
"""Gets the user's guild profile."""
guild = event.guild
if (guild is None) or (guild not in client.guild_profiles):
abort(
'The command unavailable in guilds, where the application\'s bot is not in.'
)
if not user:
abort('User parameter cannot be empty.')
yield
# Was the user requested recently?
user_search, rate_limited = await SEARCH_USER_NAME(user)
if rate_limited:
abort('We are being rate limited, please try again later!')
names = user_search.names
if not names:
abort('No user matched the given name.')
if user == names[0]:
name = user
elif len(names) == 1:
name = names[0]
else:
yield Embed('Multiple matches', ''.join(user_search.render_description_to([]))) \
.add_footer(f'Total: {user_search.total_count}')
return
user_object, rate_limited = await GET_USER(name)
if rate_limited:
abort('We are being rate limited, please try again later!')
organization_container, rate_limited = await GET_ORGANIZATIONS(name)
if rate_limited:
abort('We are being rate limited, please try again later!')
description_parts = []
user_object.render_description_to(description_parts)
organization_container.render_description_to(description_parts)
description = ''.join(description_parts)
title = ''.join(user_object.render_title_to([]))
yield Embed(title, description, url=f'https://github.com/{quote(user_object.user_name)}'). \
add_thumbnail(user_object.avatar_url)
return
async def prices(client, event):
"""Lists the prices of the shop."""
embed = Embed('Witch shop')
for item in BUYABLE:
embed_field_name = f'{item.emoji:e} {item.name}'
market_cost = item.market_cost
embed_field_value = f'Sell for: {floor(market_cost*(1.0-MARKET_COST_FEE))} {EMOJI__HEART_CURRENCY:e}\n' \
f'Buy for: {floor(market_cost*(1.0+MARKET_COST_FEE))} {EMOJI__HEART_CURRENCY:e}'
embed.add_field(embed_field_name, embed_field_value, inline=True)
return embed
async def command(client, message, color: 'color'):
embed = Embed(color.__format__('06X'), color=color)
embed.add_image('attachment://color.png')
with ReuBytesIO() as buffer:
image = PIL.new('RGB', (120, 30), color.as_rgb)
image.save(buffer, 'png')
buffer.seek(0)
await client.message_create(message.channel,
embed=embed,
file=('color.png', buffer))
async def shared_guilds(client, event):
"""Returns the shared guilds between you and me."""
permissions = event.channel.cached_permissions_for(client)
if (not permissions.can_send_messages) or (
not permissions.can_add_reactions):
yield Embed(
'Permission denied',
'I require `send messages` and `add reactions` permissions to execute this command.',
color=UTILITY_COLOR,
)
return
# Ack the event, hell yeah!
yield
pages = []
lines = []
lines_count = 0
user = event.user
for guild, guild_profile in user.guild_profiles.items():
nick = guild_profile.nick
guild_name = guild.name
if nick is None:
line = guild_name
else:
line = f'{guild_name} [{nick}]'
lines.append(line)
lines_count += 1
if lines_count == 10:
pages.append('\n'.join(lines))
lines.clear()
lines_count = 0
if lines_count:
pages.append('\n'.join(lines))
if not pages:
pages.append('*none*')
embeds = []
embed_title = f'Shared guilds with {user.full_name}:'
for page in pages:
embed = Embed(embed_title, page, color=UTILITY_COLOR)
embeds.append(embed)
await Pagination(client,
event,
embeds,
check=partial_func(shared_guilds_pagination_check, user))
async def link(client, message, key):
"""
Gives you the link that you need.
If the link is not in the database you will get all of the links.
"""
try:
return Embed(
description=f'**[{key.upper()}]({LINKS[key.upper()]})**'.lower())
except KeyError:
string = '\n'.join(
(f'**[{x}]({y})**'.lower() for x, y in sorted(LINKS.items())))
return Embed(title='Nihongo Quest Links', description=string)
async def __call__(self, client, message, content):
if not client.is_owner(message.author):
await client.message_create(message.channel,
'You are not my boss!')
return
if self.lock.locked():
await client.message_create(message.channel,
'An execution is already running.')
return
self.inputter.set(client, message.channel)
async with self.lock:
result, is_exception = parse_code_content(content,
'No code to execute.')
if is_exception:
await client.message_create(message.channel,
embed=Embed(
'Parsing error', result))
return
printer = self.printer
try:
code_object = compile(result, 'online_interpreter', 'exec')
except SyntaxError as err:
printer.write(
f'{err.__class__.__name__} at line {err.lineno}: {err.msg}\n{result[err.lineno-1]}\n{" "*(err.offset-1)}^'
)
else:
try:
await client.loop.run_in_executor(
alchemy_incendiary(
exec,
(code_object, self.locals),
), )
except BaseException as err:
await client.loop.render_exc_async(err, file=printer)
if printer:
pages = []
while printer:
pages.append(Embed('Output:', printer.get_value()))
amount = len(pages)
for index, embed in enumerate(pages, 1):
embed.add_footer(f'page {index}/{amount}')
else:
pages = [Embed('No output')]
await Pagination(client, message.channel, pages, 240.)
async def sticker_create(client, sticker):
if sticker.guild is not GUILD__NEKO_DUNGEON:
return
description = render_all_sticker_field(sticker)
sticker_url = sticker.url
embed = Embed(f'Sticker created: {sticker.name} ({sticker.id})', description, url=sticker_url)
sticker_format = sticker.format
if (sticker_format is StickerFormat.png) or (sticker_format is StickerFormat.apng):
embed.add_image(sticker_url)
await client.message_create(CHANNEL__NEKO_DUNGEON__LOG_EMOJI, embed=embed, allowed_mentions=None)
async def avatar(client, message,
user: Converter('user',
ConverterFlag.user_all,
default_code='message.author')):
if user.avatar:
color = user.avatar_hash & 0xffffff
else:
color = user.default_avatar.color
url = user.avatar_url_as(size=4096)
embed = Embed(f'{user:f}\'s avatar', color=color, url=url)
embed.add_image(url)
await client.message_create(message.channel, embed=embed)
async def command(client, message):
guild = message.guild
if guild is None:
return
welscome_screen = await client.welcome_screen_get(guild)
if welscome_screen is None:
embed = Embed(
description=f'**{guild.name}** *has no welcome screen enabled*.'
)
else:
embed = Embed(
f'Welcome to **{guild.name}**',
f'{welscome_screen.description}\n\n*TOP THINGS TO DO HERE*')
icon_url = guild.icon_url
if (icon_url is not None):
embed.add_thumbnail(icon_url)
for welcome_channel in welscome_screen.welcome_channels:
embed.add_field(
f'{welcome_channel.emoji:e} {welcome_channel.description}',
f'#{welcome_channel.channel:d}')
await client.message_create(message.channel, embed=embed)
