def close(self):
"""Similar to 'close' of file descriptor.
"""
if self._handle:
try:
flags = win32pipe.GetNamedPipeInfo(self._handle)[0]
except:
flags = 0
if flags & win32con.PIPE_SERVER_END:
win32pipe.DisconnectNamedPipe(self._handle)
# TODO: if pipe, need to call FlushFileBuffers?
def _close_(self, rc, n):
win32file.CloseHandle(self._handle)
self._overlap = None
_AsyncFile._notifier.unregister(self._handle)
self._handle = None
self._read_result = self._write_result = None
self._read_coro = self._write_coro = None
self._buflist = []
if self._overlap.object:
self._overlap.object = partial_func(_close_, self)
win32file.CancelIo(self._handle)
else:
_close_(self, 0, 0)
def _read(size, full):
if size > 0:
count = size
else:
count = 16384
try:
buf = os.read(self._fileno, count)
except (OSError, IOError) as exc:
if exc.errno in (errno.EAGAIN, errno.EWOULDBLOCK):
return
else:
raise
except:
self._notifier.clear(self, _AsyncPoller._Read)
self._read_coro.throw(*sys.exc_info())
self._read_coro = self._read_task = None
return
if buf:
if size > 0:
size -= len(buf)
# assert size >= 0
if size == 0:
full = False
self._buflist.append(buf)
if full:
self._read_task = partial_func(_read, size, full)
return
if self._buflist:
buf, self._buflist = ''.join(self._buflist), []
self._notifier.clear(self, _AsyncPoller._Read)
self._read_coro._proceed_(buf)
self._read_coro = self._read_task = None
async def show_string_description(self, command_context, command_name,
description):
"""
Shows the given string description.
Parameters
----------
command_context : ``CommandContext``
The called command's context.
command_name : `str`
The respective command's display name.
description : `str`
The respective command's description.
"""
if len(description) < 2048:
embed = Embed(command_name, description)
embed_postprocessor = self.embed_postprocessor
if (embed_postprocessor is not None):
embed_postprocessor(command_context, embed)
await Closer(command_context.client,
command_context.message.channel,
embed,
check=partial_func(check_user,
command_context.message.author))
else:
description_parts = chunkify(description.splitlines())
embeds = [
Embed(command_name, description_part)
for description_part in description_parts
]
embed_postprocessor = self.embed_postprocessor
if (embed_postprocessor is not None):
for embed in embeds:
embed_postprocessor(command_context, embed)
await Pagination(command_context.client,
command_context.message.channel,
embeds,
check=partial_func(
check_user, command_context.message.author))
def sanitize_mentions(content, guild=None):
"""
Sanitizes the given content, removing the mentions from it.
Parameters
----------
content : `None`, `str`
The content to sanitize.
guild : `None`, ``Guild`` = `None`, Optional
Respective context to look up guild specific names of entities.
Returns
-------
content : `None`, `str`
"""
if (content is None):
return
transformations = {
'@everyone': '@\u200beveryone',
'@here': '@\u200bhere',
}
for id_ in USER_MENTION_RP.findall(content):
id_ = int(id_)
user = USERS.get(id_, None)
if (user is None) or user.partial:
sanitized_mention = '@invalid-user'
else:
sanitized_mention = '@' + user.name_at(guild)
transformations[f'<@{id_}>'] = sanitized_mention
transformations[f'<@!{id_}>'] = sanitized_mention
for id_ in CHANNEL_MENTION_RP.findall(content):
id_ = int(id_)
channel = CHANNELS.get(id_, None)
if (channel is None) or channel.partial:
sanitized_mention = '@deleted channel'
else:
sanitized_mention = '#' + channel.name
transformations[f'<#{id_}>'] = sanitized_mention
for id_ in ROLE_MENTION_RP.findall(content):
id_ = int(id_)
role = ROLES.get(id_, None)
if (role is None) or role.partial:
sanitized_mention = '@deleted role'
else:
sanitized_mention = '@' + role.name
transformations[f'<@&{id_}>'] = sanitized_mention
return re_compile('|'.join(transformations)).sub(
partial_func(sanitise_mention_escaper, transformations), content)
async def show_command(self, command_context, command):
"""
SHows the given command's description.
Parameters
----------
command_context : ``CommandContext``
Respective command's context.
command : ``Command``
The respective command.
"""
description = command.description
if isinstance(description, str):
await self.show_string_description(command_context,
command.display_name,
description)
return
if callable(description):
embed = await description(command_context)
embed_type = type(embed)
if issubclass(embed_type, EmbedBase):
await Closer(command_context.client,
command_context.message.channel,
embed,
check=partial_func(
check_user, command_context.message.author))
return
if issubclass(embed_type, (tuple, set)) or hasattr(
embed_type, '__getitem__') and hasattr(
embed_type, '__len__'):
await Pagination(command_context.client,
command_context.message.channel,
embed,
check=partial_func(
check_user,
command_context.message.author))
return
# No more case, go back to default
await self.show_autogenerated_description(command_context, command)
def write(self, buf, full=False, timeout=None):
"""Write data in 'buf' to file. If 'full' is True, the function
waits till all data in buf is written; otherwise, it waits
until one write completes. It returns length of data written.
If no data has been written before timeout, then
IOError('timedout') will be thrown.
If timeout is given and full is True and timeout expires
before all the data could be written, it returns length of
data written before timeout if any data has been written.
Must be used with 'yield' as
'n = yield fd.write(buf)' to write (some) data in buf.
"""
def _write(view, written):
try:
n = os.write(self._fileno, view)
except (OSError, IOError) as exc:
if exc.errno in (errno.EAGAIN, errno.EINTR):
n = 0
else:
self._notifier.clear(self, _AsyncPoller._Write)
if full:
view.release()
self._write_task.throw(*sys.exc_info())
self._write_task = self._write_fn = None
return
written += n
if n == len(view) or not full:
self._notifier.clear(self, _AsyncPoller._Write)
if full:
view.release()
self._write_task._proceed_(written)
self._write_task = self._write_fn = None
else:
view = view[n:]
self._write_fn = partial_func(_write, view, written)
if not self._pycos:
self._pycos = Pycos.scheduler()
self._notifier = self._pycos._notifier
if hasattr(self._fd, '_fileno'):
self._notifier.unregister(self._fd)
if full:
view = memoryview(buf)
else:
view = buf
self._timeout = timeout
self._write_task = Pycos.cur_task(self._pycos)
self._write_task._await_()
self._write_fn = partial_func(_write, view, 0)
self._notifier.add(self, _AsyncPoller._Write)
async def in_role(
client,
event,
role_1: ('role', 'Select a role.'),
role_2: ('role', 'Double role!') = None,
role_3: ('role', 'Triple role!') = None,
role_4: ('role', 'Quadra role!') = None,
role_5: ('role', 'Penta role!') = None,
role_6: ('role', 'Epic!') = None,
role_7: ('role', 'Legendary!') = None,
role_8: ('role', 'Mythical!') = None,
role_9: ('role', 'Lunatic!') = None,
):
"""Shows the users with the given roles."""
guild = event.guild
if guild is None:
abort('Guild only command.')
if guild not in client.guild_profiles:
abort('I must be in the guild to do this.')
roles = set()
for role in role_1, role_2, role_3, role_4, role_5, role_6, role_7, role_8, role_9:
if role is None:
continue
if role.guild is guild:
roles.add(role)
continue
abort(f'Role {role.name}, [{role.id}] is bound to an other guild.')
users = []
for user in guild.users.values():
try:
guild_profile = user.guild_profiles[guild]
except KeyError:
continue
guild_profile_roles = guild_profile.roles
if guild_profile_roles is None:
continue
if not roles.issubset(guild_profile_roles):
continue
users.append(user)
pages = InRolePageGetter(users, guild, roles)
await Pagination(client,
event,
pages,
check=partial_func(in_role_pagination_check, event.user))
def write(self, buf, full=False, timeout=None):
"""Write data in 'buf' to file. If 'full' is True, the function
waits till all data in buf is written; otherwise, it waits
until one write completes. It returns length of data written.
If no data has been written before timeout, then
IOError('timedout') will be thrown.
If timeout is given and full is True and timeout expires
before all the data could be written, it returns length of
data written before timeout if any data has been written.
Must be used with 'yield' as
'n = yield fd.write(buf)' to write (some) data in buf.
"""
def _write(view, written):
try:
n = os.write(self._fileno, view)
except (OSError, IOError) as exc:
if exc.errno in (errno.EAGAIN, errno.EINTR):
n = 0
else:
self._notifier.clear(self, _AsyncPoller._Write)
if full:
view.release()
self._write_coro.throw(*sys.exc_info())
self._write_coro = self._write_task = None
return
written += n
if n == len(view) or not full:
self._notifier.clear(self, _AsyncPoller._Write)
if full:
view.release()
self._write_coro._proceed_(written)
self._write_coro = self._write_task = None
else:
view = view[n:]
self._write_task = partial_func(_write, view, written)
if not self._asyncoro:
self._asyncoro = AsynCoro.scheduler()
self._notifier = self._asyncoro._notifier
if hasattr(self._fd, '_fileno'):
self._notifier.unregister(self._fd)
if full:
view = memoryview(buf)
else:
view = buf
self._timeout = timeout
self._write_coro = AsynCoro.cur_coro(self._asyncoro)
self._write_coro._await_()
self._write_task = partial_func(_write, view, 0)
self._notifier.add(self, _AsyncPoller._Write)
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))
def __new__(cls):
"""
Creates a partial function to wrap a slash command.
Subclasses should overwrite this method.
Returns
-------
wrapper : `functools.partial` of ``SlashCommandWrapper._decorate``
Partial function to wrap a slash command.
"""
return partial_func(cls._decorate, cls)
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 _create_socket(self, event):
"""
Called when voice server update data is received from Discord.
If full data was received, closes the actual socket if exists and creates a new one connected to the received
address.
If the voice client is already connected reconnects it, if not then marks it as connected.
This method is a coroutine.
Parameters
----------
event : ``VoiceServerUpdateEvent``
Voice server update event.
"""
self.connected.clear()
gateway = self.client.gateway_for(self.guild_id)
self._session_id = gateway.session_id
token = event.token
self._token = token
endpoint = event.endpoint
if (endpoint is None) or (token is None):
return
self._endpoint = endpoint.replace(':80', '').replace(':443', '')
self._maybe_close_socket()
socket = module_socket.socket(module_socket.AF_INET,
module_socket.SOCK_DGRAM)
protocol = await KOKORO.create_datagram_connection_with(partial_func(
DatagramMergerReadProtocol, KOKORO),
socket=socket)
self._transport = protocol.get_transport()
self._protocol = protocol
self._socket = socket
if self.reader is None:
self.reader = AudioReader(self)
handshake_complete = self._handshake_complete
if handshake_complete.is_done():
# terminate the websocket and handle the reconnect loop if necessary.
handshake_complete.clear()
await self.gateway.terminate()
else:
handshake_complete.set_result(None)
def __new__(cls, parameter_name, type_or_choice, description, name=None):
"""
Creates a partial function to wrap a slash command.
Parameters
----------
parameter_name : `str`
The parameter's name to modify.
type_or_choice : `str`, `type`, `list`, `dict`
The annotation's value to use.
description : `str`
Description for the annotation.
name : `None` or `str`, Optional
Name to use instead of the parameter's.
Returns
-------
wrapper : `functools.partial` of ``SlashCommandWrapper._decorate``
Partial function to wrap a slash command.
Raises
------
TypeError
- If `description`'s is not `str` instance.
- If `parameter_type_or_choice` is `list` instance, but it's elements do not match the `tuple`
(`str`, `str` or `int`) pattern.
- If `parameter_type_or_choice` is `dict` instance, but it's items do not match the (`str`, `str` or `int`)
pattern.
- If `parameter_type_or_choice` is unexpected.
- If `name`'s is neither `None` or `str` instance.
ValueError
- If `description`'s length is out of the expected range [2:100].
- If `parameter_type_or_choice` is `str` instance, but not any of the expected ones.
- If `parameter_type_or_choice` is `type` instance, but not any of the expected ones.
- If `choice` amount is out of the expected range [1:25].
- If `type_or_choice` is a choice, and a `choice` name is duped.
- If `type_or_choice` is a choice, and a `choice` values are mixed types.
"""
if type(parameter_name) is str:
pass
elif isinstance(parameter_name, str):
parameter_name = str(parameter_name)
else:
raise TypeError(f'`parameter_name` can be `str`, got {parameter_name.__class__.__name__}.')
type_, choices = parse_annotation_type_and_choice(type_or_choice, parameter_name)
description = parse_annotation_description(description, parameter_name)
name = parse_annotation_name(name, parameter_name)
return partial_func(cls._decorate, cls, choices, description, name, parameter_name, type_)
def __new__(cls, guild, target, allow):
"""
Creates a partial function to wrap a slash command.
Parameters
----------
guild : ``Guild``, `int`
The guild's identifier where the overwrite is applied.
target : ``ClientUserBase``, ``Role``, ``ChannelBase``, `tuple` ((``ClientUserBase``, ``Role``, \
``ChannelBase``, `str` (`'Role'`, `'role'`, `'User'`, `'user'`, `'Channel'`, `'channel'`)), `int`)
The target entity of the overwrite
The expected type & value might be pretty confusing, but the target was it to allow relaxing creation.
To avoid confusing, here is a list of the expected structures:
- ``Role``
- ``ClientUserBase``
- ``ChannelBase``
- `tuple` (``Role``, `int`)
- `tuple` (``ClientUserBase``, `int`)
- `tuple` (``ChannelBase``, `int`)
- `tuple` (`'Role'`, `int`)
- `tuple` (`'role'`, `int`)
- `tuple` (`'User'`, `int`)
- `tuple` (`'user'`, `int`)
- `tuple` (`'Channel'`, `int`)
- `tuple` (`'channel'`, `int`)
allow : `bool`
Whether the respective application command should be enabled for the respective entity.
Returns
-------
wrapper : `functools.partial` of ``SlasherCommandWrapper._decorate``
Partial function to wrap a slash command.
"""
if isinstance(guild, Guild):
guild_id = guild.id
elif isinstance(guild, (int, str)):
guild_id = preconvert_snowflake(guild, 'guild')
else:
raise TypeError(
f'`guild` can be `{Guild.__class__.__name__}`, `int`, got {guild.__class__.__name__}; {guild!r}.'
)
overwrite = ApplicationCommandPermissionOverwrite(target, allow)
return partial_func(cls._decorate, cls, guild_id, overwrite)
async def show_autogenerated_description(self, command_context, command):
"""
Generates, then sends the description of the given description-less command.
Parameters
----------
command_context : ``CommandContext``
The called command's context.
command : ``Command``
The respective command.
"""
prefix = command_context.prefix
description_lines = []
sun_commands = get_sub_commands(command)
if len(sun_commands) == 0:
description_lines.append('*no usages*')
else:
if len(sun_commands) == 1:
description_lines.append('Usage:')
else:
description_lines.append('Usages:')
for command_path, command_function in sun_commands:
description_line = ['`', prefix, command_path]
command_parameters = generate_command_parameters(
command_function)
if command_parameters is not None:
description_line.append(' ')
description_line.append(command_parameters)
description_line.append('`')
description_lines.append(''.join(description_line))
embed = Embed(command.display_name, '\n'.join(description_lines))
embed_postprocessor = self.embed_postprocessor
if embed_postprocessor is not None:
embed_postprocessor(command_context, embed)
await Closer(
command_context.client,
command_context.message.channel,
embed,
check=partial_func(check_user, command_context.message.author),
)
def _read(size, full, rc, n):
if rc or n == 0:
if self._timeout:
self._notifier._del_timeout(self)
self._overlap.object = self._read_result = None
if rc != winerror.ERROR_OPERATION_ABORTED:
if (self._buflist or rc == winerror.ERROR_HANDLE_EOF
or rc == winerror.ERROR_BROKEN_PIPE):
buf, self._buflist = ''.join(self._buflist), []
self._read_task._proceed_(buf)
return
self._read_task.throw(IOError(rc, 'ReadFile', str(rc)))
self._overlap.object = self._read_task = self._read_result = None
return
buf = self._read_result[:n]
if size > 0:
size -= len(buf)
assert size >= 0
if size == 0:
full = False
self._buflist.append(buf)
self._overlap.Offset += n
if full:
self._overlap.object = partial_func(_read, size, full)
try:
rc, _ = win32file.ReadFile(self._handle,
self._read_result,
self._overlap)
except pywintypes.error as exc:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
buf, self._buflist = ''.join(self._buflist), []
self._overlap.object = self._read_result = None
if self._timeout:
self._notifier._del_timeout(self)
self._read_task._proceed_(buf)
self._read_task = None
return
if self._buflist:
buf, self._buflist = ''.join(self._buflist), []
if self._timeout:
self._notifier._del_timeout(self)
self._overlap.object = self._read_result = None
self._read_task._proceed_(buf)
self._read_task = None
def write(self, buf, full=False, timeout=None):
"""Write data in 'buf' to file. If 'full' is True, the function
waits till all data in buf is written; otherwise, it waits
until one write completes. It returns length of data written.
If no data has been written before timeout, then
IOError('timedout') will be thrown.
If timeout is given and full is True and timeout expires
before all the data could be written, it returns length of
data written before timeout if any data has been written.
Must be used with 'yield' as
'n = yield fd.write(buf)' to write (some) data in buf.
"""
def _write(self, view, written, full):
try:
n = os.write(self._fileno, view)
except (OSError, IOError) as exc:
if exc.errno in (errno.EAGAIN, errno.EINTR):
n = 0
else:
_AsyncFile._notifier.clear(self, _AsyncPoller._Write)
self._write_task = None
coro, self._write_coro = self._write_coro, None
coro.throw(*sys.exc_info())
return
written += n
if n == len(view) or not full:
_AsyncFile._notifier.clear(self, _AsyncPoller._Write)
self._write_coro._proceed_(written)
self._write_coro = self._write_task = None
else:
view = view[n:]
self._write_task = partial_func(_write, self, view, written, full)
if full:
view = buffer(buf)
else:
view = buf
self._timeout = timeout
self._write_task = partial_func(_write, self, view, 0, full)
if not self._asyncoro:
self._asyncoro = AsynCoro.scheduler()
self._write_coro = AsynCoro.cur_coro(self._asyncoro)
self._write_coro._await_()
_AsyncFile._notifier.add(self, _AsyncPoller._Write)
def _write(self, written, full, rc, n):
if rc or n == 0:
if self._timeout:
_AsyncFile._notifier._del_timeout(self)
if rc != winerror.ERROR_OPERATION_ABORTED:
if written:
self._write_coro._proceed_(written)
else:
self._write_coro.throw(
IOError(rc, 'WriteFile', str(rc)))
self._write_result.release()
self._overlap.object = self._write_coro = self._write_result = None
return
written += n
self._overlap.Offset += n
self._write_result = self._write_result[n:]
if not full or len(self._write_result) == 0:
self._write_result.release()
self._overlap.object = self._write_result = None
if self._timeout:
_AsyncFile._notifier._del_timeout(self)
self._write_coro._proceed_(written)
self._write_coro = None
return
self._overlap.object = partial_func(_write, self, written,
full)
try:
rc, _ = win32file.WriteFile(self._handle,
self._write_result,
self._overlap)
except pywintypes.error as exc:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
self._write_result.release()
self._overlap.object = self._write_result = None
if self._timeout:
_AsyncFile._notifier._del_timeout(self)
if written:
self._write_coro._proceed_(written)
else:
self._write_coro.throw(
IOError(rc, 'WriteFile', str(rc)))
self._write_coro = None
return
def _read(size, full, rc, n):
if rc or n == 0:
if self._timeout:
self._notifier._del_timeout(self)
self._overlap.object = self._read_result = None
if rc != winerror.ERROR_OPERATION_ABORTED:
if (self._buflist or rc == winerror.ERROR_HANDLE_EOF or
rc == winerror.ERROR_BROKEN_PIPE):
buf, self._buflist = ''.join(self._buflist), []
self._read_task._proceed_(buf)
return
self._read_task.throw(IOError(rc, 'ReadFile', str(rc)))
self._overlap.object = self._read_task = self._read_result = None
return
buf = self._read_result[:n]
if size > 0:
size -= len(buf)
assert size >= 0
if size == 0:
full = False
self._buflist.append(buf)
self._overlap.Offset += n
if full:
self._overlap.object = partial_func(_read, size, full)
try:
rc, _ = win32file.ReadFile(self._handle, self._read_result, self._overlap)
except pywintypes.error as exc:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
buf, self._buflist = ''.join(self._buflist), []
self._overlap.object = self._read_result = None
if self._timeout:
self._notifier._del_timeout(self)
self._read_task._proceed_(buf)
self._read_task = None
return
if self._buflist:
buf, self._buflist = ''.join(self._buflist), []
if self._timeout:
self._notifier._del_timeout(self)
self._overlap.object = self._read_result = None
self._read_task._proceed_(buf)
self._read_task = None
def _write(view, written):
try:
n = os.write(self._fileno, view)
except (OSError, IOError) as exc:
if exc.errno in (errno.EAGAIN, errno.EINTR):
n = 0
else:
self._notifier.clear(self, _AsyncPoller._Write)
self._write_task.throw(*sys.exc_info())
self._write_task = self._write_fn = None
return
written += n
if n == len(view) or not full:
self._notifier.clear(self, _AsyncPoller._Write)
self._write_task._proceed_(written)
self._write_task = self._write_fn = None
else:
view = view[n:]
self._write_fn = partial_func(_write, view, written)
def _write(view, written):
try:
n = os.write(self._fileno, view)
except (OSError, IOError) as exc:
if exc.errno in (errno.EAGAIN, errno.EINTR):
n = 0
else:
self._notifier.clear(self, _AsyncPoller._Write)
self._write_coro.throw(*sys.exc_info())
self._write_coro = self._write_task = None
return
written += n
if n == len(view) or not full:
self._notifier.clear(self, _AsyncPoller._Write)
self._write_coro._proceed_(written)
self._write_coro = self._write_task = None
else:
view = view[n:]
self._write_task = partial_func(_write, view, written)
def error(self, exception_handler=None, *, first=False):
"""
Registers an exception handler to the command.
Parameters
----------
exception_handler : `None`, `CoroutineFunction` = `None`, Optional
Exception handler to register.
first : `bool` = `False`, Optional (Keyword Only)
Whether the exception handler should run first.
Returns
-------
exception_handler / wrapper : `CoroutineFunction` / `functools.partial`
If `exception_handler` is not given, returns a wrapper.
"""
if exception_handler is None:
return partial_func(_register_exception_handler, first)
return self._register_exception_handler(exception_handler, first)
async def getting_good(client, event):
"""Getting there."""
main_component = Row(
Button('cake', custom_id='cake', style=ButtonStyle.violet),
Button('cat', custom_id='cat', style=ButtonStyle.gray),
Button('snake', custom_id='snake', style=ButtonStyle.green),
Button('eggplant', custom_id='eggplant', style=ButtonStyle.red),
Button('eggplant', custom_id='eggplant', style=ButtonStyle.red, enabled=False),
)
yield InteractionResponse(embed=Embed('Choose your poison.'), components=main_component, show_for_invoking_user_only=True)
try:
component_interaction = await wait_for_component_interaction(event,
timeout=4500., check=partial_func(check_user, event.user))
except TimeoutError:
await client.message_edit(event.message, components=None)
else:
emoji = BUILTIN_EMOJIS[component_interaction.interaction.custom_id]
await client.message_edit(event.message, emoji.as_emoji, embed=None, components=None)
def _write(written, rc, n):
if rc or n == 0:
if self._timeout:
self._notifier._del_timeout(self)
if rc != winerror.ERROR_OPERATION_ABORTED:
if written:
self._write_coro._proceed_(written)
else:
self._write_coro.throw(IOError(rc, 'WriteFile', str(rc)))
self._write_result.release()
self._overlap.object = self._write_coro = self._write_result = None
return
written += n
self._overlap.Offset += n
self._write_result = self._write_result[n:]
if not full or len(self._write_result) == 0:
self._write_result.release()
self._overlap.object = self._write_result = None
if self._timeout:
self._notifier._del_timeout(self)
self._write_coro._proceed_(written)
self._write_coro = None
return
self._overlap.object = partial_func(_write, written)
try:
rc, _ = win32file.WriteFile(self._handle, self._write_result, self._overlap)
except pywintypes.error as exc:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
self._write_result.release()
self._overlap.object = self._write_result = None
if self._timeout:
self._notifier._del_timeout(self)
if written:
self._write_coro._proceed_(written)
else:
self._write_coro.throw(IOError(rc, 'WriteFile', str(rc)))
self._write_coro = None
return
def write_proc(fd, input, coro=None):
size = 16384
if isinstance(input, str):
n = yield fd.write(input, full=True)
if n != len(input):
raise IOError('write failed')
else:
# TODO: how to know if 'input' is file object for
# on-disk file?
if hasattr(input, 'seek') and hasattr(input, 'fileno'):
read_func = partial_func(os.read, input.fileno())
else:
read_func = input.read
while 1:
data = yield read_func(size)
if not data:
break
n = yield fd.write(data, full=True)
if n != len(data):
raise IOError('write failed')
input.close()
fd.close()
def write_proc(fd, input, task=None):
size = 16384
if isinstance(input, str):
n = yield fd.write(input, full=True)
if n != len(input):
raise IOError('write failed')
else:
# TODO: how to know if 'input' is file object for
# on-disk file?
if hasattr(input, 'seek') and hasattr(input, 'fileno'):
read_func = partial_func(os.read, input.fileno())
else:
read_func = input.read
while 1:
data = yield read_func(size)
if not data:
break
n = yield fd.write(data, full=True)
if n != len(data):
raise IOError('write failed')
input.close()
fd.close()
def _write(self, view, written, full):
try:
n = os.write(self._fileno, view)
except (OSError, IOError) as exc:
if exc.errno in (errno.EAGAIN, errno.EINTR):
n = 0
else:
_AsyncFile._notifier.clear(self, _AsyncPoller._Write)
if full:
view.release()
self._write_task = None
coro, self._write_coro = self._write_coro, None
coro.throw(*sys.exc_info())
return
written += n
if n == len(view) or not full:
_AsyncFile._notifier.clear(self, _AsyncPoller._Write)
if full:
view.release()
self._write_coro._proceed_(written)
self._write_coro = self._write_task = None
else:
view = view[n:]
self._write_task = partial_func(_write, self, view, written, full)
async def docs_search(client, event,
search_for: ('str', 'Search term'),
):
"""Searchers the given query from hata docs."""
guild = event.guild
if guild is None:
yield Embed('Error', 'Guild only command', color=COLOR__KOISHI_HELP)
return
if guild not in client.guild_profiles:
yield Embed('Error', 'I must be in the guild to execute this command.', color=COLOR__KOISHI_HELP)
return
permissions = event.channel.cached_permissions_for(client)
if (not permissions.can_send_messages) or (not permissions.can_add_reactions):
yield Embed('Permission denied',
'I need `send messages` and `add reactions` permission to execute this command.',
color=COLOR__KOISHI_HELP)
return
if len(search_for) < 4:
yield Embed('Ohoho', 'Please give a longer query', color=COLOR__KOISHI_HELP)
return
yield
async with client.http.get(HATA_DOCS_SEARCH_API, params={'search_for': search_for}) as response:
datas = await response.json()
if not datas:
embed = Embed(f'No search result for: `{search_for}`', color=COLOR__KOISHI_HELP)
await Closer(client, event, embed)
return
sections = []
section_parts = []
for data in datas:
section_parts.append('[**')
name = data['name']
name = name.replace('_', '\_')
section_parts.append(name)
section_parts.append('**](')
section_parts.append(HATA_DOCS_BASE_URL)
url = data['url']
section_parts.append(url)
section_parts.append(') *')
type_ = data['type']
section_parts.append(type_)
section_parts.append('*')
preview = data.get('preview', None)
if (preview is not None):
preview = preview.replace('_', '\_')
section_parts.append('\n')
section_parts.append(preview)
section = ''.join(section_parts)
sections.append(section)
section_parts.clear()
descriptions = []
description_parts = []
description_length = 0
for section in sections:
section_length = len(section)
description_length += section_length
if description_length > 2000:
description = ''.join(description_parts)
descriptions.append(description)
description_parts.clear()
description_parts.append(section)
description_length = section_length
continue
if description_parts:
description_parts.append('\n\n')
description_length += 2
description_parts.append(section)
continue
if description_parts:
description = ''.join(description_parts)
descriptions.append(description)
title = f'Search results for `{search_for}`'
embeds = []
for index, description in enumerate(descriptions, 1):
embed = Embed(title, description, color=COLOR__KOISHI_HELP).add_footer(f'Page {index}/{len(descriptions)}')
embeds.append(embed)
await Pagination(client, event, embeds, check=partial_func(docs_search_pagination_check, event.user))
def read(self, size=0, full=False, timeout=None):
"""Read at most 'size' bytes from file; if 'size' <= 0,
all data up to EOF is read and returned. If 'full' is
True, exactly 'size' bytes are returned (unless EOF or
timeout occur before). If EOF is encountered before any
more data is available, empty buffer is returned.
If no data has been read before timeout, then
IOError('timedout') will be thrown.
If timeout is given and full is True and timeout expires
before all the data could be read, it returns partial data
read before timeout if any data has been read.
Must be used in a task with 'yield' as
'data = yield fd.read(1024)'
"""
def _read(size, full):
if size > 0:
count = size
else:
count = 16384
try:
buf = os.read(self._fileno, count)
except (OSError, IOError) as exc:
if exc.errno in (errno.EAGAIN, errno.EWOULDBLOCK):
return
else:
raise
except Exception:
self._notifier.clear(self, _AsyncPoller._Read)
self._read_task.throw(*sys.exc_info())
self._read_task = self._read_fn = None
return
if buf:
if size > 0:
size -= len(buf)
# assert size >= 0
if size == 0:
full = False
self._buflist.append(buf)
if full:
self._read_fn = partial_func(_read, size, full)
return
if self._buflist:
buf, self._buflist = ''.join(self._buflist), []
self._notifier.clear(self, _AsyncPoller._Read)
self._read_task._proceed_(buf)
self._read_task = self._read_fn = None
if not self._pycos:
self._pycos = Pycos.scheduler()
self._notifier = self._pycos._notifier
if hasattr(self._fd, '_fileno'):
self._notifier.unregister(self._fd)
if not size or size < 0:
size = 0
full = True
elif self._buflist:
buf, self._buflist = ''.join(self._buflist), []
if len(buf) > size:
buf, self._buflist = buf[:size], [buf[size:]]
if (not full) or (len(buf) == size):
return buf
self._buflist = [buf]
size -= len(buf)
self._timeout = timeout
self._read_task = Pycos.cur_task(self._pycos)
self._read_task._await_()
self._read_fn = partial_func(_read, size, full)
self._notifier.add(self, _AsyncPoller._Read)
def read(self, size=0, full=False, timeout=None):
"""Read at most 'size' bytes from file; if 'size' <= 0,
all data up to EOF is read and returned. If 'full' is
True, exactly 'size' bytes are returned (unless EOF or
timeout occur before). If EOF is encountered before any
more data is available, empty buffer is returned.
If no data has been read before timeout, then
IOError('timedout') will be thrown.
If timeout is given and full is True and timeout expires
before all the data could be read, it returns partial data
read before timeout if any data has been read.
Must be used in a task with 'yield' as
'data = yield fd.read(1024)'
"""
def _read(size, full, rc, n):
if rc or n == 0:
if self._timeout:
self._notifier._del_timeout(self)
self._overlap.object = self._read_result = None
if rc != winerror.ERROR_OPERATION_ABORTED:
if (self._buflist or rc == winerror.ERROR_HANDLE_EOF or
rc == winerror.ERROR_BROKEN_PIPE):
buf, self._buflist = ''.join(self._buflist), []
self._read_task._proceed_(buf)
return
self._read_task.throw(IOError(rc, 'ReadFile', str(rc)))
self._overlap.object = self._read_task = self._read_result = None
return
buf = self._read_result[:n]
if size > 0:
size -= len(buf)
assert size >= 0
if size == 0:
full = False
self._buflist.append(buf)
self._overlap.Offset += n
if full:
self._overlap.object = partial_func(_read, size, full)
try:
rc, _ = win32file.ReadFile(self._handle, self._read_result, self._overlap)
except pywintypes.error as exc:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
buf, self._buflist = ''.join(self._buflist), []
self._overlap.object = self._read_result = None
if self._timeout:
self._notifier._del_timeout(self)
self._read_task._proceed_(buf)
self._read_task = None
return
if self._buflist:
buf, self._buflist = ''.join(self._buflist), []
if self._timeout:
self._notifier._del_timeout(self)
self._overlap.object = self._read_result = None
self._read_task._proceed_(buf)
self._read_task = None
if not self._pycos:
self._pycos = Pycos.scheduler()
self._notifier = self._pycos._notifier
self._notifier.register(self._handle)
if not size or size < 0:
count = 16384
full = True
else:
if self._buflist:
buf, self._buflist = ''.join(self._buflist), []
if len(buf) > size:
buf, self._buflist = buf[:size], [buf[size:]]
if (not full) or (len(buf) == size):
return buf
self._buflist = [buf]
size -= len(buf)
count = size
self._read_result = win32file.AllocateReadBuffer(count)
self._overlap.object = partial_func(_read, size, full)
self._read_task = Pycos.cur_task(self._pycos)
self._read_task._await_()
try:
rc, _ = win32file.ReadFile(self._handle, self._read_result, self._overlap)
except pywintypes.error as exc:
if exc.winerror == winerror.ERROR_BROKEN_PIPE:
buf, self._buflist = ''.join(self._buflist), []
self._read_task._proceed_(buf)
self._read_result = self._read_task = self._overlap.object = None
return
else:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
self._overlap.object = self._read_result = self._read_task = None
self._read_task.throw(IOError(rc, 'ReadFile', str(rc)))
if timeout:
self._timeout = timeout
self._notifier._add_timeout(self)
def write(self, buf, full=False, timeout=None):
"""Write data in 'buf' to file. If 'full' is True, the function
waits till all data in buf is written; otherwise, it waits
until one write completes. It returns length of data written.
If no data has been written before timeout, then
IOError('timedout') will be thrown.
If timeout is given and full is True and timeout expires
before all the data could be written, it returns length of
data written before timeout if any data has been written.
Must be used with 'yield' as
'n = yield fd.write(buf)' to write (some) data in buf.
"""
def _write(written, rc, n):
if rc or n == 0:
if self._timeout:
self._notifier._del_timeout(self)
if rc != winerror.ERROR_OPERATION_ABORTED:
if written:
self._write_task._proceed_(written)
else:
self._write_task.throw(IOError(rc, 'WriteFile', str(rc)))
self._overlap.object = self._write_task = self._write_result = None
return
written += n
self._overlap.Offset += n
self._write_result = self._write_result[n:]
if not full or len(self._write_result) == 0:
self._overlap.object = self._write_result = None
if self._timeout:
self._notifier._del_timeout(self)
self._write_task._proceed_(written)
self._write_task = None
return
self._overlap.object = partial_func(_write, written)
try:
rc, _ = win32file.WriteFile(self._handle, self._write_result, self._overlap)
except pywintypes.error as exc:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
self._overlap.object = self._write_result = None
if self._timeout:
self._notifier._del_timeout(self)
if written:
self._write_task._proceed_(written)
else:
self._write_task.throw(IOError(rc, 'WriteFile', str(rc)))
self._write_task = None
return
self._write_result = buffer(buf)
self._overlap.object = partial_func(_write, 0)
if not self._pycos:
self._pycos = Pycos.scheduler()
self._notifier = self._pycos._notifier
self._notifier.register(self._handle)
self._write_task = Pycos.cur_task(self._pycos)
self._write_task._await_()
try:
rc, _ = win32file.WriteFile(self._handle, self._write_result, self._overlap)
except pywintypes.error as exc:
if exc.winerror == winerror.ERROR_BROKEN_PIPE:
self._write_task._proceed_(0)
self._write_result = self._write_task = self._overlap.object = None
return
else:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
self._overlap.object = self._write_result = self._write_task = None
self._write_task._proceed_(None)
raise IOError(rc, 'WriteFile', str(rc))
if timeout:
self._timeout = timeout
self._notifier._add_timeout(self)
async def list_commands(self, command_context, command_names,
category_name):
"""
Lists the given commands.
Parameters
----------
command_context : ``CommandContext``
The called command's context.
command_names : `list` of `str`
The command's names to display.
category_name : `None or `str`
The respective category's name.
"""
pages = []
page = []
page_line_count = 0
prefix = self.prefix
for command_name in command_names:
page.append(prefix)
page.append(' ')
page.append(command_name)
page_line_count += 1
if page_line_count == MAX_LINE_PER_PAGE:
pages.append(''.join(page))
page.clear()
page_line_count = 0
else:
page.append('\n')
if page_line_count:
del page[-1]
pages.append(''.join(page))
page_count = len(pages)
field_name = f'Use `{command_context.prefix}help <command>` for more information.'
if category_name is None:
title = 'Commands'
else:
title = f'Commands of {category_name}'
embeds = [
Embed(title, page).add_field(field_name,
f'page {index}/{page_count}')
for index, page in enumerate(pages, 1)
]
embed_postprocessor = self.embed_postprocessor
if (embed_postprocessor is not None):
for embed in embeds:
embed_postprocessor(command_context, embed)
await Pagination(command_context.client,
command_context.message.channel,
embeds,
check=partial_func(check_user,
command_context.message.author))
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
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
with StringIO() as buffer:
try:
code_object = compile(result,
'online_interpreter',
'exec',
flags=COMPILE_FLAGS)
except SyntaxError as err:
buffer.write(
f'{err.__class__.__name__} at line {err.lineno}: {err.msg}\n'
f'{result[err.lineno-1]}\n'
f'{" "*(err.offset-1)}^')
else:
locals_ = self.locals
locals_['print'] = partial_func(raw_print, buffer)
locals_['input'] = partial_func(raw_input)
try:
function = FunctionType(code_object, locals_)
coroutine = function()
if is_awaitable(coroutine):
await coroutine
except BaseException as err:
await KOKORO.render_exc_async(err, file=buffer)
page_contents = get_buffer_value(buffer)
pages = []
if (page_contents is not None) and page_contents:
amount = len(page_contents)
for index, page_content in enumerate(page_contents, 1):
pages.append(
Embed(
'Output:',
page_content).add_footer(f'page {index}/{amount}'))
else:
pages.append(Embed('No output'))
await Pagination(client, message.channel, pages, timeout=240.)
def rasm_mode(self, K, MAX_ITER=40):
"""
Rasmussen's numerically stable mode finding
For nomenclature see Rasmussen & Williams 2006
Influenced by GPML (BSD) code, all errors are our own
:param K: Covariance matrix evaluated at locations X
:type K: NxD matrix
:param MAX_ITER: Maximum number of iterations of newton-raphson before forcing finish of optimisation
:type MAX_ITER: scalar
:returns: f_hat, mode on which to make laplace approxmiation
:rtype: NxD matrix
"""
#old_Ki_f = np.zeros((self.N, 1))
#Start f's at zero originally of if we have gone off track, try restarting
if self.old_Ki_f is None or self.bad_fhat:
old_Ki_f = np.random.rand(self.N, 1)/50.0
#old_Ki_f = self.Y
f = np.dot(K, old_Ki_f)
else:
#Start at the old best point
old_Ki_f = self.old_Ki_f.copy()
f = self.f_hat.copy()
new_obj = -np.inf
old_obj = np.inf
def obj(Ki_f, f):
return -0.5*np.dot(Ki_f.T, f) + self.noise_model.logpdf(f, self.data, extra_data=self.extra_data)
difference = np.inf
epsilon = 1e-7
#step_size = 1
#rs = 0
i = 0
while difference > epsilon and i < MAX_ITER:
W = -self.noise_model.d2logpdf_df2(f, self.data, extra_data=self.extra_data)
W_f = W*f
grad = self.noise_model.dlogpdf_df(f, self.data, extra_data=self.extra_data)
b = W_f + grad
W12BiW12Kb, _ = self._compute_B_statistics(K, W.copy(), np.dot(K, b))
#Work out the DIRECTION that we want to move in, but don't choose the stepsize yet
full_step_Ki_f = b - W12BiW12Kb
dKi_f = full_step_Ki_f - old_Ki_f
f_old = f.copy()
def inner_obj(step_size, old_Ki_f, dKi_f, K):
Ki_f = old_Ki_f + step_size*dKi_f
f = np.dot(K, Ki_f)
# This is nasty, need to set something within an optimization though
self.tmp_Ki_f = Ki_f.copy()
self.tmp_f = f.copy()
return -obj(Ki_f, f)
i_o = partial_func(inner_obj, old_Ki_f=old_Ki_f, dKi_f=dKi_f, K=K)
#Find the stepsize that minimizes the objective function using a brent line search
#The tolerance and maxiter matter for speed! Seems to be best to keep them low and make more full
#steps than get this exact then make a step, if B was bigger it might be the other way around though
#new_obj = sp.optimize.minimize_scalar(i_o, method='brent', tol=1e-4, options={'maxiter':5}).fun
new_obj = sp.optimize.brent(i_o, tol=1e-4, maxiter=10)
f = self.tmp_f.copy()
Ki_f = self.tmp_Ki_f.copy()
#Optimize without linesearch
#f_old = f.copy()
#update_passed = False
#while not update_passed:
#Ki_f = old_Ki_f + step_size*dKi_f
#f = np.dot(K, Ki_f)
#old_obj = new_obj
#new_obj = obj(Ki_f, f)
#difference = new_obj - old_obj
##print "difference: ",difference
#if difference < 0:
##print "Objective function rose", np.float(difference)
##If the objective function isn't rising, restart optimization
#step_size *= 0.8
##print "Reducing step-size to {ss:.3} and restarting optimization".format(ss=step_size)
##objective function isn't increasing, try reducing step size
#f = f_old.copy() #it's actually faster not to go back to old location and just zigzag across the mode
#old_obj = new_obj
#rs += 1
#else:
#update_passed = True
#old_Ki_f = self.Ki_f.copy()
#difference = abs(new_obj - old_obj)
#old_obj = new_obj.copy()
difference = np.abs(np.sum(f - f_old)) + np.abs(np.sum(Ki_f - old_Ki_f))
#difference = np.abs(np.sum(Ki_f - old_Ki_f))/np.float(self.N)
old_Ki_f = Ki_f.copy()
i += 1
self.old_Ki_f = old_Ki_f.copy()
#Warn of bad fits
if difference > epsilon:
self.bad_fhat = True
warnings.warn("Not perfect f_hat fit difference: {}".format(difference))
elif self.bad_fhat:
self.bad_fhat = False
warnings.warn("f_hat now perfect again")
self.Ki_f = Ki_f
return f
async def list_categories(self, command_context):
"""
Lists the categories of the respective client's command preprocessor.
Parameters
----------
command_context : ``CommandContext``
The called command's context.
"""
categories = command_context.client.command_processor.categories
displayable_categories = []
for category in categories:
if await should_show_category(command_context, category):
displayable_categories.append(category)
displayable_categories_length = len(displayable_categories)
if displayable_categories_length == 1:
await self.list_category(command_context,
displayable_categories[0],
display_category_name=False)
return
category_names = sorted(category.display_name
for category in displayable_categories)
pages = []
if displayable_categories_length == 0:
pages.append('*[No available category or command]*')
else:
page = []
page_line_count = 0
for index, category_name in enumerate(category_names, 1):
page.append(str(index))
page.append('.: ')
page.append(category_name)
page_line_count += 1
if page_line_count == MAX_LINE_PER_PAGE:
pages.append(''.join(page))
page.clear()
page_line_count = 0
else:
page.append('\n')
if page_line_count:
del page[-1]
pages.append(''.join(page))
page_count = len(pages)
field_name = f'Use `{command_context.prefix}help <category/command>` for more information.'
embeds = [
Embed('Categories', page).add_field(field_name,
f'page {index}/{page_count}')
for index, page in enumerate(pages, 1)
]
embed_postprocessor = self.embed_postprocessor
if (embed_postprocessor is not None):
for embed in embeds:
embed_postprocessor(command_context, embed)
await Pagination(command_context.client,
command_context.message.channel,
embeds,
check=partial_func(check_user,
command_context.message.author))
async def delete_(
client,
event,
sticker_name: ('str', 'The sticker\'s name to delete', 'sticker'),
):
"""Deletes the given sticker. (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.'
)
sticker = event.guild.get_sticker_like(sticker_name)
if (sticker is None):
abort(f'No sticker matched the given name: {sticker_name!r}.')
embed = Embed(
'Confirmation',
f'Are you sure to delete {sticker.name!r} ({sticker.id}) sticker forever?'
)
message = yield InteractionResponse(embed=embed,
components=STICKER_DELETE_COMPONENTS,
allowed_mentions=None)
try:
component_interaction = await wait_for_component_interaction(
message,
timeout=300.0,
check=partial_func(check_sticker_deleter, event.user))
except TimeoutError:
embed.title = 'Timeout'
embed.description = f'Sticker {sticker.name!r} was not deleted.'
# Edit the source message with the source interaction
yield InteractionResponse(embed=embed,
components=None,
allowed_mentions=None,
message=message)
return
if component_interaction.interaction == STICKER_DELETE_BUTTON_CANCEL:
embed.title = 'Cancelled'
embed.description = f'Sticker {sticker.name!r} was not deleted.'
# Edit the source message with the component interaction
yield InteractionResponse(embed=embed,
components=None,
allowed_mentions=None,
event=component_interaction)
return
# Acknowledge the event
await client.interaction_component_acknowledge(component_interaction)
try:
await client.sticker_guild_delete(sticker)
except ConnectionError:
# No internet, let it be
return
except DiscordException as err:
if err.code == ERROR_CODES.unknown_sticker:
failure = False
else:
failure = True
embed.title = 'Failure'
embed.description = repr(err)
else:
failure = False
if not failure:
embed.title = 'Success'
embed.description = f'Sticker {sticker.name!r} has been deleted successfully.'
# Edit the source message
yield InteractionResponse(embed=embed, message=message, components=None)
async def edit_(
client,
event,
sticker_name: ('str', 'The sticker\'s name to delete', 'sticker'),
new_name: (
'str',
'New name for the sticker',
) = None,
new_emoji_value: (str, 'Emoji representation of the sticker.',
'new_emoji') = None,
new_description: (str, 'Description for the sticker.') = None,
):
"""Edits the given sticker. (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.'
)
sticker = event.guild.get_sticker_like(sticker_name)
if (sticker is None):
abort(f'No sticker matched the given name: {sticker_name!r}.')
anything_to_edit = False
if (new_name is not None):
if (sticker.name != new_name):
name_length = len(new_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}, {new_name!r}.'
)
anything_to_edit = True
else:
new_name = None
if (new_emoji_value is not None):
new_emoji = parse_emoji(new_emoji_value)
if new_emoji is None:
abort(f'{new_emoji_value} cannot be interpreted as an emoji.')
if new_emoji.is_custom_emoji():
abort(f'Only unicode can be used, got {new_emoji:e}')
tags = sticker.tags
if (tags is None) or (len(tags) != 1) or (next(iter(tags)) !=
new_emoji.name):
anything_to_edit = True
else:
new_emoji = None
else:
new_emoji = None
if (new_description is not None):
description_length = len(new_description)
if (description_length > 100):
abort(
f'Sticker description\'s length can be in range [0:100], got {description_length!r}, '
f'{new_description!r}.')
if (sticker.description != new_description):
anything_to_edit = True
else:
new_description = None
if not anything_to_edit:
abort('No differences were provided.')
embed = Embed('Confirmation',
f'Are you sure to edit {sticker.name!r} sticker?')
if (new_name is not None):
embed.add_field('Name', f'{sticker.name} -> {new_name}')
if (new_emoji is not None):
embed.add_field('Tags',
f'{", ".join(sticker.tags)} -> {new_emoji.name}')
if (new_description is not None):
embed.add_field('Description',
f'{sticker.description} -> {new_description}')
message = yield InteractionResponse(embed=embed,
components=STICKER_EDIT_COMPONENTS,
allowed_mentions=None)
try:
component_interaction = await wait_for_component_interaction(
message,
timeout=300.0,
check=partial_func(check_sticker_editor, event.user))
except TimeoutError:
embed.title = 'Timeout'
embed.description = f'Sticker {sticker.name!r} was not edited.'
# Edit the source message with the source interaction
yield InteractionResponse(embed=embed,
components=None,
allowed_mentions=None,
message=message)
return
if component_interaction.interaction == STICKER_EDIT_BUTTON_CANCEL:
embed.title = 'Cancelled'
embed.description = f'Sticker {sticker.name!r} was not edited.'
# Edit the source message with the component interaction
yield InteractionResponse(embed=embed,
components=None,
allowed_mentions=None,
event=component_interaction)
return
# Acknowledge the event
await client.interaction_component_acknowledge(component_interaction)
kwargs = {}
if (new_name is not None):
kwargs['name'] = new_name
if (new_emoji is not None):
kwargs['emoji_representation'] = new_emoji
if (new_description is not None):
kwargs['description'] = new_description
try:
await client.sticker_guild_edit(sticker, **kwargs)
except ConnectionError:
# No internet, let it be
return
except DiscordException as err:
if err.code == ERROR_CODES.unknown_sticker:
failure = False
else:
failure = True
embed.title = 'Failure'
embed.description = repr(err)
else:
failure = False
if not failure:
embed.title = 'Success'
embed.description = f'Sticker {sticker.name!r} has been successfully edited.'
# Edit the source message
yield InteractionResponse(embed=embed, message=message, components=None)
def read(self, size=0, full=False, timeout=None):
"""Read at most 'size' bytes from file; if 'size' <= 0,
all data up to EOF is read and returned. If 'full' is
True, exactly 'size' bytes are returned (unless EOF or
timeout occur before). If EOF is encountered before any
more data is available, empty buffer is returned.
If no data has been read before timeout, then
IOError('timedout') will be thrown.
If timeout is given and full is True and timeout expires
before all the data could be read, it returns partial data
read before timeout if any data has been read.
Must be used in a coroutine with 'yield' as
'data = yield fd.read(1024)'
"""
def _read(size, full, rc, n):
if rc or n == 0:
if self._timeout:
self._notifier._del_timeout(self)
self._overlap.object = self._read_result = None
if rc != winerror.ERROR_OPERATION_ABORTED:
if (self._buflist or rc == winerror.ERROR_HANDLE_EOF or
rc == winerror.ERROR_BROKEN_PIPE):
buf, self._buflist = ''.join(self._buflist), []
self._read_coro._proceed_(buf)
return
self._read_coro.throw(IOError(rc, 'ReadFile', str(rc)))
self._overlap.object = self._read_coro = self._read_result = None
return
buf = self._read_result[:n]
if size > 0:
size -= len(buf)
assert size >= 0
if size == 0:
full = False
self._buflist.append(buf)
self._overlap.Offset += n
if full:
self._overlap.object = partial_func(_read, size, full)
try:
rc, _ = win32file.ReadFile(self._handle, self._read_result, self._overlap)
except pywintypes.error as exc:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
buf, self._buflist = ''.join(self._buflist), []
self._overlap.object = self._read_result = None
if self._timeout:
self._notifier._del_timeout(self)
self._read_coro._proceed_(buf)
self._read_coro = None
return
if self._buflist:
buf, self._buflist = ''.join(self._buflist), []
if self._timeout:
self._notifier._del_timeout(self)
self._overlap.object = self._read_result = None
self._read_coro._proceed_(buf)
self._read_coro = None
if not self._asyncoro:
self._asyncoro = AsynCoro.scheduler()
self._notifier = self._asyncoro._notifier
self._notifier.register(self._handle)
if not size or size < 0:
count = 16384
full = True
else:
if self._buflist:
buf, self._buflist = ''.join(self._buflist), []
if len(buf) > size:
buf, self._buflist = buf[:size], [buf[size:]]
if (not full) or (len(buf) == size):
return buf
self._buflist = [buf]
size -= len(buf)
count = size
self._read_result = win32file.AllocateReadBuffer(count)
self._overlap.object = partial_func(_read, size, full)
self._read_coro = AsynCoro.cur_coro(self._asyncoro)
self._read_coro._await_()
try:
rc, _ = win32file.ReadFile(self._handle, self._read_result, self._overlap)
except pywintypes.error as exc:
if exc.winerror == winerror.ERROR_BROKEN_PIPE:
buf, self._buflist = ''.join(self._buflist), []
self._read_coro._proceed_(buf)
self._read_result = self._read_coro = self._overlap.object = None
return
else:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
self._overlap.object = self._read_result = self._read_coro = None
self._read_coro.throw(IOError(rc, 'ReadFile', str(rc)))
if timeout:
self._timeout = timeout
self._notifier._add_timeout(self)
def write(self, buf, full=False, timeout=None):
"""Write data in 'buf' to file. If 'full' is True, the function
waits till all data in buf is written; otherwise, it waits
until one write completes. It returns length of data written.
If no data has been written before timeout, then
IOError('timedout') will be thrown.
If timeout is given and full is True and timeout expires
before all the data could be written, it returns length of
data written before timeout if any data has been written.
Must be used with 'yield' as
'n = yield fd.write(buf)' to write (some) data in buf.
"""
def _write(written, rc, n):
if rc or n == 0:
if self._timeout:
self._notifier._del_timeout(self)
if rc != winerror.ERROR_OPERATION_ABORTED:
if written:
self._write_coro._proceed_(written)
else:
self._write_coro.throw(IOError(rc, 'WriteFile', str(rc)))
self._overlap.object = self._write_coro = self._write_result = None
return
written += n
self._overlap.Offset += n
self._write_result = self._write_result[n:]
if not full or len(self._write_result) == 0:
self._overlap.object = self._write_result = None
if self._timeout:
self._notifier._del_timeout(self)
self._write_coro._proceed_(written)
self._write_coro = None
return
self._overlap.object = partial_func(_write, written)
try:
rc, _ = win32file.WriteFile(self._handle, self._write_result, self._overlap)
except pywintypes.error as exc:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
self._overlap.object = self._write_result = None
if self._timeout:
self._notifier._del_timeout(self)
if written:
self._write_coro._proceed_(written)
else:
self._write_coro.throw(IOError(rc, 'WriteFile', str(rc)))
self._write_coro = None
return
if not self._asyncoro:
self._asyncoro = AsynCoro.scheduler()
self._notifier = self._asyncoro._notifier
self._notifier.register(self._handle)
self._write_result = buffer(buf)
self._overlap.object = partial_func(_write, 0)
self._write_coro = AsynCoro.cur_coro(self._asyncoro)
self._write_coro._await_()
try:
rc, _ = win32file.WriteFile(self._handle, self._write_result, self._overlap)
except pywintypes.error as exc:
if exc.winerror == winerror.ERROR_BROKEN_PIPE:
self._write_coro._proceed_(0)
self._write_result = self._write_coro = self._overlap.object = None
return
else:
rc = exc.winerror
if rc and rc != winerror.ERROR_IO_PENDING:
self._overlap.object = self._write_result = self._write_coro = None
self._write_coro._proceed_(None)
raise IOError(rc, 'WriteFile', str(rc))
if timeout:
self._timeout = timeout
self._notifier._add_timeout(self)
def read(self, size=0, full=False, timeout=None):
"""Read at most 'size' bytes from file; if 'size' <= 0,
all data up to EOF is read and returned. If 'full' is
True, exactly 'size' bytes are returned (unless EOF or
timeout occur before). If EOF is encountered before any
more data is available, empty buffer is returned.
If no data has been read before timeout, then
IOError('timedout') will be thrown.
If timeout is given and full is True and timeout expires
before all the data could be read, it returns partial data
read before timeout if any data has been read.
Must be used in a coroutine with 'yield' as
'data = yield fd.read(1024)'
"""
def _read(size, full):
if size > 0:
count = size
else:
count = 16384
try:
buf = os.read(self._fileno, count)
except (OSError, IOError) as exc:
if exc.errno in (errno.EAGAIN, errno.EWOULDBLOCK):
return
else:
raise
except:
self._notifier.clear(self, _AsyncPoller._Read)
self._read_coro.throw(*sys.exc_info())
self._read_coro = self._read_task = None
return
if buf:
if size > 0:
size -= len(buf)
# assert size >= 0
if size == 0:
full = False
self._buflist.append(buf)
if full:
self._read_task = partial_func(_read, size, full)
return
if self._buflist:
buf, self._buflist = ''.join(self._buflist), []
self._notifier.clear(self, _AsyncPoller._Read)
self._read_coro._proceed_(buf)
self._read_coro = self._read_task = None
if not self._asyncoro:
self._asyncoro = AsynCoro.scheduler()
self._notifier = self._asyncoro._notifier
if hasattr(self._fd, '_fileno'):
self._notifier.unregister(self._fd)
if not size or size < 0:
size = 0
full = True
elif self._buflist:
buf, self._buflist = ''.join(self._buflist), []
if len(buf) > size:
buf, self._buflist = buf[:size], [buf[size:]]
if (not full) or (len(buf) == size):
return buf
self._buflist = [buf]
size -= len(buf)
self._timeout = timeout
self._read_coro = AsynCoro.cur_coro(self._asyncoro)
self._read_coro._await_()
self._read_task = partial_func(_read, size, full)
self._notifier.add(self, _AsyncPoller._Read)
def as_partial(self, end_time=None, **kwargs):
if kwargs.get("duration") == 0:
return None
obj = self.copy_with(partial=True, **kwargs)
object.__setattr__(obj, "apply", partial_func(obj.partially_apply, deadline=obj.end_time))
return obj
'is_owner_or_is_guild_owner',
'is_user_account',
'is_user_account_or_is_client',
*checks.__all__,
*utils.__all__,
)
from .checks import CheckHasRole, CheckIsOwnerOrHasRole, CheckHasAnyRole, CheckIsOwnerOrHasAnyRole, CheckIsInGuild, \
CheckIsInPrivate, CheckIsOwner, CheckIsGuildOwner, CheckIsOwnerOrIsGuildOwner, CheckHasPermission, \
CheckIsOwnerOrHasPermission, CheckHasGuildPermission, CheckIsOwnerHasGuildPermission, CheckHasClientPermission, \
CheckHasClientGuildPermission, CheckIsGuild, CheckIsAnyGuild, CheckCustom, CheckIsChannel, CheckIsAnyChannel, \
CheckIsNsfwChannel, CheckIsAnnouncementChannel, CheckIsInVoice, CheckIsBooster, CheckIsClient, CheckUserAccount, \
CheckBotAccount, CheckIsUserAccountOrIsClient, CheckIsCategory, CheckIsAnyCategory
has_role = partial_func(CommandCheckWrapper, CheckHasRole)
is_owner_or_has_role = partial_func(CommandCheckWrapper, CheckIsOwnerOrHasRole)
has_any_role = partial_func(CommandCheckWrapper, CheckHasAnyRole)
is_owner_or_has_any_role = partial_func(CommandCheckWrapper,
CheckIsOwnerOrHasAnyRole)
is_in_guild = partial_func(CommandCheckWrapper, CheckIsInGuild)
is_in_private = partial_func(CommandCheckWrapper, CheckIsInPrivate)
is_owner = partial_func(CommandCheckWrapper, CheckIsOwner)
is_guild_owner = partial_func(CommandCheckWrapper, CheckIsGuildOwner)
is_owner_or_is_guild_owner = partial_func(CommandCheckWrapper,
CheckIsOwnerOrIsGuildOwner)
has_permission = partial_func(CommandCheckWrapper, CheckHasPermission)
is_owner_or_has_permission = partial_func(CommandCheckWrapper,
CheckIsOwnerOrHasPermission)
has_guild_permission = partial_func(CommandCheckWrapper,
CheckHasGuildPermission)