dolfies
4 years ago
134 changed files with 10676 additions and 62503 deletions
@ -1,8 +1,8 @@ |
|||
blank_issues_enabled: false |
|||
contact_links: |
|||
- name: Ask a question |
|||
about: Ask questions and discuss with other users of the library. |
|||
url: https://github.com/Rapptz/discord.py/discussions |
|||
- name: Discord Server |
|||
about: Use our official Discord server to ask for help and questions as well. |
|||
url: https://discord.gg/r3sSKJJ |
|||
- name: Get help |
|||
url: https://github.com/dolfies/discord.py-self/discussions/new?category=help |
|||
about: Ask a question on our help page (*not* for bug reports). |
|||
- name: Suggest a feature |
|||
url: https://github.com/dolfies/discord.py-self/discussions/new?category=ideas |
|||
about: Suggest new features for the library! |
|||
|
|||
@ -0,0 +1,32 @@ |
|||
# This workflow will upload a Python Package using Twine when a release is created |
|||
# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries |
|||
|
|||
name: Upload Python Package |
|||
|
|||
on: |
|||
workflow_dispatch: |
|||
release: |
|||
types: [created] |
|||
|
|||
jobs: |
|||
deploy: |
|||
|
|||
runs-on: ubuntu-latest |
|||
|
|||
steps: |
|||
- uses: actions/checkout@v2 |
|||
- name: Set up Python |
|||
uses: actions/setup-python@v2 |
|||
with: |
|||
python-version: '3.x' |
|||
- name: Install dependencies |
|||
run: | |
|||
python -m pip install --upgrade pip |
|||
pip install setuptools wheel twine |
|||
- name: Build and publish |
|||
env: |
|||
TWINE_USERNAME: __token__ |
|||
TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} |
|||
run: | |
|||
python setup.py sdist bdist_wheel |
|||
twine upload dist/* |
|||
@ -1,113 +0,0 @@ |
|||
discord.py |
|||
========== |
|||
|
|||
.. image:: https://discord.com/api/guilds/336642139381301249/embed.png |
|||
:target: https://discord.gg/nXzj3dg |
|||
:alt: Discordサーバーの招待 |
|||
.. image:: https://img.shields.io/pypi/v/discord.py.svg |
|||
:target: https://pypi.python.org/pypi/discord.py |
|||
:alt: PyPIのバージョン情報 |
|||
.. image:: https://img.shields.io/pypi/pyversions/discord.py.svg |
|||
:target: https://pypi.python.org/pypi/discord.py |
|||
:alt: PyPIのサポートしているPythonのバージョン |
|||
|
|||
discord.py は機能豊富かつモダンで使いやすい、非同期処理にも対応したDiscord用のAPIラッパーです。 |
|||
|
|||
主な特徴 |
|||
------------- |
|||
|
|||
- ``async`` と ``await`` を使ったモダンなPythonらしいAPI。 |
|||
- 適切なレート制限処理 |
|||
- メモリと速度の両方を最適化。 |
|||
|
|||
インストール |
|||
------------- |
|||
|
|||
**Python 3.8 以降のバージョンが必須です** |
|||
|
|||
完全な音声サポートなしでライブラリをインストールする場合は次のコマンドを実行してください: |
|||
|
|||
.. code:: sh |
|||
|
|||
# Linux/OS X |
|||
python3 -m pip install -U discord.py |
|||
|
|||
# Windows |
|||
py -3 -m pip install -U discord.py |
|||
|
|||
音声サポートが必要なら、次のコマンドを実行しましょう: |
|||
|
|||
.. code:: sh |
|||
|
|||
# Linux/OS X |
|||
python3 -m pip install -U discord.py[voice] |
|||
|
|||
# Windows |
|||
py -3 -m pip install -U discord.py[voice] |
|||
|
|||
|
|||
開発版をインストールしたいのならば、次の手順に従ってください: |
|||
|
|||
.. code:: sh |
|||
|
|||
$ git clone https://github.com/Rapptz/discord.py |
|||
$ cd discord.py |
|||
$ python3 -m pip install -U .[voice] |
|||
|
|||
|
|||
オプションパッケージ |
|||
~~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
* PyNaCl (音声サポート用) |
|||
|
|||
Linuxで音声サポートを導入するには、前述のコマンドを実行する前にお気に入りのパッケージマネージャー(例えば ``apt`` や ``dnf`` など)を使って以下のパッケージをインストールする必要があります: |
|||
|
|||
* libffi-dev (システムによっては ``libffi-devel``) |
|||
* python-dev (例えばPython 3.6用の ``python3.6-dev``) |
|||
|
|||
簡単な例 |
|||
-------------- |
|||
|
|||
.. code:: py |
|||
|
|||
import discord |
|||
|
|||
class MyClient(discord.Client): |
|||
async def on_ready(self): |
|||
print('Logged on as', self.user) |
|||
|
|||
async def on_message(self, message): |
|||
# don't respond to ourselves |
|||
if message.author == self.user: |
|||
return |
|||
|
|||
if message.content == 'ping': |
|||
await message.channel.send('pong') |
|||
|
|||
client = MyClient() |
|||
client.run('token') |
|||
|
|||
Botの例 |
|||
~~~~~~~~~~~~~ |
|||
|
|||
.. code:: py |
|||
|
|||
import discord |
|||
from discord.ext import commands |
|||
|
|||
bot = commands.Bot(command_prefix='>') |
|||
|
|||
@bot.command() |
|||
async def ping(ctx): |
|||
await ctx.send('pong') |
|||
|
|||
bot.run('token') |
|||
|
|||
examplesディレクトリに更に多くのサンプルがあります。 |
|||
|
|||
リンク |
|||
------ |
|||
|
|||
- `ドキュメント <https://discordpy.readthedocs.io/ja/latest/index.html>`_ |
|||
- `公式Discordサーバー <https://discord.gg/nXzj3dg>`_ |
|||
- `Discord API <https://discord.gg/discord-api>`_ |
|||
@ -1,17 +0,0 @@ |
|||
""" |
|||
discord.app_commands |
|||
~~~~~~~~~~~~~~~~~~~~~ |
|||
|
|||
Application commands support for the Discord API |
|||
|
|||
:copyright: (c) 2015-present Rapptz |
|||
:license: MIT, see LICENSE for more details. |
|||
|
|||
""" |
|||
|
|||
from .commands import * |
|||
from .errors import * |
|||
from .models import * |
|||
from .tree import * |
|||
from .namespace import * |
|||
from .transformers import * |
|||
File diff suppressed because it is too large
@ -1,202 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import Any, TYPE_CHECKING, List, Optional, Type, Union |
|||
|
|||
|
|||
from ..enums import AppCommandOptionType, AppCommandType |
|||
from ..errors import DiscordException |
|||
|
|||
__all__ = ( |
|||
'AppCommandError', |
|||
'CommandInvokeError', |
|||
'TransformerError', |
|||
'CommandAlreadyRegistered', |
|||
'CommandSignatureMismatch', |
|||
'CommandNotFound', |
|||
) |
|||
|
|||
if TYPE_CHECKING: |
|||
from .commands import Command, Group, ContextMenu |
|||
from .transformers import Transformer |
|||
|
|||
|
|||
class AppCommandError(DiscordException): |
|||
"""The base exception type for all application command related errors. |
|||
|
|||
This inherits from :exc:`discord.DiscordException`. |
|||
|
|||
This exception and exceptions inherited from it are handled |
|||
in a special way as they are caught and passed into various error handlers |
|||
in this order: |
|||
|
|||
- :meth:`Command.error <discord.app_commands.Command.error>` |
|||
- :meth:`Group.on_error <discord.app_commands.Group.on_error>` |
|||
- :meth:`CommandTree.on_error <discord.app_commands.CommandTree.on_error>` |
|||
|
|||
.. versionadded:: 2.0 |
|||
""" |
|||
|
|||
pass |
|||
|
|||
|
|||
class CommandInvokeError(AppCommandError): |
|||
"""An exception raised when the command being invoked raised an exception. |
|||
|
|||
This inherits from :exc:`~discord.app_commands.AppCommandError`. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Attributes |
|||
----------- |
|||
original: :exc:`Exception` |
|||
The original exception that was raised. You can also get this via |
|||
the ``__cause__`` attribute. |
|||
command: Union[:class:`Command`, :class:`ContextMenu`] |
|||
The command that failed. |
|||
""" |
|||
|
|||
def __init__(self, command: Union[Command, ContextMenu], e: Exception) -> None: |
|||
self.original: Exception = e |
|||
self.command: Union[Command, ContextMenu] = command |
|||
super().__init__(f'Command {command.name!r} raised an exception: {e.__class__.__name__}: {e}') |
|||
|
|||
|
|||
class TransformerError(AppCommandError): |
|||
"""An exception raised when a :class:`Transformer` or type annotation fails to |
|||
convert to its target type. |
|||
|
|||
This inherits from :exc:`~discord.app_commands.AppCommandError`. |
|||
|
|||
.. note:: |
|||
|
|||
If the transformer raises a custom :exc:`AppCommandError` then it will |
|||
be propagated rather than wrapped into this exception. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Attributes |
|||
----------- |
|||
value: Any |
|||
The value that failed to convert. |
|||
type: :class:`~discord.AppCommandOptionType` |
|||
The type of argument that failed to convert. |
|||
transformer: Type[:class:`Transformer`] |
|||
The transformer that failed the conversion. |
|||
""" |
|||
|
|||
def __init__(self, value: Any, opt_type: AppCommandOptionType, transformer: Type[Transformer]): |
|||
self.value: Any = value |
|||
self.type: AppCommandOptionType = opt_type |
|||
self.transformer: Type[Transformer] = transformer |
|||
|
|||
try: |
|||
result_type = transformer.transform.__annotations__['return'] |
|||
except KeyError: |
|||
name = transformer.__name__ |
|||
if name.endswith('Transformer'): |
|||
result_type = name[:-11] |
|||
else: |
|||
result_type = name |
|||
else: |
|||
if isinstance(result_type, type): |
|||
result_type = result_type.__name__ |
|||
|
|||
super().__init__(f'Failed to convert {value} to {result_type!s}') |
|||
|
|||
|
|||
class CommandAlreadyRegistered(AppCommandError): |
|||
"""An exception raised when a command is already registered. |
|||
|
|||
This inherits from :exc:`~discord.app_commands.AppCommandError`. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Attributes |
|||
----------- |
|||
name: :class:`str` |
|||
The name of the command already registered. |
|||
guild_id: Optional[:class:`int`] |
|||
The guild ID this command was already registered at. |
|||
If ``None`` then it was a global command. |
|||
""" |
|||
|
|||
def __init__(self, name: str, guild_id: Optional[int]): |
|||
self.name: str = name |
|||
self.guild_id: Optional[int] = guild_id |
|||
super().__init__(f'Command {name!r} already registered.') |
|||
|
|||
|
|||
class CommandNotFound(AppCommandError): |
|||
"""An exception raised when an application command could not be found. |
|||
|
|||
This inherits from :exc:`~discord.app_commands.AppCommandError`. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Attributes |
|||
------------ |
|||
name: :class:`str` |
|||
The name of the application command not found. |
|||
parents: List[:class:`str`] |
|||
A list of parent command names that were previously found |
|||
prior to the application command not being found. |
|||
type: :class:`~discord.AppCommandType` |
|||
The type of command that was not found. |
|||
""" |
|||
|
|||
def __init__(self, name: str, parents: List[str], type: AppCommandType = AppCommandType.chat_input): |
|||
self.name: str = name |
|||
self.parents: List[str] = parents |
|||
self.type: AppCommandType = type |
|||
super().__init__(f'Application command {name!r} not found') |
|||
|
|||
|
|||
class CommandSignatureMismatch(AppCommandError): |
|||
"""An exception raised when an application command from Discord has a different signature |
|||
from the one provided in the code. This happens because your command definition differs |
|||
from the command definition you provided Discord. Either your code is out of date or the |
|||
data from Discord is out of sync. |
|||
|
|||
This inherits from :exc:`~discord.app_commands.AppCommandError`. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Attributes |
|||
------------ |
|||
command: Union[:class:`~.app_commands.Command`, :class:`~.app_commands.ContextMenu`, :class:`~.app_commands.Group`] |
|||
The command that had the signature mismatch. |
|||
""" |
|||
|
|||
def __init__(self, command: Union[Command, ContextMenu, Group]): |
|||
self.command: Union[Command, ContextMenu, Group] = command |
|||
msg = ( |
|||
f'The signature for command {command.name!r} is different from the one provided by Discord. ' |
|||
'This can happen because either your code is out of date or you have not synced the ' |
|||
'commands with Discord, causing the mismatch in data. It is recommended to sync the ' |
|||
'command tree to fix this issue.' |
|||
) |
|||
super().__init__(msg) |
|||
@ -1,609 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
from datetime import datetime |
|||
|
|||
|
|||
from ..permissions import Permissions |
|||
from ..enums import AppCommandOptionType, AppCommandType, ChannelType, try_enum |
|||
from ..mixins import Hashable |
|||
from ..utils import _get_as_snowflake, parse_time, snowflake_time |
|||
from typing import Generic, List, TYPE_CHECKING, Optional, TypeVar, Union |
|||
|
|||
__all__ = ( |
|||
'AppCommand', |
|||
'AppCommandGroup', |
|||
'AppCommandChannel', |
|||
'AppCommandThread', |
|||
'Argument', |
|||
'Choice', |
|||
) |
|||
|
|||
ChoiceT = TypeVar('ChoiceT', str, int, float, Union[str, int, float]) |
|||
|
|||
|
|||
def is_app_command_argument_type(value: int) -> bool: |
|||
return 11 >= value >= 3 |
|||
|
|||
|
|||
if TYPE_CHECKING: |
|||
from ..types.command import ( |
|||
ApplicationCommand as ApplicationCommandPayload, |
|||
ApplicationCommandOptionChoice, |
|||
ApplicationCommandOption, |
|||
) |
|||
from ..types.interactions import ( |
|||
PartialChannel, |
|||
PartialThread, |
|||
) |
|||
from ..types.threads import ThreadMetadata |
|||
from ..state import ConnectionState |
|||
from ..guild import GuildChannel, Guild |
|||
from ..channel import TextChannel |
|||
from ..threads import Thread |
|||
|
|||
ApplicationCommandParent = Union['AppCommand', 'AppCommandGroup'] |
|||
|
|||
|
|||
class AppCommand(Hashable): |
|||
"""Represents a application command. |
|||
|
|||
In common parlance this is referred to as a "Slash Command" or a |
|||
"Context Menu Command". |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
.. container:: operations |
|||
|
|||
.. describe:: x == y |
|||
|
|||
Checks if two application commands are equal. |
|||
|
|||
.. describe:: x != y |
|||
|
|||
Checks if two application commands are not equal. |
|||
|
|||
.. describe:: hash(x) |
|||
|
|||
Returns the application command's hash. |
|||
|
|||
.. describe:: str(x) |
|||
|
|||
Returns the application command's name. |
|||
|
|||
Attributes |
|||
----------- |
|||
id: :class:`int` |
|||
The application command's ID. |
|||
application_id: :class:`int` |
|||
The application command's application's ID. |
|||
type: :class:`~discord.AppCommandType` |
|||
The application command's type. |
|||
name: :class:`str` |
|||
The application command's name. |
|||
description: :class:`str` |
|||
The application command's description. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'id', |
|||
'type', |
|||
'application_id', |
|||
'name', |
|||
'description', |
|||
'options', |
|||
'_state', |
|||
) |
|||
|
|||
def __init__(self, *, data: ApplicationCommandPayload, state=None): |
|||
self._state = state |
|||
self._from_data(data) |
|||
|
|||
def _from_data(self, data: ApplicationCommandPayload): |
|||
self.id: int = int(data['id']) |
|||
self.application_id: int = int(data['application_id']) |
|||
self.name: str = data['name'] |
|||
self.description: str = data['description'] |
|||
self.type: AppCommandType = try_enum(AppCommandType, data.get('type', 1)) |
|||
self.options = [app_command_option_factory(data=d, parent=self, state=self._state) for d in data.get('options', [])] |
|||
|
|||
def to_dict(self) -> ApplicationCommandPayload: |
|||
return { |
|||
'id': self.id, |
|||
'type': self.type.value, |
|||
'application_id': self.application_id, |
|||
'name': self.name, |
|||
'description': self.description, |
|||
'options': [opt.to_dict() for opt in self.options], |
|||
} # type: ignore -- Type checker does not understand this literal. |
|||
|
|||
def __str__(self) -> str: |
|||
return self.name |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} id={self.id!r} name={self.name!r} type={self.type!r}>' |
|||
|
|||
|
|||
class Choice(Generic[ChoiceT]): |
|||
"""Represents an application command argument choice. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
.. container:: operations |
|||
|
|||
.. describe:: x == y |
|||
|
|||
Checks if two choices are equal. |
|||
|
|||
.. describe:: x != y |
|||
|
|||
Checks if two choices are not equal. |
|||
|
|||
.. describe:: hash(x) |
|||
|
|||
Returns the choice's hash. |
|||
|
|||
Parameters |
|||
----------- |
|||
name: :class:`str` |
|||
The name of the choice. Used for display purposes. |
|||
value: Union[:class:`int`, :class:`str`, :class:`float`] |
|||
The value of the choice. |
|||
""" |
|||
|
|||
__slots__ = ('name', 'value') |
|||
|
|||
def __init__(self, *, name: str, value: ChoiceT): |
|||
self.name: str = name |
|||
self.value: ChoiceT = value |
|||
|
|||
def __eq__(self, o: object) -> bool: |
|||
return isinstance(o, Choice) and self.name == o.name and self.value == o.value |
|||
|
|||
def __hash__(self) -> int: |
|||
return hash((self.name, self.value)) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'{self.__class__.__name__}(name={self.name!r}, value={self.value!r})' |
|||
|
|||
def to_dict(self) -> ApplicationCommandOptionChoice: |
|||
return { |
|||
'name': self.name, |
|||
'value': self.value, |
|||
} # type: ignore -- Type checker does not understand this literal. |
|||
|
|||
|
|||
class AppCommandChannel(Hashable): |
|||
"""Represents an application command partially resolved channel object. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
.. container:: operations |
|||
|
|||
.. describe:: x == y |
|||
|
|||
Checks if two channels are equal. |
|||
|
|||
.. describe:: x != y |
|||
|
|||
Checks if two channels are not equal. |
|||
|
|||
.. describe:: hash(x) |
|||
|
|||
Returns the channel's hash. |
|||
|
|||
.. describe:: str(x) |
|||
|
|||
Returns the channel's name. |
|||
|
|||
Attributes |
|||
----------- |
|||
id: :class:`int` |
|||
The ID of the channel. |
|||
type: :class:`~discord.ChannelType` |
|||
The type of channel. |
|||
name: :class:`str` |
|||
The name of the channel. |
|||
permissions: :class:`~discord.Permissions` |
|||
The resolved permissions of the user who invoked |
|||
the application command in that channel. |
|||
guild_id: :class:`int` |
|||
The guild ID this channel belongs to. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'id', |
|||
'type', |
|||
'name', |
|||
'permissions', |
|||
'guild_id', |
|||
'_state', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
state: ConnectionState, |
|||
data: PartialChannel, |
|||
guild_id: int, |
|||
): |
|||
self._state = state |
|||
self.guild_id = guild_id |
|||
self.id = int(data['id']) |
|||
self.type = try_enum(ChannelType, data['type']) |
|||
self.name = data['name'] |
|||
self.permissions = Permissions(int(data['permissions'])) |
|||
|
|||
def __str__(self) -> str: |
|||
return self.name |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} id={self.id!r} name={self.name!r} type={self.type!r}>' |
|||
|
|||
@property |
|||
def guild(self) -> Optional[Guild]: |
|||
"""Optional[:class:`~discord.Guild`]: The channel's guild, from cache, if found.""" |
|||
return self._state._get_guild(self.guild_id) |
|||
|
|||
def resolve(self) -> Optional[GuildChannel]: |
|||
"""Resolves the application command channel to the appropriate channel |
|||
from cache if found. |
|||
|
|||
Returns |
|||
-------- |
|||
Optional[:class:`.abc.GuildChannel`] |
|||
The resolved guild channel or ``None`` if not found in cache. |
|||
""" |
|||
guild = self._state._get_guild(self.guild_id) |
|||
if guild is not None: |
|||
return guild.get_channel(self.id) |
|||
return None |
|||
|
|||
async def fetch(self) -> GuildChannel: |
|||
"""|coro| |
|||
|
|||
Fetches the partial channel to a full :class:`.abc.GuildChannel`. |
|||
|
|||
Raises |
|||
-------- |
|||
NotFound |
|||
The channel was not found. |
|||
Forbidden |
|||
You do not have the permissions required to get a channel. |
|||
HTTPException |
|||
Retrieving the channel failed. |
|||
|
|||
Returns |
|||
-------- |
|||
:class:`.abc.GuildChannel` |
|||
The full channel. |
|||
""" |
|||
client = self._state._get_client() |
|||
return await client.fetch_channel(self.id) # type: ignore -- This is explicit narrowing |
|||
|
|||
@property |
|||
def mention(self) -> str: |
|||
""":class:`str`: The string that allows you to mention the channel.""" |
|||
return f'<#{self.id}>' |
|||
|
|||
@property |
|||
def created_at(self) -> datetime: |
|||
""":class:`datetime.datetime`: An aware timestamp of when this channel was created in UTC.""" |
|||
return snowflake_time(self.id) |
|||
|
|||
|
|||
class AppCommandThread(Hashable): |
|||
"""Represents an application command partially resolved thread object. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
.. container:: operations |
|||
|
|||
.. describe:: x == y |
|||
|
|||
Checks if two thread are equal. |
|||
|
|||
.. describe:: x != y |
|||
|
|||
Checks if two thread are not equal. |
|||
|
|||
.. describe:: hash(x) |
|||
|
|||
Returns the thread's hash. |
|||
|
|||
.. describe:: str(x) |
|||
|
|||
Returns the thread's name. |
|||
|
|||
Attributes |
|||
----------- |
|||
id: :class:`int` |
|||
The ID of the thread. |
|||
type: :class:`~discord.ChannelType` |
|||
The type of thread. |
|||
name: :class:`str` |
|||
The name of the thread. |
|||
parent_id: :class:`int` |
|||
The parent text channel ID this thread belongs to. |
|||
permissions: :class:`~discord.Permissions` |
|||
The resolved permissions of the user who invoked |
|||
the application command in that thread. |
|||
guild_id: :class:`int` |
|||
The guild ID this thread belongs to. |
|||
archived: :class:`bool` |
|||
Whether the thread is archived. |
|||
locked: :class:`bool` |
|||
Whether the thread is locked. |
|||
invitable: :class:`bool` |
|||
Whether non-moderators can add other non-moderators to this thread. |
|||
This is always ``True`` for public threads. |
|||
archiver_id: Optional[:class:`int`] |
|||
The user's ID that archived this thread. |
|||
auto_archive_duration: :class:`int` |
|||
The duration in minutes until the thread is automatically archived due to inactivity. |
|||
Usually a value of 60, 1440, 4320 and 10080. |
|||
archive_timestamp: :class:`datetime.datetime` |
|||
An aware timestamp of when the thread's archived status was last updated in UTC. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'id', |
|||
'type', |
|||
'name', |
|||
'permissions', |
|||
'guild_id', |
|||
'parent_id', |
|||
'archived', |
|||
'archiver_id', |
|||
'auto_archive_duration', |
|||
'archive_timestamp', |
|||
'locked', |
|||
'invitable', |
|||
'_created_at', |
|||
'_state', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
state: ConnectionState, |
|||
data: PartialThread, |
|||
guild_id: int, |
|||
): |
|||
self._state = state |
|||
self.guild_id = guild_id |
|||
self.id = int(data['id']) |
|||
self.parent_id = int(data['parent_id']) |
|||
self.type = try_enum(ChannelType, data['type']) |
|||
self.name = data['name'] |
|||
self.permissions = Permissions(int(data['permissions'])) |
|||
self._unroll_metadata(data['thread_metadata']) |
|||
|
|||
def __str__(self) -> str: |
|||
return self.name |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} id={self.id!r} name={self.name!r} archived={self.archived} type={self.type!r}>' |
|||
|
|||
@property |
|||
def guild(self) -> Optional[Guild]: |
|||
"""Optional[:class:`~discord.Guild`]: The channel's guild, from cache, if found.""" |
|||
return self._state._get_guild(self.guild_id) |
|||
|
|||
def _unroll_metadata(self, data: ThreadMetadata): |
|||
self.archived = data['archived'] |
|||
self.archiver_id = _get_as_snowflake(data, 'archiver_id') |
|||
self.auto_archive_duration = data['auto_archive_duration'] |
|||
self.archive_timestamp = parse_time(data['archive_timestamp']) |
|||
self.locked = data.get('locked', False) |
|||
self.invitable = data.get('invitable', True) |
|||
self._created_at = parse_time(data.get('create_timestamp')) |
|||
|
|||
@property |
|||
def parent(self) -> Optional[TextChannel]: |
|||
"""Optional[:class:`~discord.TextChannel`]: The parent channel this thread belongs to.""" |
|||
return self.guild.get_channel(self.parent_id) # type: ignore |
|||
|
|||
@property |
|||
def mention(self) -> str: |
|||
""":class:`str`: The string that allows you to mention the thread.""" |
|||
return f'<#{self.id}>' |
|||
|
|||
@property |
|||
def created_at(self) -> Optional[datetime]: |
|||
"""An aware timestamp of when the thread was created in UTC. |
|||
|
|||
.. note:: |
|||
|
|||
This timestamp only exists for threads created after 9 January 2022, otherwise returns ``None``. |
|||
""" |
|||
return self._created_at |
|||
|
|||
def resolve(self) -> Optional[Thread]: |
|||
"""Resolves the application command channel to the appropriate channel |
|||
from cache if found. |
|||
|
|||
Returns |
|||
-------- |
|||
Optional[:class:`.abc.GuildChannel`] |
|||
The resolved guild channel or ``None`` if not found in cache. |
|||
""" |
|||
guild = self._state._get_guild(self.guild_id) |
|||
if guild is not None: |
|||
return guild.get_thread(self.id) |
|||
return None |
|||
|
|||
async def fetch(self) -> Thread: |
|||
"""|coro| |
|||
|
|||
Fetches the partial channel to a full :class:`~discord.Thread`. |
|||
|
|||
Raises |
|||
-------- |
|||
NotFound |
|||
The thread was not found. |
|||
Forbidden |
|||
You do not have the permissions required to get a thread. |
|||
HTTPException |
|||
Retrieving the thread failed. |
|||
|
|||
Returns |
|||
-------- |
|||
:class:`~discord.Thread` |
|||
The full thread. |
|||
""" |
|||
client = self._state._get_client() |
|||
return await client.fetch_channel(self.id) # type: ignore -- This is explicit narrowing |
|||
|
|||
|
|||
class Argument: |
|||
"""Represents a application command argument. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Attributes |
|||
------------ |
|||
type: :class:`~discord.AppCommandOptionType` |
|||
The type of argument. |
|||
name: :class:`str` |
|||
The name of the argument. |
|||
description: :class:`str` |
|||
The description of the argument. |
|||
required: :class:`bool` |
|||
Whether the argument is required. |
|||
choices: List[:class:`Choice`] |
|||
A list of choices for the command to choose from for this argument. |
|||
parent: Union[:class:`AppCommand`, :class:`AppCommandGroup`] |
|||
The parent application command that has this argument. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'type', |
|||
'name', |
|||
'description', |
|||
'required', |
|||
'choices', |
|||
'parent', |
|||
'_state', |
|||
) |
|||
|
|||
def __init__(self, *, parent: ApplicationCommandParent, data: ApplicationCommandOption, state=None): |
|||
self._state = state |
|||
self.parent = parent |
|||
self._from_data(data) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} name={self.name!r} type={self.type!r} required={self.required}>' |
|||
|
|||
def _from_data(self, data: ApplicationCommandOption): |
|||
self.type: AppCommandOptionType = try_enum(AppCommandOptionType, data['type']) |
|||
self.name: str = data['name'] |
|||
self.description: str = data['description'] |
|||
self.required: bool = data.get('required', False) |
|||
self.choices: List[Choice] = [Choice(name=d['name'], value=d['value']) for d in data.get('choices', [])] |
|||
|
|||
def to_dict(self) -> ApplicationCommandOption: |
|||
return { |
|||
'name': self.name, |
|||
'type': self.type.value, |
|||
'description': self.description, |
|||
'required': self.required, |
|||
'choices': [choice.to_dict() for choice in self.choices], |
|||
'options': [], |
|||
} # type: ignore -- Type checker does not understand this literal. |
|||
|
|||
|
|||
class AppCommandGroup: |
|||
"""Represents a application command subcommand. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Attributes |
|||
------------ |
|||
type: :class:`~discord.AppCommandOptionType` |
|||
The type of subcommand. |
|||
name: :class:`str` |
|||
The name of the subcommand. |
|||
description: :class:`str` |
|||
The description of the subcommand. |
|||
required: :class:`bool` |
|||
Whether the subcommand is required. |
|||
choices: List[:class:`Choice`] |
|||
A list of choices for the command to choose from for this subcommand. |
|||
arguments: List[:class:`Argument`] |
|||
A list of arguments. |
|||
parent: Union[:class:`AppCommand`, :class:`AppCommandGroup`] |
|||
The parent application command. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'type', |
|||
'name', |
|||
'description', |
|||
'required', |
|||
'choices', |
|||
'arguments', |
|||
'parent', |
|||
'_state', |
|||
) |
|||
|
|||
def __init__(self, *, parent: ApplicationCommandParent, data: ApplicationCommandOption, state=None): |
|||
self.parent = parent |
|||
self._state = state |
|||
self._from_data(data) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} name={self.name!r} type={self.type!r} required={self.required}>' |
|||
|
|||
def _from_data(self, data: ApplicationCommandOption): |
|||
self.type: AppCommandOptionType = try_enum(AppCommandOptionType, data['type']) |
|||
self.name: str = data['name'] |
|||
self.description: str = data['description'] |
|||
self.required: bool = data.get('required', False) |
|||
self.choices: List[Choice] = [Choice(name=d['name'], value=d['value']) for d in data.get('choices', [])] |
|||
self.arguments: List[Argument] = [ |
|||
Argument(parent=self, state=self._state, data=d) |
|||
for d in data.get('options', []) |
|||
if is_app_command_argument_type(d['type']) |
|||
] |
|||
|
|||
def to_dict(self) -> 'ApplicationCommandOption': |
|||
return { |
|||
'name': self.name, |
|||
'type': self.type.value, |
|||
'description': self.description, |
|||
'required': self.required, |
|||
'choices': [choice.to_dict() for choice in self.choices], |
|||
'options': [arg.to_dict() for arg in self.arguments], |
|||
} # type: ignore -- Type checker does not understand this literal. |
|||
|
|||
|
|||
def app_command_option_factory( |
|||
parent: ApplicationCommandParent, data: ApplicationCommandOption, *, state=None |
|||
) -> Union[Argument, AppCommandGroup]: |
|||
if is_app_command_argument_type(data['type']): |
|||
return Argument(parent=parent, data=data, state=state) |
|||
else: |
|||
return AppCommandGroup(parent=parent, data=data, state=state) |
|||
@ -1,218 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import TYPE_CHECKING, Any, Dict, Iterable, List, NamedTuple, Tuple |
|||
from ..interactions import Interaction |
|||
from ..member import Member |
|||
from ..object import Object |
|||
from ..role import Role |
|||
from ..message import Message, Attachment |
|||
from ..channel import PartialMessageable |
|||
from ..enums import AppCommandOptionType |
|||
from .models import AppCommandChannel, AppCommandThread |
|||
|
|||
if TYPE_CHECKING: |
|||
from ..types.interactions import ResolvedData, ApplicationCommandInteractionDataOption |
|||
|
|||
__all__ = ('Namespace',) |
|||
|
|||
|
|||
class ResolveKey(NamedTuple): |
|||
id: str |
|||
# CommandOptionType does not use 0 or negative numbers so those can be safe for library |
|||
# internal use, if necessary. Likewise, only 6, 7, 8, and 11 are actually in use. |
|||
type: int |
|||
|
|||
@classmethod |
|||
def any_with(cls, id: str) -> ResolveKey: |
|||
return ResolveKey(id=id, type=-1) |
|||
|
|||
def __eq__(self, o: object) -> bool: |
|||
if not isinstance(o, ResolveKey): |
|||
return NotImplemented |
|||
if self.type == -1 or o.type == -1: |
|||
return self.id == o.id |
|||
return (self.id, self.type) == (o.id, o.type) |
|||
|
|||
def __hash__(self) -> int: |
|||
# Most of the time an ID lookup is all that is necessary |
|||
# In case of collision then we look up both the ID and the type. |
|||
return hash(self.id) |
|||
|
|||
|
|||
class Namespace: |
|||
"""An object that holds the parameters being passed to a command in a mostly raw state. |
|||
|
|||
This class is deliberately simple and just holds the option name and resolved value as a simple |
|||
key-pair mapping. These attributes can be accessed using dot notation. For example, an option |
|||
with the name of ``example`` can be accessed using ``ns.example``. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
.. container:: operations |
|||
|
|||
.. describe:: x == y |
|||
|
|||
Checks if two namespaces are equal by checking if all attributes are equal. |
|||
.. describe:: x != y |
|||
|
|||
Checks if two namespaces are not equal. |
|||
|
|||
This namespace object converts resolved objects into their appropriate form depending on their |
|||
type. Consult the table below for conversion information. |
|||
|
|||
+-------------------------------------------+-------------------------------------------------------------------------------+ |
|||
| Option Type | Resolved Type | |
|||
+===========================================+===============================================================================+ |
|||
| :attr:`.AppCommandOptionType.string` | :class:`str` | |
|||
+-------------------------------------------+-------------------------------------------------------------------------------+ |
|||
| :attr:`.AppCommandOptionType.integer` | :class:`int` | |
|||
+-------------------------------------------+-------------------------------------------------------------------------------+ |
|||
| :attr:`.AppCommandOptionType.boolean` | :class:`bool` | |
|||
+-------------------------------------------+-------------------------------------------------------------------------------+ |
|||
| :attr:`.AppCommandOptionType.number` | :class:`float` | |
|||
+-------------------------------------------+-------------------------------------------------------------------------------+ |
|||
| :attr:`.AppCommandOptionType.user` | :class:`~discord.User` or :class:`~discord.Member` | |
|||
+-------------------------------------------+-------------------------------------------------------------------------------+ |
|||
| :attr:`.AppCommandOptionType.channel` | :class:`.AppCommandChannel` or :class:`.AppCommandThread` | |
|||
+-------------------------------------------+-------------------------------------------------------------------------------+ |
|||
| :attr:`.AppCommandOptionType.role` | :class:`~discord.Role` | |
|||
+-------------------------------------------+-------------------------------------------------------------------------------+ |
|||
| :attr:`.AppCommandOptionType.mentionable` | :class:`~discord.User` or :class:`~discord.Member`, or :class:`~discord.Role` | |
|||
+-------------------------------------------+-------------------------------------------------------------------------------+ |
|||
| :attr:`.AppCommandOptionType.attachment` | :class:`~discord.Attachment` | |
|||
+-------------------------------------------+-------------------------------------------------------------------------------+ |
|||
""" |
|||
|
|||
def __init__( |
|||
self, |
|||
interaction: Interaction, |
|||
resolved: ResolvedData, |
|||
options: List[ApplicationCommandInteractionDataOption], |
|||
): |
|||
completed = self._get_resolved_items(interaction, resolved) |
|||
for option in options: |
|||
opt_type = option['type'] |
|||
name = option['name'] |
|||
if opt_type in (3, 4, 5): # string, integer, boolean |
|||
value = option['value'] # type: ignore -- Key is there |
|||
self.__dict__[name] = value |
|||
elif opt_type == 10: # number |
|||
value = option['value'] # type: ignore -- Key is there |
|||
if value is None: |
|||
self.__dict__[name] = float('nan') |
|||
else: |
|||
self.__dict__[name] = float(value) |
|||
elif opt_type in (6, 7, 8, 9, 11): |
|||
# Remaining ones should be snowflake based ones with resolved data |
|||
snowflake: str = option['value'] # type: ignore -- Key is there |
|||
if opt_type == 9: # Mentionable |
|||
# Mentionable is User | Role, these do not cause any conflict |
|||
key = ResolveKey.any_with(snowflake) |
|||
else: |
|||
# The remaining keys can conflict, for example, a role and a channel |
|||
# could end up with the same ID in very old guilds since they used to default |
|||
# to sharing the guild ID. Old general channels no longer exist, but some old |
|||
# servers will still have them so this needs to be handled. |
|||
key = ResolveKey(id=snowflake, type=opt_type) |
|||
|
|||
value = completed.get(key) |
|||
self.__dict__[name] = value |
|||
|
|||
@classmethod |
|||
def _get_resolved_items(cls, interaction: Interaction, resolved: ResolvedData) -> Dict[ResolveKey, Any]: |
|||
completed: Dict[ResolveKey, Any] = {} |
|||
state = interaction._state |
|||
members = resolved.get('members', {}) |
|||
guild_id = interaction.guild_id |
|||
guild = (state._get_guild(guild_id) or Object(id=guild_id)) if guild_id is not None else None |
|||
type = AppCommandOptionType.user.value |
|||
for (user_id, user_data) in resolved.get('users', {}).items(): |
|||
try: |
|||
member_data = members[user_id] |
|||
except KeyError: |
|||
completed[ResolveKey(id=user_id, type=type)] = state.create_user(user_data) |
|||
else: |
|||
member_data['user'] = user_data |
|||
# Guild ID can't be None in this case. |
|||
# There's a type mismatch here that I don't actually care about |
|||
member = Member(state=state, guild=guild, data=member_data) # type: ignore |
|||
completed[ResolveKey(id=user_id, type=type)] = member |
|||
|
|||
type = AppCommandOptionType.role.value |
|||
completed.update( |
|||
{ |
|||
# The guild ID can't be None in this case. |
|||
ResolveKey(id=role_id, type=type): Role(guild=guild, state=state, data=role_data) # type: ignore |
|||
for role_id, role_data in resolved.get('roles', {}).items() |
|||
} |
|||
) |
|||
|
|||
type = AppCommandOptionType.channel.value |
|||
for (channel_id, channel_data) in resolved.get('channels', {}).items(): |
|||
key = ResolveKey(id=channel_id, type=type) |
|||
if channel_data['type'] in (10, 11, 12): |
|||
# The guild ID can't be none in this case |
|||
completed[key] = AppCommandThread(state=state, data=channel_data, guild_id=guild_id) # type: ignore |
|||
else: |
|||
# The guild ID can't be none in this case |
|||
completed[key] = AppCommandChannel(state=state, data=channel_data, guild_id=guild_id) # type: ignore |
|||
|
|||
type = AppCommandOptionType.attachment.value |
|||
completed.update( |
|||
{ |
|||
ResolveKey(id=attachment_id, type=type): Attachment(data=attachment_data, state=state) |
|||
for attachment_id, attachment_data in resolved.get('attachments', {}).items() |
|||
} |
|||
) |
|||
|
|||
guild = state._get_guild(guild_id) |
|||
for (message_id, message_data) in resolved.get('messages', {}).items(): |
|||
channel_id = int(message_data['channel_id']) |
|||
if guild is None: |
|||
channel = PartialMessageable(state=state, id=channel_id) |
|||
else: |
|||
channel = guild.get_channel_or_thread(channel_id) or PartialMessageable(state=state, id=channel_id) |
|||
|
|||
# Type checker doesn't understand this due to failure to narrow |
|||
message = Message(state=state, channel=channel, data=message_data) # type: ignore |
|||
key = ResolveKey(id=message_id, type=-1) |
|||
completed[key] = message |
|||
|
|||
return completed |
|||
|
|||
def __repr__(self) -> str: |
|||
items = (f'{k}={v!r}' for k, v in self.__dict__.items()) |
|||
return '<{} {}>'.format(self.__class__.__name__, ' '.join(items)) |
|||
|
|||
def __eq__(self, other: object) -> bool: |
|||
if isinstance(self, Namespace) and isinstance(other, Namespace): |
|||
return self.__dict__ == other.__dict__ |
|||
return NotImplemented |
|||
|
|||
def _update_with_defaults(self, defaults: Iterable[Tuple[str, Any]]) -> None: |
|||
for key, value in defaults: |
|||
self.__dict__.setdefault(key, value) |
|||
@ -1,664 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
import inspect |
|||
|
|||
from dataclasses import dataclass |
|||
from enum import Enum |
|||
from typing import ( |
|||
TYPE_CHECKING, |
|||
Any, |
|||
Callable, |
|||
ClassVar, |
|||
Coroutine, |
|||
Dict, |
|||
List, |
|||
Literal, |
|||
Optional, |
|||
Set, |
|||
Tuple, |
|||
Type, |
|||
TypeVar, |
|||
Union, |
|||
) |
|||
|
|||
from .errors import TransformerError |
|||
from .models import AppCommandChannel, AppCommandThread, Choice |
|||
from ..channel import StageChannel, StoreChannel, VoiceChannel, TextChannel, CategoryChannel |
|||
from ..enums import AppCommandOptionType, ChannelType |
|||
from ..utils import MISSING |
|||
from ..user import User |
|||
from ..role import Role |
|||
from ..member import Member |
|||
from ..message import Attachment |
|||
|
|||
__all__ = ( |
|||
'Transformer', |
|||
'Transform', |
|||
'Range', |
|||
) |
|||
|
|||
T = TypeVar('T') |
|||
NoneType = type(None) |
|||
|
|||
if TYPE_CHECKING: |
|||
from ..interactions import Interaction |
|||
|
|||
|
|||
@dataclass |
|||
class CommandParameter: |
|||
"""Represents a application command parameter. |
|||
|
|||
Attributes |
|||
----------- |
|||
name: :class:`str` |
|||
The name of the parameter. |
|||
description: :class:`str` |
|||
The description of the parameter |
|||
required: :class:`bool` |
|||
Whether the parameter is required |
|||
choices: List[:class:`~discord.app_commands.Choice`] |
|||
A list of choices this parameter takes |
|||
type: :class:`~discord.AppCommandOptionType` |
|||
The underlying type of this parameter. |
|||
channel_types: List[:class:`~discord.ChannelType`] |
|||
The channel types that are allowed for this parameter. |
|||
min_value: Optional[Union[:class:`int`, :class:`float`]] |
|||
The minimum supported value for this parameter. |
|||
max_value: Optional[Union[:class:`int`, :class:`float`]] |
|||
The maximum supported value for this parameter. |
|||
""" |
|||
|
|||
name: str = MISSING |
|||
description: str = MISSING |
|||
required: bool = MISSING |
|||
default: Any = MISSING |
|||
choices: List[Choice] = MISSING |
|||
type: AppCommandOptionType = MISSING |
|||
channel_types: List[ChannelType] = MISSING |
|||
min_value: Optional[Union[int, float]] = None |
|||
max_value: Optional[Union[int, float]] = None |
|||
autocomplete: Optional[Callable[..., Coroutine[Any, Any, Any]]] = None |
|||
_annotation: Any = MISSING |
|||
|
|||
def to_dict(self) -> Dict[str, Any]: |
|||
base = { |
|||
'type': self.type.value, |
|||
'name': self.name, |
|||
'description': self.description, |
|||
'required': self.required, |
|||
} |
|||
|
|||
if self.choices: |
|||
base['choices'] = [choice.to_dict() for choice in self.choices] |
|||
if self.channel_types: |
|||
base['channel_types'] = [t.value for t in self.channel_types] |
|||
if self.autocomplete: |
|||
base['autocomplete'] = True |
|||
if self.min_value is not None: |
|||
base['min_value'] = self.min_value |
|||
if self.max_value is not None: |
|||
base['max_value'] = self.max_value |
|||
|
|||
return base |
|||
|
|||
async def transform(self, interaction: Interaction, value: Any) -> Any: |
|||
if hasattr(self._annotation, '__discord_app_commands_transformer__'): |
|||
# This one needs special handling for type safety reasons |
|||
if self._annotation.__discord_app_commands_is_choice__: |
|||
choice = next((c for c in self.choices if c.value == value), None) |
|||
if choice is None: |
|||
raise TransformerError(value, self.type, self._annotation) |
|||
return choice |
|||
|
|||
return await self._annotation.transform(interaction, value) |
|||
return value |
|||
|
|||
|
|||
class Transformer: |
|||
"""The base class that allows a type annotation in an application command parameter |
|||
to map into a :class:`~discord.AppCommandOptionType` and transform the raw value into one |
|||
from this type. |
|||
|
|||
This class is customisable through the overriding of :func:`classmethod` in the class |
|||
and by using it as the second type parameter of the :class:`~discord.app_commands.Transform` |
|||
class. For example, to convert a string into a custom pair type: |
|||
|
|||
.. code-block:: python3 |
|||
|
|||
class Point(typing.NamedTuple): |
|||
x: int |
|||
y: int |
|||
|
|||
class PointTransformer(app_commands.Transformer): |
|||
@classmethod |
|||
async def transform(cls, interaction: discord.Interaction, value: str) -> Point: |
|||
(x, _, y) = value.partition(',') |
|||
return Point(x=int(x.strip()), y=int(y.strip())) |
|||
|
|||
@app_commands.command() |
|||
async def graph( |
|||
interaction: discord.Interaction, |
|||
point: app_commands.Transform[Point, PointTransformer], |
|||
): |
|||
await interaction.response.send_message(str(point)) |
|||
|
|||
.. versionadded:: 2.0 |
|||
""" |
|||
|
|||
__discord_app_commands_transformer__: ClassVar[bool] = True |
|||
__discord_app_commands_is_choice__: ClassVar[bool] = False |
|||
|
|||
@classmethod |
|||
def type(cls) -> AppCommandOptionType: |
|||
""":class:`~discord.AppCommandOptionType`: The option type associated with this transformer. |
|||
|
|||
This must be a :obj:`classmethod`. |
|||
|
|||
Defaults to :attr:`~discord.AppCommandOptionType.string`. |
|||
""" |
|||
return AppCommandOptionType.string |
|||
|
|||
@classmethod |
|||
def channel_types(cls) -> List[ChannelType]: |
|||
"""List[:class:`~discord.ChannelType`]: A list of channel types that are allowed to this parameter. |
|||
|
|||
Only valid if the :meth:`type` returns :attr:`~discord.AppCommandOptionType.channel`. |
|||
|
|||
Defaults to an empty list. |
|||
""" |
|||
return [] |
|||
|
|||
@classmethod |
|||
def min_value(cls) -> Optional[Union[int, float]]: |
|||
"""Optional[:class:`int`]: The minimum supported value for this parameter. |
|||
|
|||
Only valid if the :meth:`type` returns :attr:`~discord.AppCommandOptionType.number` or |
|||
:attr:`~discord.AppCommandOptionType.integer`. |
|||
|
|||
Defaults to ``None``. |
|||
""" |
|||
return None |
|||
|
|||
@classmethod |
|||
def max_value(cls) -> Optional[Union[int, float]]: |
|||
"""Optional[:class:`int`]: The maximum supported value for this parameter. |
|||
|
|||
Only valid if the :meth:`type` returns :attr:`~discord.AppCommandOptionType.number` or |
|||
:attr:`~discord.AppCommandOptionType.integer`. |
|||
|
|||
Defaults to ``None``. |
|||
""" |
|||
return None |
|||
|
|||
@classmethod |
|||
async def transform(cls, interaction: Interaction, value: Any) -> Any: |
|||
"""|coro| |
|||
|
|||
Transforms the converted option value into another value. |
|||
|
|||
The value passed into this transform function is the same as the |
|||
one in the :class:`conversion table <discord.app_commands.Namespace>`. |
|||
|
|||
Parameters |
|||
----------- |
|||
interaction: :class:`~discord.Interaction` |
|||
The interaction being handled. |
|||
value: Any |
|||
The value of the given argument after being resolved. |
|||
See the :class:`conversion table <discord.app_commands.Namespace>` |
|||
for how certain option types correspond to certain values. |
|||
""" |
|||
raise NotImplementedError('Derived classes need to implement this.') |
|||
|
|||
|
|||
class _TransformMetadata: |
|||
__discord_app_commands_transform__: ClassVar[bool] = True |
|||
__slots__ = ('metadata',) |
|||
|
|||
def __init__(self, metadata: Type[Transformer]): |
|||
self.metadata: Type[Transformer] = metadata |
|||
|
|||
|
|||
async def _identity_transform(cls, interaction: Interaction, value: Any) -> Any: |
|||
return value |
|||
|
|||
|
|||
def _make_range_transformer( |
|||
opt_type: AppCommandOptionType, |
|||
*, |
|||
min: Optional[Union[int, float]] = None, |
|||
max: Optional[Union[int, float]] = None, |
|||
) -> Type[Transformer]: |
|||
ns = { |
|||
'type': classmethod(lambda _: opt_type), |
|||
'min_value': classmethod(lambda _: min), |
|||
'max_value': classmethod(lambda _: max), |
|||
'transform': classmethod(_identity_transform), |
|||
} |
|||
return type('RangeTransformer', (Transformer,), ns) |
|||
|
|||
|
|||
def _make_literal_transformer(values: Tuple[Any, ...]) -> Type[Transformer]: |
|||
if len(values) < 2: |
|||
raise TypeError(f'typing.Literal requires at least two values.') |
|||
|
|||
first = type(values[0]) |
|||
if first is int: |
|||
opt_type = AppCommandOptionType.integer |
|||
elif first is float: |
|||
opt_type = AppCommandOptionType.number |
|||
elif first is str: |
|||
opt_type = AppCommandOptionType.string |
|||
else: |
|||
raise TypeError(f'expected int, str, or float values not {first!r}') |
|||
|
|||
ns = { |
|||
'type': classmethod(lambda _: opt_type), |
|||
'transform': classmethod(_identity_transform), |
|||
'__discord_app_commands_transformer_choices__': [Choice(name=str(v), value=v) for v in values], |
|||
} |
|||
return type('LiteralTransformer', (Transformer,), ns) |
|||
|
|||
|
|||
def _make_choice_transformer(inner_type: Any) -> Type[Transformer]: |
|||
if inner_type is int: |
|||
opt_type = AppCommandOptionType.integer |
|||
elif inner_type is float: |
|||
opt_type = AppCommandOptionType.number |
|||
elif inner_type is str: |
|||
opt_type = AppCommandOptionType.string |
|||
else: |
|||
raise TypeError(f'expected int, str, or float values not {inner_type!r}') |
|||
|
|||
ns = { |
|||
'type': classmethod(lambda _: opt_type), |
|||
'transform': classmethod(_identity_transform), |
|||
'__discord_app_commands_is_choice__': True, |
|||
} |
|||
return type('ChoiceTransformer', (Transformer,), ns) |
|||
|
|||
|
|||
def _make_enum_transformer(enum) -> Type[Transformer]: |
|||
values = list(enum) |
|||
if len(values) < 2: |
|||
raise TypeError(f'enum.Enum requires at least two values.') |
|||
|
|||
first = type(values[0].value) |
|||
if first is int: |
|||
opt_type = AppCommandOptionType.integer |
|||
elif first is float: |
|||
opt_type = AppCommandOptionType.number |
|||
elif first is str: |
|||
opt_type = AppCommandOptionType.string |
|||
else: |
|||
raise TypeError(f'expected int, str, or float values not {first!r}') |
|||
|
|||
async def transform(cls, interaction: Interaction, value: Any) -> Any: |
|||
return enum(value) |
|||
|
|||
ns = { |
|||
'type': classmethod(lambda _: opt_type), |
|||
'transform': classmethod(transform), |
|||
'__discord_app_commands_transformer_enum__': enum, |
|||
'__discord_app_commands_transformer_choices__': [Choice(name=v.name, value=v.value) for v in values], |
|||
} |
|||
|
|||
return type(f'{enum.__name__}EnumTransformer', (Transformer,), ns) |
|||
|
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Annotated as Transform |
|||
from typing_extensions import Annotated as Range |
|||
else: |
|||
|
|||
class Transform: |
|||
"""A type annotation that can be applied to a parameter to customise the behaviour of |
|||
an option type by transforming with the given :class:`Transformer`. This requires |
|||
the usage of two generic parameters, the first one is the type you're converting to and the second |
|||
one is the type of the :class:`Transformer` actually doing the transformation. |
|||
|
|||
During type checking time this is equivalent to :obj:`typing.Annotated` so type checkers understand |
|||
the intent of the code. |
|||
|
|||
For example usage, check :class:`Transformer`. |
|||
|
|||
.. versionadded:: 2.0 |
|||
""" |
|||
|
|||
def __class_getitem__(cls, items) -> _TransformMetadata: |
|||
if not isinstance(items, tuple): |
|||
raise TypeError(f'expected tuple for arguments, received {items.__class__!r} instead') |
|||
|
|||
if len(items) != 2: |
|||
raise TypeError(f'Transform only accepts exactly two arguments') |
|||
|
|||
_, transformer = items |
|||
|
|||
is_valid = inspect.isclass(transformer) and issubclass(transformer, Transformer) |
|||
if not is_valid: |
|||
raise TypeError(f'second argument of Transform must be a Transformer class not {transformer!r}') |
|||
|
|||
return _TransformMetadata(transformer) |
|||
|
|||
class Range: |
|||
"""A type annotation that can be applied to a parameter to require a numeric type |
|||
to fit within the range provided. |
|||
|
|||
During type checking time this is equivalent to :obj:`typing.Annotated` so type checkers understand |
|||
the intent of the code. |
|||
|
|||
Some example ranges: |
|||
|
|||
- ``Range[int, 10]`` means the minimum is 10 with no maximum. |
|||
- ``Range[int, None, 10]`` means the maximum is 10 with no minimum. |
|||
- ``Range[int, 1, 10]`` means the minimum is 1 and the maximum is 10. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Examples |
|||
---------- |
|||
|
|||
.. code-block:: python3 |
|||
|
|||
@app_commands.command() |
|||
async def range(interaction: discord.Interaction, value: app_commands.Range[int, 10, 12]): |
|||
await interaction.response.send_message(f'Your value is {value}', ephemeral=True) |
|||
""" |
|||
|
|||
def __class_getitem__(cls, obj) -> _TransformMetadata: |
|||
if not isinstance(obj, tuple): |
|||
raise TypeError(f'expected tuple for arguments, received {obj.__class__!r} instead') |
|||
|
|||
if len(obj) == 2: |
|||
obj = (*obj, None) |
|||
elif len(obj) != 3: |
|||
raise TypeError('Range accepts either two or three arguments with the first being the type of range.') |
|||
|
|||
obj_type, min, max = obj |
|||
|
|||
if min is None and max is None: |
|||
raise TypeError('Range must not be empty') |
|||
|
|||
if min is not None and max is not None: |
|||
# At this point max and min are both not none |
|||
if type(min) != type(max): |
|||
raise TypeError('Both min and max in Range must be the same type') |
|||
|
|||
if obj_type is int: |
|||
opt_type = AppCommandOptionType.integer |
|||
elif obj_type is float: |
|||
opt_type = AppCommandOptionType.number |
|||
else: |
|||
raise TypeError(f'expected int or float as range type, received {obj_type!r} instead') |
|||
|
|||
transformer = _make_range_transformer( |
|||
opt_type, |
|||
min=obj_type(min) if min is not None else None, |
|||
max=obj_type(max) if max is not None else None, |
|||
) |
|||
return _TransformMetadata(transformer) |
|||
|
|||
|
|||
def passthrough_transformer(opt_type: AppCommandOptionType) -> Type[Transformer]: |
|||
class _Generated(Transformer): |
|||
@classmethod |
|||
def type(cls) -> AppCommandOptionType: |
|||
return opt_type |
|||
|
|||
@classmethod |
|||
async def transform(cls, interaction: Interaction, value: Any) -> Any: |
|||
return value |
|||
|
|||
return _Generated |
|||
|
|||
|
|||
class MemberTransformer(Transformer): |
|||
@classmethod |
|||
def type(cls) -> AppCommandOptionType: |
|||
return AppCommandOptionType.user |
|||
|
|||
@classmethod |
|||
async def transform(cls, interaction: Interaction, value: Any) -> Member: |
|||
if not isinstance(value, Member): |
|||
raise TransformerError(value, cls.type(), cls) |
|||
return value |
|||
|
|||
|
|||
def channel_transformer(*channel_types: Type[Any], raw: Optional[bool] = False) -> Type[Transformer]: |
|||
if raw: |
|||
|
|||
async def transform(cls, interaction: Interaction, value: Any): |
|||
if not isinstance(value, channel_types): |
|||
raise TransformerError(value, AppCommandOptionType.channel, cls) |
|||
return value |
|||
|
|||
elif raw is False: |
|||
|
|||
async def transform(cls, interaction: Interaction, value: Any): |
|||
resolved = value.resolve() |
|||
if resolved is None or not isinstance(resolved, channel_types): |
|||
raise TransformerError(value, AppCommandOptionType.channel, cls) |
|||
return resolved |
|||
|
|||
else: |
|||
|
|||
async def transform(cls, interaction: Interaction, value: Any): |
|||
if isinstance(value, channel_types): |
|||
return value |
|||
|
|||
resolved = value.resolve() |
|||
if resolved is None or not isinstance(resolved, channel_types): |
|||
raise TransformerError(value, AppCommandOptionType.channel, cls) |
|||
return resolved |
|||
|
|||
if len(channel_types) == 1: |
|||
name = channel_types[0].__name__ |
|||
types = CHANNEL_TO_TYPES[channel_types[0]] |
|||
else: |
|||
name = 'MultiChannel' |
|||
types = [] |
|||
|
|||
for t in channel_types: |
|||
try: |
|||
types.extend(CHANNEL_TO_TYPES[t]) |
|||
except KeyError: |
|||
raise TypeError(f'Union type of channels must be entirely made up of channels') from None |
|||
|
|||
return type( |
|||
f'{name}Transformer', |
|||
(Transformer,), |
|||
{ |
|||
'type': classmethod(lambda cls: AppCommandOptionType.channel), |
|||
'transform': classmethod(transform), |
|||
'channel_types': classmethod(lambda cls: types), |
|||
}, |
|||
) |
|||
|
|||
|
|||
CHANNEL_TO_TYPES: Dict[Any, List[ChannelType]] = { |
|||
AppCommandChannel: [ |
|||
ChannelType.stage_voice, |
|||
ChannelType.store, |
|||
ChannelType.voice, |
|||
ChannelType.text, |
|||
ChannelType.category, |
|||
], |
|||
AppCommandThread: [ChannelType.news_thread, ChannelType.private_thread, ChannelType.public_thread], |
|||
StageChannel: [ChannelType.stage_voice], |
|||
StoreChannel: [ChannelType.store], |
|||
VoiceChannel: [ChannelType.voice], |
|||
TextChannel: [ChannelType.text], |
|||
CategoryChannel: [ChannelType.category], |
|||
} |
|||
|
|||
BUILT_IN_TRANSFORMERS: Dict[Any, Type[Transformer]] = { |
|||
str: passthrough_transformer(AppCommandOptionType.string), |
|||
int: passthrough_transformer(AppCommandOptionType.integer), |
|||
float: passthrough_transformer(AppCommandOptionType.number), |
|||
bool: passthrough_transformer(AppCommandOptionType.boolean), |
|||
User: passthrough_transformer(AppCommandOptionType.user), |
|||
Member: MemberTransformer, |
|||
Role: passthrough_transformer(AppCommandOptionType.role), |
|||
AppCommandChannel: channel_transformer(AppCommandChannel, raw=True), |
|||
AppCommandThread: channel_transformer(AppCommandThread, raw=True), |
|||
StageChannel: channel_transformer(StageChannel), |
|||
StoreChannel: channel_transformer(StoreChannel), |
|||
VoiceChannel: channel_transformer(VoiceChannel), |
|||
TextChannel: channel_transformer(TextChannel), |
|||
CategoryChannel: channel_transformer(CategoryChannel), |
|||
Attachment: passthrough_transformer(AppCommandOptionType.attachment), |
|||
} |
|||
|
|||
ALLOWED_DEFAULTS: Dict[AppCommandOptionType, Tuple[Type[Any], ...]] = { |
|||
AppCommandOptionType.string: (str, NoneType), |
|||
AppCommandOptionType.integer: (int, NoneType), |
|||
AppCommandOptionType.boolean: (bool, NoneType), |
|||
} |
|||
|
|||
|
|||
def get_supported_annotation( |
|||
annotation: Any, |
|||
*, |
|||
_none=NoneType, |
|||
_mapping: Dict[Any, Type[Transformer]] = BUILT_IN_TRANSFORMERS, |
|||
) -> Tuple[Any, Any]: |
|||
"""Returns an appropriate, yet supported, annotation along with an optional default value. |
|||
|
|||
This differs from the built in mapping by supporting a few more things. |
|||
Likewise, this returns a "transformed" annotation that is ready to use with CommandParameter.transform. |
|||
""" |
|||
|
|||
try: |
|||
return (_mapping[annotation], MISSING) |
|||
except KeyError: |
|||
pass |
|||
|
|||
if hasattr(annotation, '__discord_app_commands_transform__'): |
|||
return (annotation.metadata, MISSING) |
|||
|
|||
if inspect.isclass(annotation): |
|||
if issubclass(annotation, Transformer): |
|||
return (annotation, MISSING) |
|||
if issubclass(annotation, Enum): |
|||
return (_make_enum_transformer(annotation), MISSING) |
|||
if annotation is Choice: |
|||
raise TypeError(f'Choice requires a type argument of int, str, or float') |
|||
|
|||
# Check if there's an origin |
|||
origin = getattr(annotation, '__origin__', None) |
|||
if origin is Literal: |
|||
args = annotation.__args__ # type: ignore |
|||
return (_make_literal_transformer(args), MISSING) |
|||
|
|||
if origin is Choice: |
|||
arg = annotation.__args__[0] # type: ignore |
|||
return (_make_choice_transformer(arg), MISSING) |
|||
|
|||
if origin is not Union: |
|||
# Only Union/Optional is supported right now so bail early |
|||
raise TypeError(f'unsupported type annotation {annotation!r}') |
|||
|
|||
default = MISSING |
|||
args = annotation.__args__ # type: ignore |
|||
if args[-1] is _none: |
|||
if len(args) == 2: |
|||
underlying = args[0] |
|||
inner, _ = get_supported_annotation(underlying) |
|||
if inner is None: |
|||
raise TypeError(f'unsupported inner optional type {underlying!r}') |
|||
return (inner, None) |
|||
else: |
|||
args = args[:-1] |
|||
default = None |
|||
|
|||
# Check for channel union types |
|||
if any(arg in CHANNEL_TO_TYPES for arg in args): |
|||
# If any channel type is given, then *all* must be channel types |
|||
return (channel_transformer(*args, raw=None), default) |
|||
|
|||
# The only valid transformations here are: |
|||
# [Member, User] => user |
|||
# [Member, User, Role] => mentionable |
|||
# [Member | User, Role] => mentionable |
|||
supported_types: Set[Any] = {Role, Member, User} |
|||
if not all(arg in supported_types for arg in args): |
|||
raise TypeError(f'unsupported types given inside {annotation!r}') |
|||
if args == (User, Member) or args == (Member, User): |
|||
return (passthrough_transformer(AppCommandOptionType.user), default) |
|||
|
|||
return (passthrough_transformer(AppCommandOptionType.mentionable), default) |
|||
|
|||
|
|||
def annotation_to_parameter(annotation: Any, parameter: inspect.Parameter) -> CommandParameter: |
|||
"""Returns the appropriate :class:`CommandParameter` for the given annotation. |
|||
|
|||
The resulting ``_annotation`` attribute might not match the one given here and might |
|||
be transformed in order to be easier to call from the ``transform`` asynchronous function |
|||
of a command parameter. |
|||
""" |
|||
|
|||
(inner, default) = get_supported_annotation(annotation) |
|||
type = inner.type() |
|||
if default is MISSING: |
|||
default = parameter.default |
|||
if default is parameter.empty: |
|||
default = MISSING |
|||
|
|||
# Verify validity of the default parameter |
|||
if default is not MISSING: |
|||
enum_type = getattr(inner, '__discord_app_commands_transformer_enum__', None) |
|||
if default.__class__ is not enum_type: |
|||
valid_types: Tuple[Any, ...] = ALLOWED_DEFAULTS.get(type, (NoneType,)) |
|||
if not isinstance(default, valid_types): |
|||
raise TypeError(f'invalid default parameter type given ({default.__class__}), expected {valid_types}') |
|||
|
|||
result = CommandParameter( |
|||
type=type, |
|||
_annotation=inner, |
|||
default=default, |
|||
required=default is MISSING, |
|||
name=parameter.name, |
|||
) |
|||
|
|||
try: |
|||
choices = inner.__discord_app_commands_transformer_choices__ |
|||
except AttributeError: |
|||
pass |
|||
else: |
|||
result.choices = choices |
|||
|
|||
# These methods should be duck typed |
|||
if type in (AppCommandOptionType.number, AppCommandOptionType.integer): |
|||
result.min_value = inner.min_value() |
|||
result.max_value = inner.max_value() |
|||
|
|||
if type is AppCommandOptionType.channel: |
|||
result.channel_types = inner.channel_types() |
|||
|
|||
if parameter.kind in (parameter.POSITIONAL_ONLY, parameter.VAR_KEYWORD, parameter.VAR_POSITIONAL): |
|||
raise TypeError(f'unsupported parameter kind in callback: {parameter.kind!s}') |
|||
|
|||
return result |
|||
@ -1,713 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
import inspect |
|||
import sys |
|||
import traceback |
|||
from typing import Callable, Dict, Generic, List, Literal, Optional, TYPE_CHECKING, Tuple, TypeVar, Union, overload |
|||
|
|||
|
|||
from .namespace import Namespace, ResolveKey |
|||
from .models import AppCommand |
|||
from .commands import Command, ContextMenu, Group, _shorten |
|||
from .errors import ( |
|||
AppCommandError, |
|||
CommandAlreadyRegistered, |
|||
CommandNotFound, |
|||
CommandSignatureMismatch, |
|||
) |
|||
from ..errors import ClientException |
|||
from ..enums import AppCommandType, InteractionType |
|||
from ..utils import MISSING |
|||
|
|||
if TYPE_CHECKING: |
|||
from ..types.interactions import ApplicationCommandInteractionData, ApplicationCommandInteractionDataOption |
|||
from ..interactions import Interaction |
|||
from ..client import Client |
|||
from ..abc import Snowflake |
|||
from .commands import ContextMenuCallback, CommandCallback, P, T |
|||
|
|||
__all__ = ('CommandTree',) |
|||
|
|||
ClientT = TypeVar('ClientT', bound='Client') |
|||
|
|||
|
|||
class CommandTree(Generic[ClientT]): |
|||
"""Represents a container that holds application command information. |
|||
|
|||
Parameters |
|||
----------- |
|||
client: :class:`~discord.Client` |
|||
The client instance to get application command information from. |
|||
""" |
|||
|
|||
def __init__(self, client: ClientT): |
|||
self.client: ClientT = client |
|||
self._http = client.http |
|||
self._state = client._connection |
|||
self._state._command_tree = self |
|||
self._guild_commands: Dict[int, Dict[str, Union[Command, Group]]] = {} |
|||
self._global_commands: Dict[str, Union[Command, Group]] = {} |
|||
# (name, guild_id, command_type): Command |
|||
# The above two mappings can use this structure too but we need fast retrieval |
|||
# by name and guild_id in the above case while here it isn't as important since |
|||
# it's uncommon and N=5 anyway. |
|||
self._context_menus: Dict[Tuple[str, Optional[int], int], ContextMenu] = {} |
|||
|
|||
async def fetch_commands(self, *, guild: Optional[Snowflake] = None) -> List[AppCommand]: |
|||
"""|coro| |
|||
|
|||
Fetches the application's current commands. |
|||
|
|||
If no guild is passed then global commands are fetched, otherwise |
|||
the guild's commands are fetched instead. |
|||
|
|||
.. note:: |
|||
|
|||
This includes context menu commands. |
|||
|
|||
Parameters |
|||
----------- |
|||
guild: Optional[:class:`~discord.abc.Snowflake`] |
|||
The guild to fetch the commands from. If not passed then global commands |
|||
are fetched instead. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Fetching the commands failed. |
|||
ClientException |
|||
The application ID could not be found. |
|||
|
|||
Returns |
|||
-------- |
|||
List[:class:`~discord.app_commands.AppCommand`] |
|||
The application's commands. |
|||
""" |
|||
if self.client.application_id is None: |
|||
raise ClientException('Client does not have an application ID set') |
|||
|
|||
if guild is None: |
|||
commands = await self._http.get_global_commands(self.client.application_id) |
|||
else: |
|||
commands = await self._http.get_guild_commands(self.client.application_id, guild.id) |
|||
|
|||
return [AppCommand(data=data, state=self._state) for data in commands] |
|||
|
|||
def add_command( |
|||
self, |
|||
command: Union[Command, ContextMenu, Group], |
|||
/, |
|||
*, |
|||
guild: Optional[Snowflake] = None, |
|||
override: bool = False, |
|||
): |
|||
"""Adds an application command to the tree. |
|||
|
|||
This only adds the command locally -- in order to sync the commands |
|||
and enable them in the client, :meth:`sync` must be called. |
|||
|
|||
The root parent of the command is added regardless of the type passed. |
|||
|
|||
Parameters |
|||
----------- |
|||
command: Union[:class:`Command`, :class:`Group`] |
|||
The application command or group to add. |
|||
guild: Optional[:class:`~discord.abc.Snowflake`] |
|||
The guild to add the command to. If not given then it |
|||
becomes a global command instead. |
|||
override: :class:`bool` |
|||
Whether to override a command with the same name. If ``False`` |
|||
an exception is raised. Default is ``False``. |
|||
|
|||
Raises |
|||
-------- |
|||
~discord.app_commands.CommandAlreadyRegistered |
|||
The command was already registered and no override was specified. |
|||
TypeError |
|||
The application command passed is not a valid application command. |
|||
ValueError |
|||
The maximum number of commands was reached globally or for that guild. |
|||
This is currently 100 for slash commands and 5 for context menu commands. |
|||
""" |
|||
|
|||
if isinstance(command, ContextMenu): |
|||
guild_id = None if guild is None else guild.id |
|||
type = command.type.value |
|||
key = (command.name, guild_id, type) |
|||
found = key in self._context_menus |
|||
if found and not override: |
|||
raise CommandAlreadyRegistered(command.name, guild_id) |
|||
|
|||
total = sum(1 for _, g, t in self._context_menus if g == guild_id and t == type) |
|||
if total + found > 5: |
|||
raise ValueError('maximum number of context menu commands exceeded (5)') |
|||
self._context_menus[key] = command |
|||
return |
|||
elif not isinstance(command, (Command, Group)): |
|||
raise TypeError(f'Expected a application command, received {command.__class__!r} instead') |
|||
|
|||
# todo: validate application command groups having children (required) |
|||
|
|||
root = command.root_parent or command |
|||
name = root.name |
|||
if guild is not None: |
|||
commands = self._guild_commands.setdefault(guild.id, {}) |
|||
found = name in commands |
|||
if found and not override: |
|||
raise CommandAlreadyRegistered(name, guild.id) |
|||
if len(commands) + found > 100: |
|||
raise ValueError('maximum number of slash commands exceeded (100)') |
|||
commands[name] = root |
|||
else: |
|||
found = name in self._global_commands |
|||
if found and not override: |
|||
raise CommandAlreadyRegistered(name, None) |
|||
if len(self._global_commands) + found > 100: |
|||
raise ValueError('maximum number of slash commands exceeded (100)') |
|||
self._global_commands[name] = root |
|||
|
|||
@overload |
|||
def remove_command( |
|||
self, |
|||
command: str, |
|||
/, |
|||
*, |
|||
guild: Optional[Snowflake] = ..., |
|||
type: Literal[AppCommandType.message, AppCommandType.user] = ..., |
|||
) -> Optional[ContextMenu]: |
|||
... |
|||
|
|||
@overload |
|||
def remove_command( |
|||
self, |
|||
command: str, |
|||
/, |
|||
*, |
|||
guild: Optional[Snowflake] = ..., |
|||
type: Literal[AppCommandType.chat_input] = ..., |
|||
) -> Optional[Union[Command, Group]]: |
|||
... |
|||
|
|||
@overload |
|||
def remove_command( |
|||
self, |
|||
command: str, |
|||
/, |
|||
*, |
|||
guild: Optional[Snowflake] = ..., |
|||
type: AppCommandType = ..., |
|||
) -> Optional[Union[Command, ContextMenu, Group]]: |
|||
... |
|||
|
|||
def remove_command( |
|||
self, |
|||
command: str, |
|||
/, |
|||
*, |
|||
guild: Optional[Snowflake] = None, |
|||
type: AppCommandType = AppCommandType.chat_input, |
|||
) -> Optional[Union[Command, ContextMenu, Group]]: |
|||
"""Removes an application command from the tree. |
|||
|
|||
This only removes the command locally -- in order to sync the commands |
|||
and remove them in the client, :meth:`sync` must be called. |
|||
|
|||
Parameters |
|||
----------- |
|||
command: :class:`str` |
|||
The name of the root command to remove. |
|||
guild: Optional[:class:`~discord.abc.Snowflake`] |
|||
The guild to remove the command from. If not given then it |
|||
removes a global command instead. |
|||
type: :class:`~discord.AppCommandType` |
|||
The type of command to remove. Defaults to :attr:`~discord.AppCommandType.chat_input`, |
|||
i.e. slash commands. |
|||
|
|||
Returns |
|||
--------- |
|||
Optional[Union[:class:`Command`, :class:`ContextMenu`, :class:`Group`]] |
|||
The application command that got removed. |
|||
If nothing was removed then ``None`` is returned instead. |
|||
""" |
|||
|
|||
if type is AppCommandType.chat_input: |
|||
if guild is None: |
|||
return self._global_commands.pop(command, None) |
|||
else: |
|||
try: |
|||
commands = self._guild_commands[guild.id] |
|||
except KeyError: |
|||
return None |
|||
else: |
|||
return commands.pop(command, None) |
|||
elif type in (AppCommandType.user, AppCommandType.message): |
|||
guild_id = None if guild is None else guild.id |
|||
key = (command, guild_id, type.value) |
|||
return self._context_menus.pop(key, None) |
|||
|
|||
@overload |
|||
def get_command( |
|||
self, |
|||
command: str, |
|||
/, |
|||
*, |
|||
guild: Optional[Snowflake] = ..., |
|||
type: Literal[AppCommandType.message, AppCommandType.user] = ..., |
|||
) -> Optional[ContextMenu]: |
|||
... |
|||
|
|||
@overload |
|||
def get_command( |
|||
self, |
|||
command: str, |
|||
/, |
|||
*, |
|||
guild: Optional[Snowflake] = ..., |
|||
type: Literal[AppCommandType.chat_input] = ..., |
|||
) -> Optional[Union[Command, Group]]: |
|||
... |
|||
|
|||
@overload |
|||
def get_command( |
|||
self, |
|||
command: str, |
|||
/, |
|||
*, |
|||
guild: Optional[Snowflake] = ..., |
|||
type: AppCommandType = ..., |
|||
) -> Optional[Union[Command, ContextMenu, Group]]: |
|||
... |
|||
|
|||
def get_command( |
|||
self, |
|||
command: str, |
|||
/, |
|||
*, |
|||
guild: Optional[Snowflake] = None, |
|||
type: AppCommandType = AppCommandType.chat_input, |
|||
) -> Optional[Union[Command, ContextMenu, Group]]: |
|||
"""Gets a application command from the tree. |
|||
|
|||
Parameters |
|||
----------- |
|||
command: :class:`str` |
|||
The name of the root command to get. |
|||
guild: Optional[:class:`~discord.abc.Snowflake`] |
|||
The guild to get the command from. If not given then it |
|||
gets a global command instead. |
|||
type: :class:`~discord.AppCommandType` |
|||
The type of command to get. Defaults to :attr:`~discord.AppCommandType.chat_input`, |
|||
i.e. slash commands. |
|||
|
|||
Returns |
|||
--------- |
|||
Optional[Union[:class:`Command`, :class:`ContextMenu`, :class:`Group`]] |
|||
The application command that was found. |
|||
If nothing was found then ``None`` is returned instead. |
|||
""" |
|||
|
|||
if type is AppCommandType.chat_input: |
|||
if guild is None: |
|||
return self._global_commands.get(command) |
|||
else: |
|||
try: |
|||
commands = self._guild_commands[guild.id] |
|||
except KeyError: |
|||
return None |
|||
else: |
|||
return commands.get(command) |
|||
elif type in (AppCommandType.user, AppCommandType.message): |
|||
guild_id = None if guild is None else guild.id |
|||
key = (command, guild_id, type.value) |
|||
return self._context_menus.get(key) |
|||
|
|||
@overload |
|||
def get_commands( |
|||
self, |
|||
*, |
|||
guild: Optional[Snowflake] = ..., |
|||
type: Literal[AppCommandType.message, AppCommandType.user] = ..., |
|||
) -> List[ContextMenu]: |
|||
... |
|||
|
|||
@overload |
|||
def get_commands( |
|||
self, |
|||
*, |
|||
guild: Optional[Snowflake] = ..., |
|||
type: Literal[AppCommandType.chat_input] = ..., |
|||
) -> List[Union[Command, Group]]: |
|||
... |
|||
|
|||
@overload |
|||
def get_commands( |
|||
self, |
|||
*, |
|||
guild: Optional[Snowflake] = ..., |
|||
type: AppCommandType = ..., |
|||
) -> Union[List[Union[Command, Group]], List[ContextMenu]]: |
|||
... |
|||
|
|||
def get_commands( |
|||
self, |
|||
*, |
|||
guild: Optional[Snowflake] = None, |
|||
type: AppCommandType = AppCommandType.chat_input, |
|||
) -> Union[List[Union[Command, Group]], List[ContextMenu]]: |
|||
"""Gets all application commands from the tree. |
|||
|
|||
Parameters |
|||
----------- |
|||
guild: Optional[:class:`~discord.abc.Snowflake`] |
|||
The guild to get the commands from. If not given then it |
|||
gets all global commands instead. |
|||
type: :class:`~discord.AppCommandType` |
|||
The type of commands to get. Defaults to :attr:`~discord.AppCommandType.chat_input`, |
|||
i.e. slash commands. |
|||
|
|||
Returns |
|||
--------- |
|||
Union[List[:class:`ContextMenu`], List[Union[:class:`Command`, :class:`Group`]] |
|||
The application commands from the tree. |
|||
""" |
|||
|
|||
if type is AppCommandType.chat_input: |
|||
if guild is None: |
|||
return list(self._global_commands.values()) |
|||
else: |
|||
try: |
|||
commands = self._guild_commands[guild.id] |
|||
except KeyError: |
|||
return [] |
|||
else: |
|||
return list(commands.values()) |
|||
else: |
|||
guild_id = None if guild is None else guild.id |
|||
value = type.value |
|||
return [command for ((_, g, t), command) in self._context_menus.items() if g == guild_id and t == value] |
|||
|
|||
def _get_all_commands(self, *, guild: Optional[Snowflake] = None) -> List[Union[Command, Group, ContextMenu]]: |
|||
if guild is None: |
|||
base: List[Union[Command, Group, ContextMenu]] = list(self._global_commands.values()) |
|||
base.extend(cmd for ((_, g, _), cmd) in self._context_menus.items() if g is None) |
|||
return base |
|||
else: |
|||
try: |
|||
commands = self._guild_commands[guild.id] |
|||
except KeyError: |
|||
return [cmd for ((_, g, _), cmd) in self._context_menus.items() if g is None] |
|||
else: |
|||
base: List[Union[Command, Group, ContextMenu]] = list(commands.values()) |
|||
guild_id = guild.id |
|||
base.extend(cmd for ((_, g, _), cmd) in self._context_menus.items() if g == guild_id) |
|||
return base |
|||
|
|||
async def on_error( |
|||
self, |
|||
interaction: Interaction, |
|||
command: Optional[Union[ContextMenu, Command]], |
|||
error: AppCommandError, |
|||
) -> None: |
|||
"""|coro| |
|||
|
|||
A callback that is called when any command raises an :exc:`AppCommandError`. |
|||
|
|||
The default implementation prints the traceback to stderr. |
|||
|
|||
Parameters |
|||
----------- |
|||
interaction: :class:`~discord.Interaction` |
|||
The interaction that is being handled. |
|||
command: Optional[Union[:class:`~discord.app_commands.Command`, :class:`~discord.app_commands.ContextMenu`]] |
|||
The command that failed, if any. |
|||
error: :exc:`AppCommandError` |
|||
The exception that was raised. |
|||
""" |
|||
|
|||
if command is not None: |
|||
print(f'Ignoring exception in command {command.name!r}:', file=sys.stderr) |
|||
else: |
|||
print(f'Ignoring exception in command tree:', file=sys.stderr) |
|||
|
|||
traceback.print_exception(error.__class__, error, error.__traceback__, file=sys.stderr) |
|||
|
|||
def command( |
|||
self, |
|||
*, |
|||
name: str = MISSING, |
|||
description: str = MISSING, |
|||
guild: Optional[Snowflake] = None, |
|||
) -> Callable[[CommandCallback[Group, P, T]], Command[Group, P, T]]: |
|||
"""Creates an application command directly under this tree. |
|||
|
|||
Parameters |
|||
------------ |
|||
name: :class:`str` |
|||
The name of the application command. If not given, it defaults to a lower-case |
|||
version of the callback name. |
|||
description: :class:`str` |
|||
The description of the application command. This shows up in the UI to describe |
|||
the application command. If not given, it defaults to the first line of the docstring |
|||
of the callback shortened to 100 characters. |
|||
guild: Optional[:class:`~discord.abc.Snowflake`] |
|||
The guild to add the command to. If not given then it |
|||
becomes a global command instead. |
|||
""" |
|||
|
|||
def decorator(func: CommandCallback[Group, P, T]) -> Command[Group, P, T]: |
|||
if not inspect.iscoroutinefunction(func): |
|||
raise TypeError('command function must be a coroutine function') |
|||
|
|||
if description is MISSING: |
|||
if func.__doc__ is None: |
|||
desc = '...' |
|||
else: |
|||
desc = _shorten(func.__doc__) |
|||
else: |
|||
desc = description |
|||
|
|||
command = Command( |
|||
name=name if name is not MISSING else func.__name__, |
|||
description=desc, |
|||
callback=func, |
|||
parent=None, |
|||
) |
|||
self.add_command(command, guild=guild) |
|||
return command |
|||
|
|||
return decorator |
|||
|
|||
def context_menu( |
|||
self, *, name: str = MISSING, guild: Optional[Snowflake] = None |
|||
) -> Callable[[ContextMenuCallback], ContextMenu]: |
|||
"""Creates a application command context menu from a regular function directly under this tree. |
|||
|
|||
This function must have a signature of :class:`~discord.Interaction` as its first parameter |
|||
and taking either a :class:`~discord.Member`, :class:`~discord.User`, or :class:`~discord.Message`, |
|||
or a :obj:`typing.Union` of ``Member`` and ``User`` as its second parameter. |
|||
|
|||
Examples |
|||
--------- |
|||
|
|||
.. code-block:: python3 |
|||
|
|||
@app_commands.context_menu() |
|||
async def react(interaction: discord.Interaction, message: discord.Message): |
|||
await interaction.response.send_message('Very cool message!', ephemeral=True) |
|||
|
|||
@app_commands.context_menu() |
|||
async def ban(interaction: discord.Interaction, user: discord.Member): |
|||
await interaction.response.send_message(f'Should I actually ban {user}...', ephemeral=True) |
|||
|
|||
Parameters |
|||
------------ |
|||
name: :class:`str` |
|||
The name of the context menu command. If not given, it defaults to a title-case |
|||
version of the callback name. Note that unlike regular slash commands this can |
|||
have spaces and upper case characters in the name. |
|||
guild: Optional[:class:`~discord.abc.Snowflake`] |
|||
The guild to add the command to. If not given then it |
|||
becomes a global command instead. |
|||
""" |
|||
|
|||
def decorator(func: ContextMenuCallback) -> ContextMenu: |
|||
if not inspect.iscoroutinefunction(func): |
|||
raise TypeError('context menu function must be a coroutine function') |
|||
|
|||
context_menu = ContextMenu._from_decorator(func, name=name) |
|||
self.add_command(context_menu, guild=guild) |
|||
return context_menu |
|||
|
|||
return decorator |
|||
|
|||
async def sync(self, *, guild: Optional[Snowflake] = None) -> List[AppCommand]: |
|||
"""|coro| |
|||
|
|||
Syncs the application commands to Discord. |
|||
|
|||
This must be called for the application commands to show up. |
|||
|
|||
Global commands take up to 1-hour to propagate but guild |
|||
commands propagate instantly. |
|||
|
|||
Parameters |
|||
----------- |
|||
guild: Optional[:class:`~discord.abc.Snowflake`] |
|||
The guild to sync the commands to. If ``None`` then it |
|||
syncs all global commands instead. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Syncing the commands failed. |
|||
ClientException |
|||
The client does not have an application ID. |
|||
|
|||
Returns |
|||
-------- |
|||
List[:class:`AppCommand`] |
|||
The application's commands that got synced. |
|||
""" |
|||
|
|||
if self.client.application_id is None: |
|||
raise ClientException('Client does not have an application ID set') |
|||
|
|||
commands = self._get_all_commands(guild=guild) |
|||
payload = [command.to_dict() for command in commands] |
|||
if guild is None: |
|||
data = await self._http.bulk_upsert_global_commands(self.client.application_id, payload=payload) |
|||
else: |
|||
data = await self._http.bulk_upsert_guild_commands(self.client.application_id, guild.id, payload=payload) |
|||
|
|||
return [AppCommand(data=d, state=self._state) for d in data] |
|||
|
|||
def _from_interaction(self, interaction: Interaction): |
|||
async def wrapper(): |
|||
try: |
|||
await self.call(interaction) |
|||
except AppCommandError as e: |
|||
await self.on_error(interaction, None, e) |
|||
|
|||
self.client.loop.create_task(wrapper(), name='CommandTree-invoker') |
|||
|
|||
async def _call_context_menu(self, interaction: Interaction, data: ApplicationCommandInteractionData, type: int): |
|||
name = data['name'] |
|||
guild_id = interaction.guild_id |
|||
ctx_menu = self._context_menus.get((name, guild_id, type)) |
|||
if ctx_menu is None: |
|||
raise CommandNotFound(name, [], AppCommandType(type)) |
|||
|
|||
resolved = Namespace._get_resolved_items(interaction, data.get('resolved', {})) |
|||
|
|||
target_id = data.get('target_id') |
|||
# Right now, the only types are message and user |
|||
# Therefore, there's no conflict with snowflakes |
|||
|
|||
# This will always work at runtime |
|||
key = ResolveKey.any_with(target_id) # type: ignore |
|||
value = resolved.get(key) |
|||
if ctx_menu.type.value != type: |
|||
raise CommandSignatureMismatch(ctx_menu) |
|||
|
|||
if value is None: |
|||
raise AppCommandError('This should not happen if Discord sent well-formed data.') |
|||
|
|||
# I assume I don't have to type check here. |
|||
try: |
|||
await ctx_menu._invoke(interaction, value) |
|||
except AppCommandError as e: |
|||
await self.on_error(interaction, ctx_menu, e) |
|||
|
|||
async def call(self, interaction: Interaction): |
|||
"""|coro| |
|||
|
|||
Given an :class:`~discord.Interaction`, calls the matching |
|||
application command that's being invoked. |
|||
|
|||
This is usually called automatically by the library. |
|||
|
|||
Parameters |
|||
----------- |
|||
interaction: :class:`~discord.Interaction` |
|||
The interaction to dispatch from. |
|||
|
|||
Raises |
|||
-------- |
|||
CommandNotFound |
|||
The application command referred to could not be found. |
|||
CommandSignatureMismatch |
|||
The interaction data referred to a parameter that was not found in the |
|||
application command definition. |
|||
AppCommandError |
|||
An error occurred while calling the command. |
|||
""" |
|||
data: ApplicationCommandInteractionData = interaction.data # type: ignore |
|||
type = data.get('type', 1) |
|||
if type != 1: |
|||
# Context menu command... |
|||
await self._call_context_menu(interaction, data, type) |
|||
return |
|||
|
|||
parents: List[str] = [] |
|||
name = data['name'] |
|||
command = self._global_commands.get(name) |
|||
if interaction.guild_id: |
|||
try: |
|||
guild_commands = self._guild_commands[interaction.guild_id] |
|||
except KeyError: |
|||
pass |
|||
else: |
|||
command = guild_commands.get(name) or command |
|||
|
|||
# If it's not found at this point then it's not gonna be found at any point |
|||
if command is None: |
|||
raise CommandNotFound(name, parents) |
|||
|
|||
# This could be done recursively but it'd be a bother due to the state needed |
|||
# to be tracked above like the parents, the actual command type, and the |
|||
# resulting options we care about |
|||
searching = True |
|||
options: List[ApplicationCommandInteractionDataOption] = data.get('options', []) |
|||
while searching: |
|||
for option in options: |
|||
# Find subcommands |
|||
if option.get('type', 0) in (1, 2): |
|||
parents.append(name) |
|||
name = option['name'] |
|||
command = command._get_internal_command(name) |
|||
if command is None: |
|||
raise CommandNotFound(name, parents) |
|||
options = option.get('options', []) |
|||
break |
|||
else: |
|||
searching = False |
|||
break |
|||
else: |
|||
break |
|||
|
|||
if isinstance(command, Group): |
|||
# Right now, groups can't be invoked. This is a Discord limitation in how they |
|||
# do slash commands. So if we're here and we have a Group rather than a Command instance |
|||
# then something in the code is out of date from the data that Discord has. |
|||
raise CommandSignatureMismatch(command) |
|||
|
|||
# At this point options refers to the arguments of the command |
|||
# and command refers to the class type we care about |
|||
namespace = Namespace(interaction, data.get('resolved', {}), options) |
|||
|
|||
# Auto complete handles the namespace differently... so at this point this is where we decide where that is. |
|||
if interaction.type is InteractionType.autocomplete: |
|||
focused = next((opt['name'] for opt in options if opt.get('focused')), None) |
|||
if focused is None: |
|||
raise AppCommandError('This should not happen, but there is no focused element. This is a Discord bug.') |
|||
await command._invoke_autocomplete(interaction, focused, namespace) |
|||
return |
|||
|
|||
try: |
|||
await command._invoke_with_namespace(interaction, namespace) |
|||
except AppCommandError as e: |
|||
await command._invoke_error_handler(interaction, e) |
|||
await self.on_error(interaction, command, e) |
|||
@ -0,0 +1,473 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
from __future__ import annotations |
|||
|
|||
import datetime |
|||
from typing import Callable, Dict, List, Optional, TYPE_CHECKING, Union |
|||
|
|||
from . import utils |
|||
from .errors import ClientException |
|||
from .utils import MISSING |
|||
|
|||
if TYPE_CHECKING: |
|||
from .abc import Connectable, PrivateChannel, User as abcUser, T as ConnectReturn |
|||
from .channel import DMChannel, GroupChannel |
|||
from .client import Client |
|||
from .member import VoiceState |
|||
from .message import Message |
|||
from .state import ConnectionState |
|||
from .types.snowflake import Snowflake, SnowflakeList |
|||
from .types.voice import GuildVoiceState |
|||
from .user import User |
|||
|
|||
_PrivateChannel = Union[DMChannel, GroupChannel] |
|||
|
|||
__all__ = ( |
|||
'CallMessage', |
|||
'PrivateCall', |
|||
'GroupCall', |
|||
) |
|||
|
|||
|
|||
def _running_only(func: Callable): |
|||
def decorator(self: Call, *args, **kwargs): |
|||
if self._ended: |
|||
raise ClientException('Call is over') |
|||
else: |
|||
return func(self, *args, **kwargs) |
|||
return decorator |
|||
|
|||
|
|||
class CallMessage: |
|||
"""Represents a group call message from Discord. |
|||
|
|||
This is only received in cases where the message type is equivalent to |
|||
:attr:`MessageType.call`. |
|||
|
|||
Attributes |
|||
----------- |
|||
ended_timestamp: Optional[:class:`datetime.datetime`] |
|||
A naive UTC datetime object that represents the time that the call has ended. |
|||
participants: List[:class:`User`] |
|||
A list of users that participated in the call. |
|||
message: :class:`Message` |
|||
The message associated with this call message. |
|||
""" |
|||
|
|||
def __init__( |
|||
self, message: Message, *, participants: List[User], ended_timestamp: str |
|||
) -> None: |
|||
self.message = message |
|||
self.ended_timestamp = utils.parse_time(ended_timestamp) |
|||
self.participants = participants |
|||
|
|||
@property |
|||
def call_ended(self) -> bool: |
|||
""":class:`bool`: Indicates if the call has ended.""" |
|||
return self.ended_timestamp is not None |
|||
|
|||
@property |
|||
def initiator(self) -> User: |
|||
""":class:`User`: Returns the user that started the call.""" |
|||
return self.message.author # type: ignore - Cannot be a Member in private messages |
|||
|
|||
@property |
|||
def channel(self) -> _PrivateChannel: |
|||
r""":class:`PrivateChannel`\: The private channel associated with this message.""" |
|||
return self.message.channel # type: ignore - Can only be a private channel here |
|||
|
|||
@property |
|||
def duration(self) -> datetime.timedelta: |
|||
"""Queries the duration of the call. |
|||
|
|||
If the call has not ended then the current duration will |
|||
be returned. |
|||
|
|||
Returns |
|||
--------- |
|||
:class:`datetime.timedelta` |
|||
The timedelta object representing the duration. |
|||
""" |
|||
if self.ended_timestamp is None: |
|||
return datetime.datetime.utcnow() - self.message.created_at |
|||
else: |
|||
return self.ended_timestamp - self.message.created_at |
|||
|
|||
|
|||
class PrivateCall: |
|||
"""Represents the actual group call from Discord. |
|||
|
|||
This is accompanied with a :class:`CallMessage` denoting the information. |
|||
|
|||
Attributes |
|||
----------- |
|||
channel: :class:`DMChannel` |
|||
The channel the call is in. |
|||
message: Optional[:class:`Message`] |
|||
The message associated with this call (if available). |
|||
unavailable: :class:`bool` |
|||
Denotes if this call is unavailable. |
|||
ringing: List[:class:`~discord.abc.User`] |
|||
A list of users that are currently being rung to join the call. |
|||
region: :class:`str` |
|||
The region the call is being hosted at. |
|||
|
|||
.. versionchanged:: 2.0 |
|||
The type of this attribute has changed to :class:`str`. |
|||
""" |
|||
|
|||
if TYPE_CHECKING: |
|||
channel: DMChannel |
|||
ringing: List[abcUser] |
|||
region: str |
|||
|
|||
def __init__( |
|||
self, |
|||
state: ConnectionState, |
|||
*, |
|||
message_id: Snowflake, |
|||
channel_id: Snowflake, |
|||
message: Optional[Message] = None, |
|||
channel: PrivateChannel, |
|||
unavailable: bool, |
|||
voice_states: List[GuildVoiceState] = [], |
|||
**kwargs, |
|||
) -> None: |
|||
self._state = state |
|||
self._message_id: int = int(message_id) |
|||
self._channel_id: int = int(channel_id) |
|||
self.message: Optional[Message] = message |
|||
self.channel = channel # type: ignore |
|||
self.unavailable: bool = unavailable |
|||
self._ended: bool = False |
|||
|
|||
for vs in voice_states: |
|||
state._update_voice_state(vs, int(channel_id)) |
|||
|
|||
self._update(**kwargs) |
|||
|
|||
def _deleteup(self) -> None: |
|||
self.ringing = [] |
|||
self._ended = True |
|||
|
|||
def _is_participating(self, user: abcUser) -> bool: |
|||
state = self.voice_state_for(user) |
|||
return bool(state and state.channel and state.channel.id == self._channel_id) |
|||
|
|||
def _update( |
|||
self, *, ringing: SnowflakeList = [], region: str = MISSING |
|||
) -> None: |
|||
if region is not MISSING: |
|||
self.region = region |
|||
channel = self.channel |
|||
recipients = {channel.me, channel.recipient} |
|||
lookup = {u.id: u for u in recipients} |
|||
self.ringing = list(filter(None, map(lookup.get, ringing))) |
|||
|
|||
@property |
|||
def initiator(self) -> Optional[User]: |
|||
"""Optional[:class:`User`]: Returns the user that started the call. The call message must be available to obtain this information.""" |
|||
if self.message: |
|||
return self.message.author # type: ignore - Cannot be a Member in private messages |
|||
|
|||
@property |
|||
def connected(self) -> bool: |
|||
""":class:`bool`: Returns whether you're in the call (this does not mean you're in the call through the lib).""" |
|||
return self._is_participating(self.channel.me) |
|||
|
|||
@property |
|||
def members(self) -> List[User]: |
|||
"""List[:class:`User`]: Returns all users that are currently in this call.""" |
|||
channel = self.channel |
|||
recipients = {channel.me, channel.recipient} |
|||
return [u for u in recipients if self._is_participating(u)] |
|||
|
|||
@property |
|||
def voice_states(self) -> Dict[int, VoiceState]: |
|||
"""Mapping[:class:`int`, :class:`VoiceState`]: Returns a mapping of user IDs who have voice states in this call.""" |
|||
return {k: v for k, v in self._state._voice_states.items() if bool(v and v.channel and v.channel.id == self._channel_id)} |
|||
|
|||
async def fetch_message(self) -> Optional[Message]: |
|||
"""|coro| |
|||
|
|||
Fetches and caches the message associated with this call. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Retrieving the message failed. |
|||
|
|||
Returns |
|||
------- |
|||
Optional[:class:`Message`] |
|||
The message associated with this call. |
|||
""" |
|||
message = await self.channel.fetch_message(self._message_id) |
|||
if message is not None and self.message is None: |
|||
self.message = message |
|||
return message |
|||
|
|||
async def change_region(self, region: str) -> None: |
|||
"""|coro| |
|||
|
|||
Changes the channel's voice region. |
|||
|
|||
Parameters |
|||
----------- |
|||
region: :class:`str` |
|||
A region to change the voice region to. |
|||
|
|||
.. versionchanged:: 2.0 |
|||
The type of this paramter has changed to :class:`str`. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Failed to change the channel's voice region. |
|||
""" |
|||
await self._state.http.change_call_voice_region(self._channel_id, str(region)) |
|||
|
|||
@_running_only |
|||
async def ring(self) -> None: |
|||
"""|coro| |
|||
|
|||
Rings the other recipient. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Ringing failed. |
|||
ClientException |
|||
The call has ended. |
|||
""" |
|||
channel = self.channel |
|||
await self._state.http.ring(channel.id, channel.recipient.id) |
|||
|
|||
@_running_only |
|||
async def stop_ringing(self) -> None: |
|||
"""|coro| |
|||
|
|||
Stops ringing the other recipient. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Stopping the ringing failed. |
|||
ClientException |
|||
The call has ended. |
|||
""" |
|||
channel = self.channel |
|||
await self._state.http.stop_ringing(channel.id, channel.recipient.id) |
|||
|
|||
@_running_only |
|||
async def connect( |
|||
self, |
|||
*, |
|||
timeout: float = 60.0, |
|||
reconnect: bool = True, |
|||
cls: Callable[[Client, Connectable], ConnectReturn] = MISSING, |
|||
ring: bool = True, |
|||
) -> ConnectReturn: |
|||
"""|coro| |
|||
|
|||
Connects to voice and creates a :class:`~discord.VoiceClient` to establish |
|||
your connection to the voice server. |
|||
|
|||
There is an alias of this called :attr:`join`. |
|||
|
|||
Parameters |
|||
----------- |
|||
timeout: :class:`float` |
|||
The timeout in seconds to wait for the voice endpoint. |
|||
reconnect: :class:`bool` |
|||
Whether the bot should automatically attempt |
|||
a reconnect if a part of the handshake fails |
|||
or the gateway goes down. |
|||
cls: Type[:class:`~discord.VoiceProtocol`] |
|||
A type that subclasses :class:`~discord.VoiceProtocol` to connect with. |
|||
Defaults to :class:`~discord.VoiceClient`. |
|||
ring: :class:`bool` |
|||
Whether to ring the other user. |
|||
|
|||
Raises |
|||
------- |
|||
asyncio.TimeoutError |
|||
Could not connect to the voice channel in time. |
|||
~discord.ClientException |
|||
You are already connected to a voice channel. |
|||
~discord.opus.OpusNotLoaded |
|||
The opus library has not been loaded. |
|||
|
|||
Returns |
|||
-------- |
|||
:class:`~discord.VoiceProtocol` |
|||
A voice client that is fully connected to the voice server. |
|||
""" |
|||
return await self.channel.connect(timeout=timeout, reconnect=reconnect, cls=cls, ring=ring) |
|||
|
|||
@_running_only |
|||
async def join( |
|||
self, |
|||
*, |
|||
timeout: float = 60.0, |
|||
reconnect: bool = True, |
|||
cls: Callable[[Client, Connectable], ConnectReturn] = MISSING, |
|||
ring: bool = True, |
|||
) -> ConnectReturn: |
|||
"""|coro| |
|||
|
|||
Connects to voice and creates a :class:`~discord.VoiceClient` to establish |
|||
your connection to the voice server. |
|||
|
|||
This is an alias of :attr:`connect`. |
|||
|
|||
Parameters |
|||
----------- |
|||
timeout: :class:`float` |
|||
The timeout in seconds to wait for the voice endpoint. |
|||
reconnect: :class:`bool` |
|||
Whether the bot should automatically attempt |
|||
a reconnect if a part of the handshake fails |
|||
or the gateway goes down. |
|||
cls: Type[:class:`~discord.VoiceProtocol`] |
|||
A type that subclasses :class:`~discord.VoiceProtocol` to connect with. |
|||
Defaults to :class:`~discord.VoiceClient`. |
|||
ring: :class:`bool` |
|||
Whether to ring the other user. |
|||
|
|||
Raises |
|||
------- |
|||
asyncio.TimeoutError |
|||
Could not connect to the voice channel in time. |
|||
~discord.ClientException |
|||
You are already connected to a voice channel. |
|||
~discord.opus.OpusNotLoaded |
|||
The opus library has not been loaded. |
|||
|
|||
Returns |
|||
-------- |
|||
:class:`~discord.VoiceProtocol` |
|||
A voice client that is fully connected to the voice server. |
|||
""" |
|||
return await self.connect(timeout=timeout, reconnect=reconnect, cls=cls, ring=ring) |
|||
|
|||
@_running_only |
|||
async def disconnect(self, **kwargs) -> None: |
|||
"""|coro| |
|||
|
|||
Disconnects this voice client from voice. |
|||
|
|||
There is an alias of this called :attr:`leave`. |
|||
""" |
|||
state = self._state |
|||
if not (client := state._get_voice_client(self.channel.me.id)): |
|||
return |
|||
|
|||
return await client.disconnect(**kwargs) |
|||
|
|||
@_running_only |
|||
async def leave(self, **kwargs) -> None: |
|||
"""|coro| |
|||
|
|||
Disconnects this voice client from voice. |
|||
|
|||
This is an alias of :attr:`disconnect`. |
|||
""" |
|||
return await self.disconnect(**kwargs) |
|||
|
|||
def voice_state_for(self, user) -> Optional[VoiceState]: |
|||
"""Retrieves the :class:`VoiceState` for a specified :class:`User`. |
|||
|
|||
If the :class:`User` has no voice state then this function returns |
|||
``None``. |
|||
|
|||
Parameters |
|||
------------ |
|||
user: :class:`User` |
|||
The user to retrieve the voice state for. |
|||
|
|||
Returns |
|||
-------- |
|||
Optional[:class:`VoiceState`] |
|||
The voice state associated with this user. |
|||
""" |
|||
return self._state._voice_state_for(user.id) |
|||
|
|||
|
|||
class GroupCall(PrivateCall): |
|||
"""Represents a Discord group call. |
|||
|
|||
This is accompanied with a :class:`CallMessage` denoting the information. |
|||
|
|||
Attributes |
|||
----------- |
|||
channel: :class:`GroupChannel` |
|||
The channel the group call is in. |
|||
message: Optional[:class:`Message`] |
|||
The message associated with this group call (if available). |
|||
unavailable: :class:`bool` |
|||
Denotes if this group call is unavailable. |
|||
ringing: List[:class:`~discord.abc.User`] |
|||
A list of users that are currently being rung to join the call. |
|||
region: :class:`str` |
|||
The region the group call is being hosted in. |
|||
|
|||
.. versionchanged:: 2.0 |
|||
The type of this attribute has changed to :class:`str`. |
|||
""" |
|||
|
|||
if TYPE_CHECKING: |
|||
channel: GroupChannel |
|||
|
|||
def _update( |
|||
self, *, ringing: List[int] = [], region: str = MISSING |
|||
) -> None: |
|||
if region is not MISSING: |
|||
self.region = region |
|||
|
|||
lookup: Dict[int, abcUser] = {u.id: u for u in self.channel.recipients} |
|||
me = self.channel.me |
|||
lookup[me.id] = me |
|||
self.ringing = list(filter(None, map(lookup.get, ringing))) |
|||
|
|||
@property |
|||
def members(self) -> List[abcUser]: |
|||
"""List[:class:`User`]: Returns all users that are currently in this call.""" |
|||
ret: List[abcUser] = [u for u in self.channel.recipients if self._is_participating(u)] |
|||
me = self.channel.me |
|||
if self._is_participating(me): |
|||
ret.append(me) |
|||
|
|||
return ret |
|||
|
|||
@_running_only |
|||
async def ring(self, *recipients) -> None: |
|||
await self._state.http.ring(self._channel_id, *{r.id for r in recipients}) |
|||
|
|||
@_running_only |
|||
async def stop_ringing(self, *recipients) -> None: |
|||
await self._state.http.stop_ringing(self._channel_id, *{r.id for r in recipients}) |
|||
|
|||
|
|||
Call = Union[PrivateCall, GroupCall] |
|||
File diff suppressed because it is too large
@ -0,0 +1,705 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2021-present Dolfies |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from datetime import datetime |
|||
from typing import Any, Dict, List, Optional, Protocol, Tuple, Type, runtime_checkable, TYPE_CHECKING, Union |
|||
|
|||
from .enums import AppCommandOptionType, AppCommandType, ChannelType, InteractionType, try_enum |
|||
from .errors import InvalidData |
|||
from .utils import _generate_session_id, time_snowflake |
|||
|
|||
if TYPE_CHECKING: |
|||
from .abc import Messageable, Snowflake |
|||
from .interactions import Interaction |
|||
from .message import Message |
|||
from .state import ConnectionState |
|||
|
|||
__all__ = ( |
|||
'ApplicationCommand', |
|||
'BaseCommand', |
|||
'UserCommand', |
|||
'MessageCommand', |
|||
'SlashCommand', |
|||
'SubCommand', |
|||
'Option', |
|||
'OptionChoice', |
|||
) |
|||
|
|||
|
|||
@runtime_checkable |
|||
class ApplicationCommand(Protocol): |
|||
"""An ABC that represents a useable application command. |
|||
|
|||
The following implement this ABC: |
|||
|
|||
- :class:`~discord.BaseCommand` |
|||
- :class:`~discord.UserCommand` |
|||
- :class:`~discord.MessageCommand` |
|||
- :class:`~discord.SlashCommand` |
|||
- :class:`~discord.SubCommand` |
|||
|
|||
Attributes |
|||
----------- |
|||
name: :class:`str` |
|||
The command's name. |
|||
description: :class:`str` |
|||
The command's description, if any. |
|||
version: :class:`int` |
|||
The command's version. |
|||
type: :class:`AppCommandType` |
|||
The type of application command. |
|||
default_permission: :class:`bool` |
|||
Whether the command is enabled in guilds by default. |
|||
""" |
|||
|
|||
__slots__ = () |
|||
|
|||
if TYPE_CHECKING: |
|||
_state: ConnectionState |
|||
_application_id: int |
|||
name: str |
|||
description: str |
|||
version: int |
|||
type: AppCommandType |
|||
target_channel: Optional[Messageable] |
|||
default_permission: bool |
|||
|
|||
async def __call__(self, data, channel: Optional[Messageable] = None) -> Interaction: |
|||
channel = channel or self.target_channel |
|||
if channel is None: |
|||
raise TypeError('__call__() missing 1 required argument: \'channel\'') |
|||
state = self._state |
|||
acc_channel = await channel._get_channel() |
|||
nonce = str(time_snowflake(datetime.utcnow())) |
|||
type = InteractionType.application_command |
|||
|
|||
state._interaction_cache[nonce] = (type.value, data['name'], acc_channel) |
|||
try: |
|||
await state.http.interact(type, data, acc_channel, form_data=True, nonce=nonce, application_id=self._application_id) |
|||
i = await state.client.wait_for( |
|||
'interaction_finish', |
|||
check=lambda d: d.nonce == nonce, |
|||
timeout=7, |
|||
) |
|||
except TimeoutError as exc: |
|||
raise InvalidData('Did not receive a response from Discord') from exc |
|||
finally: # Cleanup even if we failed |
|||
state._interaction_cache.pop(nonce, None) |
|||
return i |
|||
|
|||
|
|||
class BaseCommand(ApplicationCommand): |
|||
"""Represents a base command. |
|||
|
|||
Attributes |
|||
---------- |
|||
id: :class:`int` |
|||
The command's ID. |
|||
name: :class:`str` |
|||
The command's name. |
|||
description: :class:`str` |
|||
The command's description, if any. |
|||
version: :class:`int` |
|||
The command's version. |
|||
type: :class:`AppCommandType` |
|||
The type of application command. |
|||
default_permission: :class:`bool` |
|||
Whether the command is enabled in guilds by default. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'name', |
|||
'description', |
|||
'id', |
|||
'version', |
|||
'type', |
|||
'default_permission', |
|||
'_data', |
|||
'_state', |
|||
'_channel', |
|||
'_application_id', |
|||
'_dm_permission', |
|||
'_default_member_permissions', |
|||
) |
|||
|
|||
def __init__( |
|||
self, *, state: ConnectionState, data: Dict[str, Any], channel: Optional[Messageable] = None |
|||
) -> None: |
|||
self._state = state |
|||
self._data = data |
|||
self.name = data['name'] |
|||
self.description = data['description'] |
|||
self._channel = channel |
|||
self._application_id: int = int(data['application_id']) |
|||
self.id: int = int(data['id']) |
|||
self.version = int(data['version']) |
|||
self.type = try_enum(AppCommandType, data['type']) |
|||
self.default_permission: bool = data['default_permission'] |
|||
self._dm_permission = data['dm_permission'] |
|||
self._default_member_permissions = data['default_member_permissions'] |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} id={self.id} name={self.name}>' |
|||
|
|||
def is_group(self) -> bool: |
|||
"""Query whether this command is a group. |
|||
|
|||
Here for compatibility purposes. |
|||
|
|||
Returns |
|||
------- |
|||
:class:`bool` |
|||
Whether this command is a group. |
|||
""" |
|||
return False |
|||
|
|||
@property |
|||
def application(self): |
|||
"""The application this command belongs to.""" |
|||
... |
|||
#return self._state.get_application(self._application_id) |
|||
|
|||
@property |
|||
def target_channel(self) -> Optional[Messageable]: |
|||
"""Optional[:class:`Messageable`]: The channel this application command will be used on. |
|||
|
|||
You can set this in order to use this command in a different channel without re-fetching it. |
|||
""" |
|||
return self._channel |
|||
|
|||
@target_channel.setter |
|||
def target_channel(self, value: Optional[Messageable]) -> None: |
|||
from .abc import Messageable |
|||
if not isinstance(value, Messageable) and value is not None: |
|||
raise TypeError('channel must derive from Messageable') |
|||
self._channel = value |
|||
|
|||
|
|||
class SlashMixin(ApplicationCommand, Protocol): |
|||
if TYPE_CHECKING: |
|||
_parent: SlashCommand |
|||
options: List[Option] |
|||
children: List[SubCommand] |
|||
|
|||
async def __call__(self, options, channel=None): |
|||
obj = self._parent |
|||
command = obj._data |
|||
command['name_localized'] = command['name'] |
|||
data = { |
|||
'application_command': command, |
|||
'attachments': [], |
|||
'id': str(obj.id), |
|||
'name': obj.name, |
|||
'options': options, |
|||
'type': obj.type.value, |
|||
'version': str(obj.version), |
|||
} |
|||
return await super().__call__(data, channel) |
|||
|
|||
def _parse_kwargs(self, kwargs: Dict[str, Any]) -> List[Dict[str, Any]]: |
|||
possible_options = {o.name: o for o in self.options} |
|||
kwargs = {k: v for k, v in kwargs.items() if k in possible_options} |
|||
options = [] |
|||
|
|||
for k, v in kwargs.items(): |
|||
option = possible_options[k] |
|||
type = option.type |
|||
|
|||
if type in { |
|||
AppCommandOptionType.user, |
|||
AppCommandOptionType.channel, |
|||
AppCommandOptionType.role, |
|||
AppCommandOptionType.mentionable, |
|||
}: |
|||
v = str(v.id) |
|||
elif type is AppCommandOptionType.boolean: |
|||
v = bool(v) |
|||
else: |
|||
v = option._convert(v) |
|||
|
|||
if type is AppCommandOptionType.string: |
|||
v = str(v) |
|||
elif type is AppCommandOptionType.integer: |
|||
v = int(v) |
|||
elif type is AppCommandOptionType.number: |
|||
v = float(v) |
|||
|
|||
options.append({'name': k, 'value': v, 'type': type.value}) |
|||
|
|||
return options |
|||
|
|||
def _unwrap_options(self, data: List[Dict[str, Any]]) -> None: |
|||
options = [] |
|||
children = [] |
|||
for option in data: |
|||
type = try_enum(AppCommandOptionType, option['type']) |
|||
if type in { |
|||
AppCommandOptionType.sub_command, |
|||
AppCommandOptionType.sub_command_group, |
|||
}: |
|||
children.append(SubCommand(parent=self, data=option)) |
|||
else: |
|||
options.append(Option(option)) |
|||
|
|||
for child in children: |
|||
setattr(self, child.name, child) |
|||
|
|||
self.options = options |
|||
self.children = children |
|||
|
|||
|
|||
class UserCommand(BaseCommand): |
|||
"""Represents a user command.""" |
|||
|
|||
__slots__ = ('_user',) |
|||
|
|||
def __init__(self, *, user: Optional[Snowflake] = None, **kwargs): |
|||
super().__init__(**kwargs) |
|||
self._user = user |
|||
|
|||
async def __call__( |
|||
self, user: Optional[Snowflake] = None, *, channel: Optional[Messageable] = None |
|||
): |
|||
"""Use the user command. |
|||
|
|||
Parameters |
|||
---------- |
|||
user: Optional[:class:`User`] |
|||
The user to use the command on. Overrides :attr:`target_user`. |
|||
Required if :attr:`target_user` is not set. |
|||
channel: Optional[:class:`abc.Messageable`] |
|||
The channel to use the command on. Overrides :attr:`target_channel`. |
|||
Required if :attr:`target_channel` is not set. |
|||
""" |
|||
user = user or self._user |
|||
if user is None: |
|||
raise TypeError('__call__() missing 1 required positional argument: \'user\'') |
|||
|
|||
command = self._data |
|||
command['name_localized'] = command['name'] |
|||
data = { |
|||
'application_command': command, |
|||
'attachments': [], |
|||
'id': str(self.id), |
|||
'name': self.name, |
|||
'options': [], |
|||
'target_id': str(user.id), |
|||
'type': self.type.value, |
|||
'version': str(self.version), |
|||
} |
|||
return await super().__call__(data, channel) |
|||
|
|||
@property |
|||
def target_user(self) -> Optional[Snowflake]: |
|||
"""Optional[:class:`Snowflake`]: The user this application command will be used on. |
|||
|
|||
You can set this in order to use this command on a different user without re-fetching it. |
|||
""" |
|||
return self._user |
|||
|
|||
@target_user.setter |
|||
def target_user(self, value: Optional[Snowflake]) -> None: |
|||
from .abc import Snowflake |
|||
if not isinstance(value, Snowflake) and value is not None: |
|||
raise TypeError('user must be Snowflake') |
|||
self._user = value |
|||
|
|||
|
|||
class MessageCommand(BaseCommand): |
|||
"""Represents a message command. |
|||
|
|||
Attributes |
|||
---------- |
|||
id: :class:`int` |
|||
The command's ID. |
|||
name: :class:`str` |
|||
The command's name. |
|||
description: :class:`str` |
|||
The command's description, if any. |
|||
type: :class:`AppCommandType` |
|||
The type of application command. Always :class:`AppCommandType.message`. |
|||
default_permission: :class:`bool` |
|||
Whether the command is enabled in guilds by default. |
|||
""" |
|||
|
|||
__slots__ = ('_message',) |
|||
|
|||
def __init__(self, *, message: Optional[Message] = None, **kwargs): |
|||
super().__init__(**kwargs) |
|||
self._message = message |
|||
|
|||
async def __call__( |
|||
self, message: Optional[Message] = None, *, channel: Optional[Messageable] = None |
|||
): |
|||
"""Use the message command. |
|||
|
|||
Parameters |
|||
---------- |
|||
message: Optional[:class:`Message`] |
|||
The message to use the command on. Overrides :attr:`target_message`. |
|||
Required if :attr:`target_message` is not set. |
|||
channel: Optional[:class:`abc.Messageable`] |
|||
The channel to use the command on. Overrides :attr:`target_channel`. |
|||
Required if :attr:`target_channel` is not set. |
|||
""" |
|||
message = message or self._message |
|||
if message is None: |
|||
raise TypeError('__call__() missing 1 required positional argument: \'message\'') |
|||
|
|||
command = self._data |
|||
command['name_localized'] = command['name'] |
|||
data = { |
|||
'application_command': command, |
|||
'attachments': [], |
|||
'id': str(self.id), |
|||
'name': self.name, |
|||
'options': [], |
|||
'target_id': str(message.id), |
|||
'type': self.type.value, |
|||
'version': str(self.version), |
|||
} |
|||
return await super().__call__(data, channel) |
|||
|
|||
@property |
|||
def target_message(self) -> Optional[Message]: |
|||
"""Optional[:class:`Message`]: The message this application command will be used on. |
|||
|
|||
You can set this in order to use this command on a different message without re-fetching it. |
|||
""" |
|||
return self._message |
|||
|
|||
@target_message.setter |
|||
def target_message(self, value: Optional[Message]) -> None: |
|||
from .message import Message |
|||
if not isinstance(value, Message) and value is not None: |
|||
raise TypeError('message must be Message') |
|||
self._message = value |
|||
|
|||
|
|||
class SlashCommand(BaseCommand, SlashMixin): |
|||
"""Represents a slash command. |
|||
|
|||
Attributes |
|||
---------- |
|||
id: :class:`int` |
|||
The command's ID. |
|||
name: :class:`str` |
|||
The command's name. |
|||
description: :class:`str` |
|||
The command's description, if any. |
|||
type: :class:`AppCommandType` |
|||
The type of application command. Always :class:`AppCommandType.chat_input`. |
|||
default_permission: :class:`bool` |
|||
Whether the command is enabled in guilds by default. |
|||
options: List[:class:`Option`] |
|||
The command's options. |
|||
children: List[:class:`SubCommand`] |
|||
The command's subcommands. If a command has subcommands, it is a group and cannot be used. |
|||
You can access (and use) subcommands directly as attributes of the class. |
|||
""" |
|||
|
|||
__slots__ = ('_parent', 'options', 'children') |
|||
|
|||
def __init__( |
|||
self, *, data: Dict[str, Any], **kwargs |
|||
) -> None: |
|||
super().__init__(data=data, **kwargs) |
|||
self._parent = self |
|||
self._unwrap_options(data.get('options', [])) |
|||
|
|||
async def __call__(self, channel: Optional[Messageable] = None, /, **kwargs): |
|||
r"""Use the slash command. |
|||
|
|||
Parameters |
|||
---------- |
|||
channel: Optional[:class:`abc.Messageable`] |
|||
The channel to use the command on. Overrides :attr:`target_channel`. |
|||
Required if :attr:`target_message` is not set. |
|||
\*\*kwargs: Any |
|||
The options to use. These will be casted to the correct type. |
|||
If an option has choices, they are automatically converted from name to value for you. |
|||
|
|||
Raises |
|||
------ |
|||
TypeError |
|||
Attempted to use a group. |
|||
""" |
|||
if self.is_group(): |
|||
raise TypeError('Cannot use a group') |
|||
|
|||
return await super().__call__(self._parse_kwargs(kwargs), channel) |
|||
|
|||
def __repr__(self) -> str: |
|||
BASE = f'<SlashCommand id={self.id} name={self.name}' |
|||
if self.options: |
|||
BASE += f' options={len(self.options)}' |
|||
if self.children: |
|||
BASE += f' children={len(self.children)}' |
|||
return BASE + '>' |
|||
|
|||
def is_group(self) -> bool: |
|||
"""Query whether this command is a group. |
|||
|
|||
Returns |
|||
------- |
|||
:class:`bool` |
|||
Whether this command is a group. |
|||
""" |
|||
return bool(self.children) |
|||
|
|||
|
|||
class SubCommand(SlashMixin): |
|||
"""Represents a slash command child. |
|||
|
|||
This could be a subcommand, or a subgroup. |
|||
|
|||
Attributes |
|||
---------- |
|||
parent: :class:`SlashCommand` |
|||
The parent command. |
|||
name: :class:`str` |
|||
The command's name. |
|||
description: :class:`str` |
|||
The command's description, if any. |
|||
type: :class:`AppCommandType` |
|||
The type of application command. Always :class:`AppCommandType.chat_input`. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'_parent', |
|||
'_state', |
|||
'_type', |
|||
'parent', |
|||
'options', |
|||
'children', |
|||
'type', |
|||
) |
|||
|
|||
def __init__(self, *, parent, data): |
|||
self.name = data['name'] |
|||
self.description = data.get('description') |
|||
self._state = parent._state |
|||
self.parent: Union[SlashCommand, SubCommand] = parent |
|||
self._parent: SlashCommand = getattr(parent, 'parent', parent) # type: ignore |
|||
self.type = AppCommandType.chat_input # Avoid confusion I guess |
|||
self._type: AppCommandOptionType = try_enum(AppCommandOptionType, data['type']) |
|||
self._unwrap_options(data.get('options', [])) |
|||
|
|||
def _walk_parents(self): |
|||
parent = self.parent |
|||
while True: |
|||
if isinstance(parent, SlashCommand): |
|||
break |
|||
else: |
|||
yield parent |
|||
parent = parent.parent |
|||
|
|||
async def __call__(self, channel: Optional[Messageable] = None, /, **kwargs): |
|||
r"""Use the sub command. |
|||
|
|||
Parameters |
|||
---------- |
|||
channel: Optional[:class:`abc.Messageable`] |
|||
The channel to use the command on. Overrides :attr:`target_channel`. |
|||
Required if :attr:`target_message` is not set. |
|||
\*\*kwargs: Any |
|||
The options to use. These will be casted to the correct type. |
|||
If an option has choices, they are automatically converted from name to value for you. |
|||
|
|||
Raises |
|||
------ |
|||
TypeError |
|||
Attempted to use a group. |
|||
""" |
|||
if self.is_group(): |
|||
raise TypeError('Cannot use a group') |
|||
|
|||
options = [{ |
|||
'type': self._type.value, |
|||
'name': self.name, |
|||
'options': self._parse_kwargs(kwargs), |
|||
}] |
|||
for parent in self._walk_parents(): |
|||
options = [{ |
|||
'type': parent._type.value, |
|||
'name': parent.name, |
|||
'options': options, |
|||
}] |
|||
|
|||
return await super().__call__(options, channel) |
|||
|
|||
def __repr__(self) -> str: |
|||
BASE = f'<SubCommand name={self.name}' |
|||
if self.options: |
|||
BASE += f' options={len(self.options)}' |
|||
if self.children: |
|||
BASE += f' children={len(self.children)}' |
|||
return BASE + '>' |
|||
|
|||
@property |
|||
def _application_id(self) -> int: |
|||
return self._parent._application_id |
|||
|
|||
@property |
|||
def version(self) -> int: |
|||
""":class:`int`: The version of the command.""" |
|||
return self._parent.version |
|||
|
|||
@property |
|||
def default_permission(self) -> bool: |
|||
""":class:`bool`: Whether the command is enabled in guilds by default.""" |
|||
return self._parent.default_permission |
|||
|
|||
def is_group(self) -> bool: |
|||
"""Query whether this command is a group. |
|||
|
|||
Returns |
|||
------- |
|||
:class:`bool` |
|||
Whether this command is a group. |
|||
""" |
|||
return self._type is AppCommandOptionType.sub_command_group |
|||
|
|||
@property |
|||
def application(self): |
|||
"""The application this command belongs to.""" |
|||
return self._parent.application |
|||
|
|||
@property |
|||
def target_channel(self) -> Optional[Messageable]: |
|||
"""Optional[:class:`abc.Messageable`]: The channel this command will be used on. |
|||
|
|||
You can set this in order to use this command on a different channel without re-fetching it. |
|||
""" |
|||
return self._parent.target_channel |
|||
|
|||
@target_channel.setter |
|||
def target_channel(self, value: Optional[Messageable]) -> None: |
|||
self._parent.target_channel = value |
|||
|
|||
|
|||
class Option: # TODO: Add validation |
|||
"""Represents a command option. |
|||
|
|||
Attributes |
|||
---------- |
|||
name: :class:`str` |
|||
The option's name. |
|||
description: :class:`str` |
|||
The option's description, if any. |
|||
type: :class:`AppCommandOptionType` |
|||
The type of option. |
|||
required: :class:`bool` |
|||
Whether the option is required. |
|||
min_value: Optional[Union[:class:`int`, :class:`float`]] |
|||
Minimum value of the option. Only applicable to :attr:`AppCommandOptionType.integer` and :attr:`AppCommandOptionType.number`. |
|||
max_value: Optional[Union[:class:`int`, :class:`float`]] |
|||
Maximum value of the option. Only applicable to :attr:`AppCommandOptionType.integer` and :attr:`AppCommandOptionType.number`. |
|||
choices: List[:class:`OptionChoice`] |
|||
A list of possible choices to choose from. If these are present, you must choose one from them. |
|||
Only applicable to :attr:`AppCommandOptionType.string`, :attr:`AppCommandOptionType.integer`, and :attr:`AppCommandOptionType.number`. |
|||
channel_types: List[:class:`ChannelType`] |
|||
A list of channel types that you can choose from. If these are present, you must choose a channel that is one of these types. |
|||
Only applicable to :attr:`AppCommandOptionType.channel`. |
|||
autocomplete: :class:`bool` |
|||
Whether the option autocompletes. Always ``False`` if :attr:`choices` are present. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'name', |
|||
'description', |
|||
'type', |
|||
'required', |
|||
'min_value', |
|||
'max_value', |
|||
'choices', |
|||
'channel_types', |
|||
'autocomplete', |
|||
) |
|||
|
|||
def __init__(self, data): |
|||
self.name: str = data['name'] |
|||
self.description: str = data['description'] |
|||
self.type: AppCommandOptionType = try_enum(AppCommandOptionType, data['type']) |
|||
self.required: bool = data.get('required', False) |
|||
self.min_value: Optional[Union[int, float]] = data.get('min_value') |
|||
self.max_value: Optional[int] = data.get('max_value') |
|||
self.choices = [OptionChoice(choice, self.type) for choice in data.get('choices', [])] |
|||
self.channel_types: List[ChannelType] = [try_enum(ChannelType, c) for c in data.get('channel_types', [])] |
|||
self.autocomplete: bool = data.get('autocomplete', False) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<Option name={self.name} type={self.type} required={self.required}>' |
|||
|
|||
def _convert(self, value): |
|||
for choice in self.choices: |
|||
if (new_value := choice._convert(value)) != value: |
|||
return new_value |
|||
return value |
|||
|
|||
|
|||
class OptionChoice: |
|||
"""Represents a choice for an option. |
|||
|
|||
Attributes |
|||
---------- |
|||
name: :class:`str` |
|||
The choice's displayed name. |
|||
value: Any |
|||
The choice's value. The type of this depends on the option's type. |
|||
""" |
|||
|
|||
__slots__ = ('name', 'value') |
|||
|
|||
def __init__(self, data: Dict[str, str], type: AppCommandOptionType): |
|||
self.name: str = data['name'] |
|||
self.value: Union[str, int, float] |
|||
if type is AppCommandOptionType.string: |
|||
self.value = data['value'] |
|||
elif type is AppCommandOptionType.integer: |
|||
self.value = int(data['value']) |
|||
elif type is AppCommandOptionType.number: |
|||
self.value = float(data['value']) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<OptionChoice name={self.name} value={self.value}>' |
|||
|
|||
def _convert(self, value): |
|||
if value == self.name: |
|||
return self.value |
|||
return value |
|||
|
|||
|
|||
def _command_factory(command_type: int) -> Tuple[AppCommandType, Type[BaseCommand]]: |
|||
value = try_enum(AppCommandType, command_type) |
|||
if value is AppCommandType.chat_input: |
|||
return value, SlashCommand |
|||
elif value is AppCommandType.user: |
|||
return value, UserCommand |
|||
elif value is AppCommandType.message: |
|||
return value, MessageCommand |
|||
else: |
|||
return value, BaseCommand # IDK about this |
|||
@ -0,0 +1,161 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2021-present Dolfies |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
from __future__ import annotations |
|||
|
|||
from typing import Optional, TYPE_CHECKING |
|||
|
|||
from .utils import MISSING |
|||
|
|||
if TYPE_CHECKING: |
|||
from .state import ConnectionState |
|||
|
|||
__all__ = ( |
|||
'PartialConnection', |
|||
'Connection', |
|||
) |
|||
|
|||
|
|||
class PartialConnection: |
|||
"""Represents a partial Discord profile connection |
|||
|
|||
This is the info you get for other people's connections. |
|||
|
|||
Attributes |
|||
---------- |
|||
id: :class:`str` |
|||
The connection's account ID. |
|||
name: :class:`str` |
|||
The connection's account name. |
|||
type: :class:`str` |
|||
The connection service (e.g. 'youtube') |
|||
verified: :class:`bool` |
|||
Whether the connection is verified. |
|||
revoked: :class:`bool` |
|||
Whether the connection is revoked. |
|||
visible: :class:`bool` |
|||
Whether the connection is visible on the user's profile. |
|||
""" |
|||
|
|||
__slots__ = ('id', 'name', 'type', 'verified', 'revoked', 'visible') |
|||
|
|||
def __init__(self, data: dict): |
|||
self._update(data) |
|||
|
|||
def _update(self, data: dict): |
|||
self.id: str = data['id'] |
|||
self.name: str = data['name'] |
|||
self.type: str = data['type'] |
|||
|
|||
self.verified: bool = data['verified'] |
|||
self.revoked: bool = data.get('revoked', False) |
|||
self.visible: bool = True |
|||
|
|||
|
|||
class Connection(PartialConnection): |
|||
"""Represents a Discord profile connection |
|||
|
|||
Attributes |
|||
---------- |
|||
friend_sync: :class:`bool` |
|||
Whether friends are synced over the connection. |
|||
show_activity: :class:`bool` |
|||
Whether activities from this connection will be shown in presences. |
|||
access_token: :class:`str` |
|||
The OAuth2 access token for the account, if applicable. |
|||
""" |
|||
|
|||
__slots__ = ('_state', 'visible', 'friend_sync', 'show_activity', 'access_token') |
|||
|
|||
def __init__(self, *, data: dict, state: ConnectionState): |
|||
super().__init__(data) |
|||
self._state = state |
|||
self.access_token: Optional[str] = None |
|||
|
|||
def _update(self, data: dict): |
|||
super()._update(data) |
|||
self.visible: bool = bool(data.get('visibility', True)) |
|||
self.friend_sync: bool = data.get('friend_sync', False) |
|||
self.show_activity: bool = data.get('show_activity', True) |
|||
|
|||
# Only sometimes in the payload |
|||
try: |
|||
self.access_token: Optional[str] = data['access_token'] |
|||
except KeyError: |
|||
pass |
|||
|
|||
async def edit(self, *, visible: bool = MISSING, show_activity: bool = MISSING): |
|||
"""|coro| |
|||
|
|||
Edit the connection. |
|||
|
|||
All parameters are optional. |
|||
|
|||
Parameters |
|||
---------- |
|||
visible: :class:`bool` |
|||
Whether the connection is visible on your profile. |
|||
|
|||
Raises |
|||
------ |
|||
HTTPException |
|||
Editing the connection failed. |
|||
""" |
|||
payload = {} |
|||
if visible is not MISSING: |
|||
payload['visibility'] = visible |
|||
if show_activity is not MISSING: |
|||
payload['show_activity'] = show_activity |
|||
data = await self._state.http.edit_connection(self.type, self.id, **payload) |
|||
self._update(data) |
|||
|
|||
async def delete(self) -> None: |
|||
"""|coro| |
|||
|
|||
Removes the connection. |
|||
|
|||
Raises |
|||
------ |
|||
HTTPException |
|||
Deleting the connection failed. |
|||
""" |
|||
await self._state.http.delete_connection(self.type, self.id) |
|||
|
|||
async def fetch_access_token(self) -> str: |
|||
"""|coro| |
|||
|
|||
Retrieves a new access token for the connection. |
|||
|
|||
Raises |
|||
------ |
|||
HTTPException |
|||
Retrieving the access token failed. |
|||
|
|||
Returns |
|||
------- |
|||
:class:`str` |
|||
The new access token. |
|||
""" |
|||
data = await self._state.http.get_connection_token(self.type, self.id) |
|||
self.access_token = token = data['access_token'] |
|||
return token |
|||
File diff suppressed because it is too large
@ -0,0 +1,102 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2021-present Dolfies |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import List, Optional, TYPE_CHECKING |
|||
|
|||
from .colour import Colour |
|||
from .object import Object |
|||
|
|||
if TYPE_CHECKING: |
|||
from .guild import Guild |
|||
from .state import ConnectionState |
|||
from .types.snowflake import Snowflake |
|||
|
|||
# fmt: off |
|||
__all__ = ( |
|||
'GuildFolder', |
|||
) |
|||
# fmt: on |
|||
|
|||
|
|||
class GuildFolder: |
|||
"""Represents a guild folder |
|||
|
|||
.. note:: |
|||
Guilds not in folders *are* actually in folders API wise, with them being the only member. |
|||
Because Discord. |
|||
|
|||
Attributes |
|||
---------- |
|||
id: Union[:class:`str`, :class:`int`] |
|||
The ID of the folder. |
|||
name: :class:`str` |
|||
The name of the folder. |
|||
guilds: List[:class:`Guild`] |
|||
The guilds in the folder. |
|||
""" |
|||
__slots__ = ('_state', 'id', 'name', '_colour', 'guilds') |
|||
|
|||
def __init__(self, *, data, state: ConnectionState) -> None: |
|||
self._state = state |
|||
self.id: Snowflake = data['id'] |
|||
self.name: str = data['name'] |
|||
self._colour: int = data['color'] |
|||
self.guilds: List[Guild] = list(filter(None, map(self._get_guild, data['guild_ids']))) # type: ignore - Lying for better developer UX |
|||
|
|||
def _get_guild(self, id): |
|||
return self._state._get_guild(int(id)) or Object(id=int(id)) |
|||
|
|||
@property |
|||
def colour(self) -> Optional[Colour]: |
|||
"""Optional[:class:`Colour`] The colour of the folder. |
|||
|
|||
There is an alias for this called :attr:`color`. |
|||
""" |
|||
colour = self._colour |
|||
return Colour(colour) if colour is not None else None |
|||
|
|||
@property |
|||
def color(self) -> Optional[Colour]: |
|||
"""Optional[:class:`Color`] The color of the folder. |
|||
|
|||
This is an alias for :attr:`colour`. |
|||
""" |
|||
return self.colour |
|||
|
|||
def __str__(self) -> str: |
|||
return self.name or 'None' |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<GuildFolder id={self.id} name={self.name} guilds={self.guilds!r}>' |
|||
|
|||
def __len__(self) -> int: |
|||
return len(self.name) |
|||
|
|||
def __eq__(self, other) -> bool: |
|||
return isinstance(other, GuildFolder) and self.id == other.id |
|||
|
|||
def __ne__(self, other) -> bool: |
|||
return not self.__eq__(other) |
|||
File diff suppressed because it is too large
File diff suppressed because it is too large
@ -0,0 +1,302 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
import asyncio |
|||
from typing import Awaitable, TYPE_CHECKING, TypeVar, Optional, Any, Callable, Union, List, Tuple, AsyncIterator, Dict |
|||
|
|||
from .errors import InvalidData |
|||
from .utils import time_snowflake, utcnow |
|||
from .object import Object |
|||
from .commands import _command_factory |
|||
from .enums import AppCommandType |
|||
|
|||
__all__ = ( |
|||
'CommandIterator', |
|||
'FakeCommandIterator', |
|||
) |
|||
|
|||
if TYPE_CHECKING: |
|||
from .user import User |
|||
from .message import Message |
|||
from .abc import Snowflake, Messageable |
|||
from .commands import ApplicationCommand |
|||
from .channel import DMChannel |
|||
|
|||
T = TypeVar('T') |
|||
OT = TypeVar('OT') |
|||
_Func = Callable[[T], Union[OT, Awaitable[OT]]] |
|||
|
|||
OLDEST_OBJECT = Object(id=0) |
|||
|
|||
|
|||
|
|||
def _is_fake(item: Union[Messageable, Message]) -> bool: # I hate this too, but <circular imports> and performance exist |
|||
try: |
|||
item.guild # type: ignore |
|||
except AttributeError: |
|||
return True |
|||
try: |
|||
item.channel.me # type: ignore |
|||
except AttributeError: |
|||
return False |
|||
return True |
|||
|
|||
|
|||
class CommandIterator: |
|||
def __new__(cls, *args, **kwargs) -> Union[CommandIterator, FakeCommandIterator]: |
|||
if _is_fake(args[0]): |
|||
return FakeCommandIterator(*args) |
|||
else: |
|||
return super().__new__(cls) |
|||
|
|||
def __init__( |
|||
self, |
|||
item: Union[Messageable, Message], |
|||
type: AppCommandType, |
|||
query: Optional[str] = None, |
|||
limit: Optional[int] = None, |
|||
command_ids: Optional[List[int]] = None, |
|||
**kwargs, |
|||
) -> None: |
|||
if query and command_ids: |
|||
raise TypeError('Cannot specify both query and command_ids') |
|||
if limit is not None and limit <= 0: |
|||
raise ValueError('limit must be > 0') |
|||
|
|||
self.item = item |
|||
self.channel = None |
|||
self.state = item._state |
|||
self._tuple = None |
|||
self.type = type |
|||
_, self.cls = _command_factory(int(type)) |
|||
self.query = query |
|||
self.limit = limit |
|||
self.command_ids = command_ids |
|||
self.applications: bool = kwargs.get('applications', True) |
|||
self.application: Snowflake = kwargs.get('application', None) |
|||
self.commands = asyncio.Queue() |
|||
|
|||
async def _process_args(self) -> Tuple[DMChannel, Optional[str], Optional[Union[User, Message]]]: |
|||
item = self.item |
|||
if self.type is AppCommandType.user: |
|||
channel = await item._get_channel() # type: ignore |
|||
if getattr(item, 'bot', None): |
|||
item = item |
|||
else: |
|||
item = None |
|||
text = 'user' |
|||
elif self.type is AppCommandType.message: |
|||
message = self.item |
|||
channel = message.channel # type: ignore |
|||
text = 'message' |
|||
elif self.type is AppCommandType.chat_input: |
|||
channel = await item._get_channel() # type: ignore |
|||
item = None |
|||
text = None |
|||
self._process_kwargs(channel) # type: ignore |
|||
return channel, text, item # type: ignore |
|||
|
|||
def _process_kwargs(self, channel) -> None: |
|||
kwargs = { |
|||
'guild_id': channel.guild.id, |
|||
'type': self.type.value, |
|||
'offset': 0, |
|||
} |
|||
if self.applications: |
|||
kwargs['applications'] = True # Only sent if it's True... |
|||
if (app := self.application): |
|||
kwargs['application'] = app.id |
|||
if (query := self.query) is not None: |
|||
kwargs['query'] = query |
|||
if (cmds := self.command_ids): |
|||
kwargs['command_ids'] = cmds |
|||
self.kwargs = kwargs |
|||
|
|||
async def iterate(self) -> AsyncIterator[ApplicationCommand]: |
|||
while True: |
|||
if self.commands.empty(): |
|||
await self.fill_commands() |
|||
|
|||
try: |
|||
yield self.commands.get_nowait() |
|||
except asyncio.QueueEmpty: |
|||
break |
|||
|
|||
def _get_retrieve(self): |
|||
l = self.limit |
|||
if l is None or l > 100: |
|||
r = 100 |
|||
else: |
|||
r = l |
|||
self.retrieve = r |
|||
return r > 0 |
|||
|
|||
async def fill_commands(self) -> None: |
|||
if not self._tuple: # Do the required setup |
|||
self._tuple = await self._process_args() |
|||
|
|||
if not self._get_retrieve(): |
|||
return |
|||
|
|||
state = self.state |
|||
kwargs = self.kwargs |
|||
retrieve = self.retrieve |
|||
nonce = str(time_snowflake(utcnow())) |
|||
|
|||
def predicate(d): |
|||
return d.get('nonce') == nonce |
|||
|
|||
data = None |
|||
for _ in range(3): |
|||
await state.ws.request_commands(**kwargs, limit=retrieve, nonce=nonce) |
|||
try: |
|||
data: Optional[Dict[str, Any]] = await asyncio.wait_for(state.ws.wait_for('guild_application_commands_update', predicate), timeout=3) |
|||
except asyncio.TimeoutError: |
|||
pass |
|||
|
|||
if data is None: |
|||
raise InvalidData('Didn\'t receive a response from Discord') |
|||
|
|||
cmds = data['application_commands'] |
|||
if len(cmds) < retrieve: |
|||
self.limit = 0 |
|||
elif self.limit is not None: |
|||
self.limit -= retrieve |
|||
|
|||
kwargs['offset'] += retrieve |
|||
|
|||
for cmd in cmds: |
|||
self.commands.put_nowait(self.create_command(cmd)) |
|||
|
|||
for app in data.get('applications', []): |
|||
... |
|||
|
|||
def create_command(self, data) -> ApplicationCommand: |
|||
channel, item, value = self._tuple # type: ignore |
|||
if item is not None: |
|||
kwargs = {item: value} |
|||
else: |
|||
kwargs = {} |
|||
return self.cls(state=channel._state, data=data, channel=channel, **kwargs) |
|||
|
|||
|
|||
class FakeCommandIterator: |
|||
def __init__( |
|||
self, |
|||
item: Union[User, Message, DMChannel], |
|||
type: AppCommandType, |
|||
query: Optional[str] = None, |
|||
limit: Optional[int] = None, |
|||
command_ids: Optional[List[int]] = None, |
|||
) -> None: |
|||
if query and command_ids: |
|||
raise TypeError('Cannot specify both query and command_ids') |
|||
if limit is not None and limit <= 0: |
|||
raise ValueError('limit must be > 0') |
|||
|
|||
self.item = item |
|||
self.channel = None |
|||
self._tuple = None |
|||
self.type = type |
|||
_, self.cls = _command_factory(int(type)) |
|||
self.query = query |
|||
self.limit = limit |
|||
self.command_ids = command_ids |
|||
self.has_more = False |
|||
self.commands = asyncio.Queue() |
|||
|
|||
async def _process_args(self) -> Tuple[DMChannel, Optional[str], Optional[Union[User, Message]]]: |
|||
item = self.item |
|||
if self.type is AppCommandType.user: |
|||
channel = await item._get_channel() # type: ignore |
|||
if getattr(item, 'bot', None): |
|||
item = item |
|||
else: |
|||
item = None |
|||
text = 'user' |
|||
elif self.type is AppCommandType.message: |
|||
message = self.item |
|||
channel = message.channel # type: ignore |
|||
text = 'message' |
|||
elif self.type is AppCommandType.chat_input: |
|||
channel = await item._get_channel() # type: ignore |
|||
item = None |
|||
text = None |
|||
if not channel.recipient.bot: # type: ignore - Type checker cannot understand this |
|||
raise TypeError('User is not a bot') |
|||
return channel, text, item # type: ignore |
|||
|
|||
async def iterate(self) -> AsyncIterator[ApplicationCommand]: |
|||
while True: |
|||
if self.commands.empty(): |
|||
await self.fill_commands() |
|||
|
|||
try: |
|||
yield self.commands.get_nowait() |
|||
except asyncio.QueueEmpty: |
|||
break |
|||
|
|||
async def fill_commands(self) -> None: |
|||
if self.has_more: |
|||
return |
|||
|
|||
if not (stuff := self._tuple): |
|||
self._tuple = channel, _, _ = await self._process_args() |
|||
else: |
|||
channel = stuff[0] |
|||
|
|||
limit = self.limit or -1 |
|||
data = await channel._state.http.get_application_commands(channel.recipient.id) |
|||
ids = self.command_ids |
|||
query = self.query and self.query.lower() |
|||
type = self.type.value |
|||
|
|||
for cmd in data: |
|||
if cmd['type'] != type: |
|||
continue |
|||
|
|||
if ids: |
|||
if not int(cmd['id']) in ids: |
|||
continue |
|||
|
|||
if query: |
|||
if not query in cmd['name'].lower(): |
|||
continue |
|||
|
|||
self.commands.put_nowait(self.create_command(cmd)) |
|||
limit -= 1 |
|||
if limit == 0: |
|||
break |
|||
|
|||
self.has_more = True |
|||
|
|||
def create_command(self, data) -> ApplicationCommand: |
|||
channel, item, value = self._tuple # type: ignore |
|||
if item is not None: |
|||
kwargs = {item: value} |
|||
else: |
|||
kwargs = {} |
|||
return self.cls(state=channel._state, data=data, channel=channel, **kwargs) |
|||
@ -0,0 +1,164 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2021-present Dolfies |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import List, Optional, TYPE_CHECKING |
|||
|
|||
from .connections import PartialConnection |
|||
from .flags import PublicUserFlags |
|||
from .member import Member |
|||
from .object import Object |
|||
from .permissions import Permissions |
|||
from .user import Note, User |
|||
from . import utils |
|||
|
|||
if TYPE_CHECKING: |
|||
from datetime import datetime |
|||
|
|||
from .guild import Guild |
|||
from .state import ConnectionState |
|||
|
|||
__all__ = ( |
|||
'UserProfile', |
|||
'MemberProfile', |
|||
) |
|||
|
|||
|
|||
class Profile: |
|||
"""Represents a Discord profile. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Attributes |
|||
---------- |
|||
application_id: Optional[:class:`int`] |
|||
The ID of the application that this user is attached to, if applicable. |
|||
install_url: Optional[:class:`str`] |
|||
The URL to invite the application to your guild with. |
|||
bio: Optional[:class:`str`] |
|||
The user's "about me" field. Could be ``None``. |
|||
premium_since: Optional[:class:`datetime.datetime`] |
|||
An aware datetime object that specifies how long a user has been premium (had Nitro). |
|||
``None`` if the user is not a premium user. |
|||
boosting_since: Optional[:class:`datetime.datetime`] |
|||
An aware datetime object that specifies when a user first boosted a guild. |
|||
connections: Optional[List[:class:`PartialConnection`]] |
|||
The connected accounts that show up on the profile. |
|||
note: :class:`Note` |
|||
Represents the note on the profile. |
|||
mutual_guilds: Optional[List[:class:`Guild`]] |
|||
A list of guilds that you share with the user. |
|||
``None`` if you didn't fetch mutuals. |
|||
mutual_friends: Optional[List[:class:`User`]] |
|||
A list of friends that you share with the user. |
|||
``None`` if you didn't fetch mutuals. |
|||
""" |
|||
|
|||
if TYPE_CHECKING: |
|||
id: int |
|||
application_id: Optional[int] |
|||
_state: ConnectionState |
|||
|
|||
def __init__(self, **kwargs) -> None: # TODO: type data |
|||
data = kwargs.pop('data') |
|||
user = data['user'] |
|||
|
|||
if (member := data.get('guild_member')) is not None: |
|||
member['user'] = user |
|||
kwargs['data'] = member |
|||
else: |
|||
kwargs['data'] = user |
|||
|
|||
super().__init__(**kwargs) |
|||
|
|||
self._flags: int = user.pop('flags', 0) |
|||
self.bio: Optional[str] = user.pop('bio') or None |
|||
self.note: Note = Note(kwargs['state'], self.id, user=self) |
|||
|
|||
self.premium_since: Optional[datetime] = utils.parse_time(data['premium_since']) |
|||
self.boosting_since: Optional[datetime] = utils.parse_time(data['premium_guild_since']) |
|||
self.connections: List[PartialConnection] = [PartialConnection(d) for d in data['connected_accounts']] # TODO: parse these |
|||
|
|||
self.mutual_guilds: Optional[List[Guild]] = self._parse_mutual_guilds(data.get('mutual_guilds')) |
|||
self.mutual_friends: Optional[List[User]] = self._parse_mutual_friends(data.get('mutual_friends')) |
|||
|
|||
application = data.get('application', {}) |
|||
install_params = application.get('install_params', {}) |
|||
self.application_id = app_id = utils._get_as_snowflake(application, 'id') |
|||
self.install_url = application.get('custom_install_url') if not install_params else utils.oauth_url(app_id, permissions=Permissions(int(install_params.get('permissions', 0))), scopes=install_params.get('scopes', utils.MISSING)) # type: ignore - app_id is always present here |
|||
|
|||
def _parse_mutual_guilds(self, mutual_guilds) -> Optional[List[Guild]]: |
|||
if mutual_guilds is None: |
|||
return |
|||
|
|||
state = self._state |
|||
|
|||
def get_guild(guild): |
|||
return state._get_guild(int(guild['id'])) or Object(id=int(guild['id'])) |
|||
|
|||
return list(filter(None, map(get_guild, mutual_guilds))) # type: ignore - Lying for better developer UX |
|||
|
|||
def _parse_mutual_friends(self, mutual_friends) -> Optional[List[User]]: |
|||
if mutual_friends is None: |
|||
return |
|||
|
|||
state = self._state |
|||
return [state.store_user(friend) for friend in mutual_friends] |
|||
|
|||
@property |
|||
def flags(self) -> PublicUserFlags: |
|||
""":class:`PublicUserFlags`: The flags the user has.""" |
|||
return PublicUserFlags._from_value(self._flags) |
|||
|
|||
@property |
|||
def premium(self) -> bool: |
|||
""":class:`bool`: Indicates if the user is a premium user. |
|||
|
|||
There is an alias for this named :attr:`nitro`. |
|||
""" |
|||
return self.premium_since is not None |
|||
|
|||
@property |
|||
def nitro(self) -> bool: |
|||
""":class:`bool`: Indicates if the user is a premium user. |
|||
|
|||
This is an alias for :attr:`premium`. |
|||
""" |
|||
return self.premium |
|||
|
|||
|
|||
class UserProfile(Profile, User): |
|||
"""Represents a Discord user's profile. This is a :class:`User` with extended attributes.""" |
|||
def __repr__(self) -> str: |
|||
return f'<UserProfile id={self.id} name={self.name!r} discriminator={self.discriminator!r} bot={self.bot} system={self.system} premium={self.premium}>' |
|||
|
|||
|
|||
class MemberProfile(Profile, Member): |
|||
"""Represents a Discord member's profile. This is a :class:`Member` with extended attributes.""" |
|||
def __repr__(self) -> str: |
|||
return ( |
|||
f'<MemberProfile id={self._user.id} name={self._user.name!r} discriminator={self._user.discriminator!r}' |
|||
f' bot={self._user.bot} nick={self.nick!r} premium={self.premium} guild={self.guild!r}>' |
|||
) |
|||
@ -0,0 +1,51 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Who do I put here??? |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
import struct |
|||
from typing import TYPE_CHECKING |
|||
|
|||
if TYPE_CHECKING: |
|||
from .voice_client import VoiceClient |
|||
|
|||
unpacker = struct.Struct('>xxHII') |
|||
|
|||
|
|||
class SSRC: |
|||
def __init__(self, ssrc: int, speaking: bool) -> None: |
|||
self._ssrc = ssrc |
|||
self.speaking = speaking |
|||
|
|||
def __repr__(self) -> str: |
|||
return str(self._ssrc) |
|||
|
|||
|
|||
class VoicePacket: # IN-PROGRESS |
|||
def __init__(self, client: VoiceClient, data: bytes): |
|||
self.client = client |
|||
_data = bytearray(data) |
|||
|
|||
self.data: bytearray = data[12:] |
|||
self.header: bytearray = data[:12] |
|||
@ -0,0 +1,119 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import Optional, TYPE_CHECKING |
|||
|
|||
from .enums import RelationshipAction, RelationshipType, try_enum |
|||
|
|||
if TYPE_CHECKING: |
|||
from .state import ConnectionState |
|||
from .user import User |
|||
|
|||
# fmt: off |
|||
__all__ = ( |
|||
'Relationship', |
|||
) |
|||
# fmt: on |
|||
|
|||
|
|||
class Relationship: |
|||
"""Represents a relationship in Discord. |
|||
|
|||
A relationship is like a friendship, a person who is blocked, etc. |
|||
|
|||
Attributes |
|||
----------- |
|||
nickname: :class:`str` |
|||
The user's friend nickname (if applicable). |
|||
user: :class:`User` |
|||
The user you have the relationship with. |
|||
type: :class:`RelationshipType` |
|||
The type of relationship you have. |
|||
""" |
|||
|
|||
__slots__ = ('nickname', 'type', 'user', '_state') |
|||
|
|||
def __init__(self, *, state: ConnectionState, data) -> None: # TODO: type data |
|||
self._state = state |
|||
self.type: RelationshipType = try_enum(RelationshipType, data['type']) |
|||
self.user: User = state.store_user(data['user']) |
|||
self.nickname: Optional[str] = data.get('nickname', None) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<Relationship user={self.user!r} type={self.type!r}>' |
|||
|
|||
async def delete(self) -> None: |
|||
"""|coro| |
|||
|
|||
Deletes the relationship. |
|||
|
|||
Raises |
|||
------ |
|||
HTTPException |
|||
Deleting the relationship failed. |
|||
""" |
|||
if self.type is RelationshipType.friend: |
|||
await self._state.http.remove_relationship(self.user.id, action=RelationshipAction.unfriend) |
|||
elif self.type is RelationshipType.blocked: |
|||
await self._state.http.remove_relationship(self.user.id, action=RelationshipAction.unblock) |
|||
elif self.type is RelationshipType.incoming_request: |
|||
await self._state.http.remove_relationship(self.user.id, action=RelationshipAction.deny_request) |
|||
elif self.type is RelationshipType.outgoing_request: |
|||
await self._state.http.remove_relationship(self.user.id, action=RelationshipAction.remove_pending_request) |
|||
|
|||
async def accept(self) -> None: |
|||
"""|coro| |
|||
|
|||
Accepts the relationship request. Only applicable for |
|||
type :class:`RelationshipType.incoming_request`. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Accepting the relationship failed. |
|||
""" |
|||
await self._state.http.add_relationship(self.user.id, action=RelationshipAction.accept_request) |
|||
|
|||
async def change_nickname(self, nick: Optional[str]) -> None: |
|||
"""|coro| |
|||
|
|||
Changes a relationship's nickname. Only applicable for |
|||
type :class:`RelationshipType.friend`. |
|||
|
|||
Parameters |
|||
---------- |
|||
nick: Optional[:class:`str`] |
|||
The nickname to change to. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Changing the nickname failed. |
|||
|
|||
.. versionadded:: 1.9 |
|||
""" |
|||
await self._state.http.change_friend_nickname(self.user.id, nick) |
|||
self.nickname = nick |
|||
@ -0,0 +1,586 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2021-present Dolfies |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from datetime import datetime, timedelta |
|||
from typing import Any, Dict, List, Optional, TYPE_CHECKING |
|||
|
|||
from .activity import create_settings_activity |
|||
from .enums import FriendFlags, Locale, NotificationLevel, Status, StickerAnimationOptions, Theme, UserContentFilter, try_enum |
|||
from .guild_folder import GuildFolder |
|||
from .utils import MISSING, parse_time, utcnow |
|||
|
|||
if TYPE_CHECKING: |
|||
from .abc import GuildChannel |
|||
from .activity import CustomActivity |
|||
from .guild import Guild |
|||
from .state import ConnectionState |
|||
from .tracking import Tracking |
|||
|
|||
__all__ = ( |
|||
'ChannelSettings', |
|||
'GuildSettings', |
|||
'UserSettings', |
|||
) |
|||
|
|||
|
|||
class UserSettings: |
|||
"""Represents the Discord client settings. |
|||
|
|||
Attributes |
|||
---------- |
|||
afk_timeout: :class:`int` |
|||
How long (in seconds) the user needs to be AFK until Discord |
|||
sends push notifications to your mobile device. |
|||
allow_accessibility_detection: :class:`bool` |
|||
Whether or not to allow Discord to track screen reader usage. |
|||
animate_emojis: :class:`bool` |
|||
Whether or not to animate emojis in the chat. |
|||
contact_sync_enabled: :class:`bool` |
|||
Whether or not to enable the contact sync on Discord mobile. |
|||
convert_emoticons: :class:`bool` |
|||
Whether or not to automatically convert emoticons into emojis. |
|||
e.g. :-) -> 😃 |
|||
default_guilds_restricted: :class:`bool` |
|||
Whether or not to automatically disable DMs between you and |
|||
members of new guilds you join. |
|||
detect_platform_accounts: :class:`bool` |
|||
Whether or not to automatically detect accounts from services |
|||
like Steam and Blizzard when you open the Discord client. |
|||
developer_mode: :class:`bool` |
|||
Whether or not to enable developer mode. |
|||
disable_games_tab: :class:`bool` |
|||
Whether or not to disable the showing of the Games tab. |
|||
enable_tts_command: :class:`bool` |
|||
Whether or not to allow tts messages to be played/sent. |
|||
gif_auto_play: :class:`bool` |
|||
Whether or not to automatically play gifs that are in the chat. |
|||
inline_attachment_media: :class:`bool` |
|||
Whether or not to display attachments when they are uploaded in chat. |
|||
inline_embed_media: :class:`bool` |
|||
Whether or not to display videos and images from links posted in chat. |
|||
message_display_compact: :class:`bool` |
|||
Whether or not to use the compact Discord display mode. |
|||
native_phone_integration_enabled: :class:`bool` |
|||
Whether or not to enable the new Discord mobile phone number friend |
|||
requesting features. |
|||
render_embeds: :class:`bool` |
|||
Whether or not to render embeds that are sent in the chat. |
|||
render_reactions: :class:`bool` |
|||
Whether or not to render reactions that are added to messages. |
|||
show_current_game: :class:`bool` |
|||
Whether or not to display the game that you are currently playing. |
|||
stream_notifications_enabled: :class:`bool` |
|||
Unknown. |
|||
timezone_offset: :class:`int` |
|||
The timezone offset to use. |
|||
view_nsfw_guilds: :class:`bool` |
|||
Whether or not to show NSFW guilds on iOS. |
|||
""" |
|||
|
|||
if TYPE_CHECKING: # Fuck me |
|||
afk_timeout: int |
|||
allow_accessibility_detection: bool |
|||
animate_emojis: bool |
|||
contact_sync_enabled: bool |
|||
convert_emoticons: bool |
|||
default_guilds_restricted: bool |
|||
detect_platform_accounts: bool |
|||
developer_mode: bool |
|||
disable_games_tab: bool |
|||
enable_tts_command: bool |
|||
gif_auto_play: bool |
|||
inline_attachment_media: bool |
|||
inline_embed_media: bool |
|||
message_display_compact: bool |
|||
native_phone_integration_enabled: bool |
|||
render_embeds: bool |
|||
render_reactions: bool |
|||
show_current_game: bool |
|||
stream_notifications_enabled: bool |
|||
timezone_offset: int |
|||
view_nsfw_guilds: bool |
|||
|
|||
def __init__(self, *, data, state: ConnectionState) -> None: |
|||
self._state = state |
|||
self._update(data) |
|||
|
|||
def __repr__(self) -> str: |
|||
return '<Settings>' |
|||
|
|||
def _get_guild(self, id: int) -> Optional[Guild]: |
|||
return self._state._get_guild(int(id)) |
|||
|
|||
def _update(self, data: Dict[str, Any]) -> None: |
|||
RAW_VALUES = { |
|||
'afk_timeout', |
|||
'allow_accessibility_detection', |
|||
'animate_emojis', |
|||
'contact_sync_enabled', |
|||
'convert_emoticons', |
|||
'default_guilds_restricted', |
|||
'detect_platform_accounts', |
|||
'developer_mode', |
|||
'disable_games_tab', |
|||
'enable_tts_command', |
|||
'gif_auto_play', |
|||
'inline_attachment_media', |
|||
'inline_embed_media', |
|||
'message_display_compact', |
|||
'native_phone_integration_enabled', |
|||
'render_embeds', |
|||
'render_reactions', |
|||
'show_current_game', |
|||
'stream_notifications_enabled', |
|||
'timezone_offset', |
|||
'view_nsfw_guilds', |
|||
} |
|||
|
|||
for key, value in data.items(): |
|||
if key in RAW_VALUES: |
|||
setattr(self, key, value) |
|||
else: |
|||
setattr(self, '_' + key, value) |
|||
|
|||
async def edit(self, **kwargs) -> UserSettings: |
|||
"""|coro| |
|||
|
|||
Edits the client user's settings. |
|||
|
|||
.. versionchanged:: 2.0 |
|||
The edit is no longer in-place, instead the newly edited settings are returned. |
|||
|
|||
Parameters |
|||
---------- |
|||
afk_timeout: :class:`int` |
|||
How long (in seconds) the user needs to be AFK until Discord |
|||
sends push notifications to your mobile device. |
|||
allow_accessibility_detection: :class:`bool` |
|||
Whether or not to allow Discord to track screen reader usage. |
|||
animate_emojis: :class:`bool` |
|||
Whether or not to animate emojis in the chat. |
|||
animate_stickers: :class:`StickerAnimationOptions` |
|||
Whether or not to animate stickers in the chat. |
|||
contact_sync_enabled: :class:`bool` |
|||
Whether or not to enable the contact sync on Discord mobile. |
|||
convert_emoticons: :class:`bool` |
|||
Whether or not to automatically convert emoticons into emojis. |
|||
e.g. :-) -> 😃 |
|||
default_guilds_restricted: :class:`bool` |
|||
Whether or not to automatically disable DMs between you and |
|||
members of new guilds you join. |
|||
detect_platform_accounts: :class:`bool` |
|||
Whether or not to automatically detect accounts from services |
|||
like Steam and Blizzard when you open the Discord client. |
|||
developer_mode: :class:`bool` |
|||
Whether or not to enable developer mode. |
|||
disable_games_tab: :class:`bool` |
|||
Whether or not to disable the showing of the Games tab. |
|||
enable_tts_command: :class:`bool` |
|||
Whether or not to allow tts messages to be played/sent. |
|||
explicit_content_filter: :class:`UserContentFilter` |
|||
The filter for explicit content in all messages. |
|||
friend_source_flags: :class:`FriendFlags` |
|||
Who can add you as a friend. |
|||
gif_auto_play: :class:`bool` |
|||
Whether or not to automatically play gifs that are in the chat. |
|||
guild_positions: List[:class:`abc.Snowflake`] |
|||
A list of guilds in order of the guild/guild icons that are on |
|||
the left hand side of the UI. |
|||
inline_attachment_media: :class:`bool` |
|||
Whether or not to display attachments when they are uploaded in chat. |
|||
inline_embed_media: :class:`bool` |
|||
Whether or not to display videos and images from links posted in chat. |
|||
locale: :class:`Locale` |
|||
The :rfc:`3066` language identifier of the locale to use for the language |
|||
of the Discord client. |
|||
message_display_compact: :class:`bool` |
|||
Whether or not to use the compact Discord display mode. |
|||
native_phone_integration_enabled: :class:`bool` |
|||
Whether or not to enable the new Discord mobile phone number friend |
|||
requesting features. |
|||
render_embeds: :class:`bool` |
|||
Whether or not to render embeds that are sent in the chat. |
|||
render_reactions: :class:`bool` |
|||
Whether or not to render reactions that are added to messages. |
|||
restricted_guilds: List[:class:`abc.Snowflake`] |
|||
A list of guilds that you will not receive DMs from. |
|||
show_current_game: :class:`bool` |
|||
Whether or not to display the game that you are currently playing. |
|||
stream_notifications_enabled: :class:`bool` |
|||
Unknown. |
|||
theme: :class:`Theme` |
|||
The theme of the Discord UI. |
|||
timezone_offset: :class:`int` |
|||
The timezone offset to use. |
|||
view_nsfw_guilds: :class:`bool` |
|||
Whether or not to show NSFW guilds on iOS. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Editing the settings failed. |
|||
|
|||
Returns |
|||
------- |
|||
:class:`.UserSettings` |
|||
The client user's updated settings. |
|||
""" |
|||
return await self._state.user.edit_settings(**kwargs) # type: ignore |
|||
|
|||
async def fetch_tracking(self) -> Tracking: |
|||
"""|coro| |
|||
|
|||
Retrieves your :class:`Tracking` settings. |
|||
|
|||
Raises |
|||
------ |
|||
HTTPException |
|||
Retrieving the tracking settings failed. |
|||
|
|||
Returns |
|||
------- |
|||
:class:`Tracking` |
|||
The tracking settings. |
|||
""" |
|||
data = await self._state.http.get_tracking() |
|||
return Tracking(state=self._state, data=data) |
|||
|
|||
@property |
|||
def tracking(self) -> Optional[Tracking]: |
|||
"""Optional[:class:`Tracking`]: Returns your tracking settings if available.""" |
|||
return self._state.consents |
|||
|
|||
@property |
|||
def animate_stickers(self) -> StickerAnimationOptions: |
|||
""":class:`StickerAnimationOptions`: Whether or not to animate stickers in the chat.""" |
|||
return try_enum(StickerAnimationOptions, getattr(self, '_animate_stickers', 0)) |
|||
|
|||
@property |
|||
def custom_activity(self) -> Optional[CustomActivity]: |
|||
"""Optional[:class:`CustomActivity]: The set custom activity.""" |
|||
return create_settings_activity(data=getattr(self, '_custom_status', None), state=self._state) |
|||
|
|||
@property |
|||
def explicit_content_filter(self) -> UserContentFilter: |
|||
""":class:`UserContentFilter`: The filter for explicit content in all messages.""" |
|||
return try_enum(UserContentFilter, getattr(self, '_explicit_content_filter', 1)) |
|||
|
|||
@property |
|||
def friend_source_flags(self) -> FriendFlags: |
|||
""":class:`FriendFlags`: Who can add you as a friend.""" |
|||
return FriendFlags._from_dict(getattr(self, '_friend_source_flags', {'all': True})) |
|||
|
|||
@property |
|||
def guild_folders(self) -> List[GuildFolder]: |
|||
"""List[:class:`GuildFolder`]: A list of guild folders.""" |
|||
state = self._state |
|||
return [GuildFolder(data=folder, state=state) for folder in getattr(self, '_guild_folders', [])] |
|||
|
|||
@property |
|||
def guild_positions(self) -> List[Guild]: |
|||
"""List[:class:`Guild`]: A list of guilds in order of the guild/guild icons that are on the left hand side of the UI.""" |
|||
return list(filter(None, map(self._get_guild, getattr(self, '_guild_positions', [])))) |
|||
|
|||
@property |
|||
def locale(self) -> Locale: |
|||
""":class:`Locale`: The :rfc:`3066` language identifier |
|||
of the locale to use for the language of the Discord client.""" |
|||
return try_enum(Locale, getattr(self, '_locale', 'en-US')) |
|||
|
|||
@property |
|||
def passwordless(self) -> bool: |
|||
""":class:`bool`: Whether the account is passwordless.""" |
|||
return getattr(self, '_passwordless', False) |
|||
|
|||
@property |
|||
def restricted_guilds(self) -> List[Guild]: |
|||
"""List[:class:`Guild`]: A list of guilds that you will not receive DMs from.""" |
|||
return list(filter(None, map(self._get_guild, getattr(self, '_restricted_guilds', [])))) |
|||
|
|||
@property |
|||
def status(self) -> Status: |
|||
"""Optional[:class:`Status`]: The configured status.""" |
|||
return try_enum(Status, getattr(self, '_status', 'online')) |
|||
|
|||
@property |
|||
def theme(self) -> Theme: |
|||
""":class:`Theme`: The theme of the Discord UI.""" |
|||
return try_enum(Theme, getattr(self, '_theme', 'dark')) # Sane default :) |
|||
|
|||
|
|||
class MuteConfig: |
|||
def __init__(self, muted: bool, config: Dict[str, str]) -> None: |
|||
until = parse_time(config.get('end_time')) |
|||
if until is not None: |
|||
if until <= utcnow(): |
|||
muted = False |
|||
until = None |
|||
|
|||
self.muted: bool = muted |
|||
self.until: Optional[datetime] = until |
|||
|
|||
for item in {'__bool__', '__eq__', '__float__', '__int__', '__str__'}: |
|||
setattr(self, item, getattr(muted, item)) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<MuteConfig muted={self.muted} until={self.until}>' |
|||
|
|||
def __bool__(self) -> bool: |
|||
return bool(self.muted) |
|||
|
|||
def __eq__(self, other) -> bool: |
|||
return self.muted == other |
|||
|
|||
def __ne__(self, other) -> bool: |
|||
return not self.muted == other |
|||
|
|||
|
|||
class ChannelSettings: |
|||
"""Represents a channel's notification settings""" |
|||
|
|||
if TYPE_CHECKING: |
|||
_channel_id: int |
|||
level: NotificationLevel |
|||
muted: MuteConfig |
|||
collapsed: bool |
|||
|
|||
def __init__(self, guild_id, *, data: Dict[str, Any] = {}, state: ConnectionState) -> None: |
|||
self._guild_id: int = guild_id |
|||
self._state = state |
|||
self._update(data) |
|||
|
|||
def _update(self, data: Dict[str, Any]) -> None: |
|||
self._channel_id = int(data['channel_id']) |
|||
self.collapsed = data.get('collapsed', False) |
|||
|
|||
self.level = try_enum(NotificationLevel, data.get('message_notifications', 3)) # type: ignore |
|||
self.muted = MuteConfig(data.get('muted', False), data.get('mute_config') or {}) |
|||
|
|||
@property |
|||
def channel(self) -> Optional[GuildChannel]: |
|||
"""Optional[:class:`GuildChannel`]: Returns the channel these settings are for.""" |
|||
guild = self._state._get_guild(self._guild_id) |
|||
return guild and guild.get_channel(self._channel_id) |
|||
|
|||
async def edit(self, |
|||
*, |
|||
muted: bool = MISSING, |
|||
duration: Optional[int] = MISSING, |
|||
collapsed: bool = MISSING, |
|||
level: NotificationLevel = MISSING, |
|||
) -> Optional[ChannelSettings]: |
|||
"""|coro| |
|||
|
|||
Edits the channel's notification settings. |
|||
|
|||
All parameters are optional. |
|||
|
|||
Parameters |
|||
----------- |
|||
muted: :class:`bool` |
|||
Indicates if the channel should be muted or not. |
|||
duration: Optional[Union[:class:`int`, :class:`float`]] |
|||
The amount of time in hours that the channel should be muted for. |
|||
Defaults to indefinite. |
|||
collapsed: :class:`bool` |
|||
Unknown. |
|||
level: :class:`NotificationLevel` |
|||
Determines what level of notifications you receive for the channel. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Editing the settings failed. |
|||
|
|||
Returns |
|||
-------- |
|||
:class:`ChannelSettings` |
|||
The new notification settings. |
|||
""" |
|||
payload = {} |
|||
data = None |
|||
|
|||
if muted is not MISSING: |
|||
payload['muted'] = muted |
|||
|
|||
if duration is not MISSING: |
|||
if muted is MISSING: |
|||
payload['muted'] = True |
|||
|
|||
if duration is not None: |
|||
mute_config = { |
|||
'selected_time_window': duration * 3600, |
|||
'end_time': (datetime.utcnow() + timedelta(hours=duration)).isoformat() |
|||
} |
|||
payload['mute_config'] = mute_config |
|||
|
|||
if collapsed is not MISSING: |
|||
payload['collapsed'] = collapsed |
|||
|
|||
if level is not MISSING: |
|||
payload['message_notifications'] = level.value |
|||
|
|||
if payload: |
|||
fields = {'channel_overrides': {str(self._channel_id): payload}} |
|||
data = await self._state.http.edit_guild_settings(self._guild_id, fields) |
|||
|
|||
if data: |
|||
return ChannelSettings( |
|||
self._guild_id, |
|||
data=data['channel_overrides'][str(self._channel_id)], |
|||
state=self._state |
|||
) |
|||
else: |
|||
return self |
|||
|
|||
|
|||
class GuildSettings: |
|||
"""Represents a guild's notification settings.""" |
|||
|
|||
if TYPE_CHECKING: |
|||
_channel_overrides: Dict[int, ChannelSettings] |
|||
_guild_id: int |
|||
version: int |
|||
muted: MuteConfig |
|||
suppress_everyone: bool |
|||
suppress_roles: bool |
|||
hide_muted_channels: bool |
|||
mobile_push_notifications: bool |
|||
level: NotificationLevel |
|||
|
|||
def __init__(self, *, data: Dict[str, Any], state: ConnectionState) -> None: |
|||
self._state = state |
|||
self._update(data) |
|||
|
|||
def _update(self, data: Dict[str, Any]) -> None: |
|||
self._guild_id = guild_id = int(data['guild_id']) |
|||
self.version = data.get('version', -1) # Overriden by real data |
|||
self.suppress_everyone = data.get('suppress_everyone', False) |
|||
self.suppress_roles = data.get('suppress_roles', False) |
|||
self.hide_muted_channels = data.get('hide_muted_channels', False) |
|||
self.mobile_push_notifications = data.get('mobile_push', True) |
|||
|
|||
self.level = try_enum(NotificationLevel, data.get('message_notifications', 3)) |
|||
self.muted = MuteConfig(data.get('muted', False), data.get('mute_config') or {}) |
|||
self._channel_overrides = overrides = {} |
|||
state = self._state |
|||
for override in data.get('channel_overrides', []): |
|||
channel_id = int(override['channel_id']) |
|||
overrides[channel_id] = ChannelSettings(guild_id, data=override, state=state) |
|||
|
|||
@property |
|||
def guild(self) -> Optional[Guild]: |
|||
"""Optional[:class:`Guild`]: Returns the guild that these settings are for.""" |
|||
return self._state._get_guild(self._guild_id) |
|||
|
|||
@property |
|||
def channel_overrides(self) -> List[ChannelSettings]: |
|||
"""List[:class:`ChannelSettings`: Returns a list of all the overrided channel notification settings.""" |
|||
return list(self._channel_overrides.values()) |
|||
|
|||
async def edit( |
|||
self, |
|||
muted: bool = MISSING, |
|||
duration: Optional[int] = MISSING, |
|||
level: NotificationLevel = MISSING, |
|||
suppress_everyone: bool = MISSING, |
|||
suppress_roles: bool = MISSING, |
|||
mobile_push_notifications: bool = MISSING, |
|||
hide_muted_channels: bool = MISSING, |
|||
) -> Optional[GuildSettings]: |
|||
"""|coro| |
|||
|
|||
Edits the guild's notification settings. |
|||
|
|||
All parameters are optional. |
|||
|
|||
Parameters |
|||
----------- |
|||
muted: :class:`bool` |
|||
Indicates if the guild should be muted or not. |
|||
duration: Optional[Union[:class:`int`, :class:`float`]] |
|||
The amount of time in hours that the guild should be muted for. |
|||
Defaults to indefinite. |
|||
level: :class:`NotificationLevel` |
|||
Determines what level of notifications you receive for the guild. |
|||
suppress_everyone: :class:`bool` |
|||
Indicates if @everyone mentions should be suppressed for the guild. |
|||
suppress_roles: :class:`bool` |
|||
Indicates if role mentions should be suppressed for the guild. |
|||
mobile_push_notifications: :class:`bool` |
|||
Indicates if push notifications should be sent to mobile devices for this guild. |
|||
hide_muted_channels: :class:`bool` |
|||
Indicates if channels that are muted should be hidden from the sidebar. |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Editing the settings failed. |
|||
|
|||
Returns |
|||
-------- |
|||
:class:`GuildSettings` |
|||
The new notification settings. |
|||
""" |
|||
payload = {} |
|||
data = None |
|||
|
|||
if muted is not MISSING: |
|||
payload['muted'] = muted |
|||
|
|||
if duration is not MISSING: |
|||
if muted is MISSING: |
|||
payload['muted'] = True |
|||
|
|||
if duration is not None: |
|||
mute_config = { |
|||
'selected_time_window': duration * 3600, |
|||
'end_time': (datetime.utcnow() + timedelta(hours=duration)).isoformat() |
|||
} |
|||
payload['mute_config'] = mute_config |
|||
|
|||
if level is not MISSING: |
|||
payload['message_notifications'] = level.value |
|||
|
|||
if suppress_everyone is not MISSING: |
|||
payload['suppress_everyone'] = suppress_everyone |
|||
|
|||
if suppress_roles is not MISSING: |
|||
payload['suppress_roles'] = suppress_roles |
|||
|
|||
if mobile_push_notifications is not MISSING: |
|||
payload['mobile_push'] = mobile_push_notifications |
|||
|
|||
if hide_muted_channels is not MISSING: |
|||
payload['hide_muted_channels'] = hide_muted_channels |
|||
|
|||
if payload: |
|||
data = await self._state.http.edit_guild_settings(self._guild_id, payload) |
|||
|
|||
if data: |
|||
return GuildSettings(data=data, state=self._state) |
|||
else: |
|||
return self |
|||
@ -1,559 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
import asyncio |
|||
import logging |
|||
|
|||
import aiohttp |
|||
|
|||
from .state import AutoShardedConnectionState |
|||
from .client import Client |
|||
from .backoff import ExponentialBackoff |
|||
from .gateway import * |
|||
from .errors import ( |
|||
ClientException, |
|||
HTTPException, |
|||
GatewayNotFound, |
|||
ConnectionClosed, |
|||
PrivilegedIntentsRequired, |
|||
) |
|||
|
|||
from .enums import Status |
|||
|
|||
from typing import TYPE_CHECKING, Any, Callable, Tuple, Type, Optional, List, Dict |
|||
|
|||
if TYPE_CHECKING: |
|||
from .gateway import DiscordWebSocket |
|||
from .activity import BaseActivity |
|||
from .enums import Status |
|||
|
|||
__all__ = ( |
|||
'AutoShardedClient', |
|||
'ShardInfo', |
|||
) |
|||
|
|||
_log = logging.getLogger(__name__) |
|||
|
|||
|
|||
class EventType: |
|||
close = 0 |
|||
reconnect = 1 |
|||
resume = 2 |
|||
identify = 3 |
|||
terminate = 4 |
|||
clean_close = 5 |
|||
|
|||
|
|||
class EventItem: |
|||
__slots__ = ('type', 'shard', 'error') |
|||
|
|||
def __init__(self, etype: int, shard: Optional['Shard'], error: Optional[Exception]) -> None: |
|||
self.type: int = etype |
|||
self.shard: Optional['Shard'] = shard |
|||
self.error: Optional[Exception] = error |
|||
|
|||
def __lt__(self, other: Any) -> bool: |
|||
if not isinstance(other, EventItem): |
|||
return NotImplemented |
|||
return self.type < other.type |
|||
|
|||
def __eq__(self, other: Any) -> bool: |
|||
if not isinstance(other, EventItem): |
|||
return NotImplemented |
|||
return self.type == other.type |
|||
|
|||
def __hash__(self) -> int: |
|||
return hash(self.type) |
|||
|
|||
|
|||
class Shard: |
|||
def __init__(self, ws: DiscordWebSocket, client: AutoShardedClient, queue_put: Callable[[EventItem], None]) -> None: |
|||
self.ws: DiscordWebSocket = ws |
|||
self._client: Client = client |
|||
self._dispatch: Callable[..., None] = client.dispatch |
|||
self._queue_put: Callable[[EventItem], None] = queue_put |
|||
self.loop: asyncio.AbstractEventLoop = self._client.loop |
|||
self._disconnect: bool = False |
|||
self._reconnect = client._reconnect |
|||
self._backoff: ExponentialBackoff = ExponentialBackoff() |
|||
self._task: Optional[asyncio.Task] = None |
|||
self._handled_exceptions: Tuple[Type[Exception], ...] = ( |
|||
OSError, |
|||
HTTPException, |
|||
GatewayNotFound, |
|||
ConnectionClosed, |
|||
aiohttp.ClientError, |
|||
asyncio.TimeoutError, |
|||
) |
|||
|
|||
@property |
|||
def id(self) -> int: |
|||
# DiscordWebSocket.shard_id is set in the from_client classmethod |
|||
return self.ws.shard_id # type: ignore |
|||
|
|||
def launch(self) -> None: |
|||
self._task = self.loop.create_task(self.worker()) |
|||
|
|||
def _cancel_task(self) -> None: |
|||
if self._task is not None and not self._task.done(): |
|||
self._task.cancel() |
|||
|
|||
async def close(self) -> None: |
|||
self._cancel_task() |
|||
await self.ws.close(code=1000) |
|||
|
|||
async def disconnect(self) -> None: |
|||
await self.close() |
|||
self._dispatch('shard_disconnect', self.id) |
|||
|
|||
async def _handle_disconnect(self, e: Exception) -> None: |
|||
self._dispatch('disconnect') |
|||
self._dispatch('shard_disconnect', self.id) |
|||
if not self._reconnect: |
|||
self._queue_put(EventItem(EventType.close, self, e)) |
|||
return |
|||
|
|||
if self._client.is_closed(): |
|||
return |
|||
|
|||
if isinstance(e, OSError) and e.errno in (54, 10054): |
|||
# If we get Connection reset by peer then always try to RESUME the connection. |
|||
exc = ReconnectWebSocket(self.id, resume=True) |
|||
self._queue_put(EventItem(EventType.resume, self, exc)) |
|||
return |
|||
|
|||
if isinstance(e, ConnectionClosed): |
|||
if e.code == 4014: |
|||
self._queue_put(EventItem(EventType.terminate, self, PrivilegedIntentsRequired(self.id))) |
|||
return |
|||
if e.code != 1000: |
|||
self._queue_put(EventItem(EventType.close, self, e)) |
|||
return |
|||
|
|||
retry = self._backoff.delay() |
|||
_log.error('Attempting a reconnect for shard ID %s in %.2fs', self.id, retry, exc_info=e) |
|||
await asyncio.sleep(retry) |
|||
self._queue_put(EventItem(EventType.reconnect, self, e)) |
|||
|
|||
async def worker(self) -> None: |
|||
while not self._client.is_closed(): |
|||
try: |
|||
await self.ws.poll_event() |
|||
except ReconnectWebSocket as e: |
|||
etype = EventType.resume if e.resume else EventType.identify |
|||
self._queue_put(EventItem(etype, self, e)) |
|||
break |
|||
except self._handled_exceptions as e: |
|||
await self._handle_disconnect(e) |
|||
break |
|||
except asyncio.CancelledError: |
|||
break |
|||
except Exception as e: |
|||
self._queue_put(EventItem(EventType.terminate, self, e)) |
|||
break |
|||
|
|||
async def reidentify(self, exc: ReconnectWebSocket) -> None: |
|||
self._cancel_task() |
|||
self._dispatch('disconnect') |
|||
self._dispatch('shard_disconnect', self.id) |
|||
_log.info('Got a request to %s the websocket at Shard ID %s.', exc.op, self.id) |
|||
try: |
|||
coro = DiscordWebSocket.from_client( |
|||
self._client, |
|||
resume=exc.resume, |
|||
shard_id=self.id, |
|||
session=self.ws.session_id, |
|||
sequence=self.ws.sequence, |
|||
) |
|||
self.ws = await asyncio.wait_for(coro, timeout=60.0) |
|||
except self._handled_exceptions as e: |
|||
await self._handle_disconnect(e) |
|||
except asyncio.CancelledError: |
|||
return |
|||
except Exception as e: |
|||
self._queue_put(EventItem(EventType.terminate, self, e)) |
|||
else: |
|||
self.launch() |
|||
|
|||
async def reconnect(self) -> None: |
|||
self._cancel_task() |
|||
try: |
|||
coro = DiscordWebSocket.from_client(self._client, shard_id=self.id) |
|||
self.ws = await asyncio.wait_for(coro, timeout=60.0) |
|||
except self._handled_exceptions as e: |
|||
await self._handle_disconnect(e) |
|||
except asyncio.CancelledError: |
|||
return |
|||
except Exception as e: |
|||
self._queue_put(EventItem(EventType.terminate, self, e)) |
|||
else: |
|||
self.launch() |
|||
|
|||
|
|||
class ShardInfo: |
|||
"""A class that gives information and control over a specific shard. |
|||
|
|||
You can retrieve this object via :meth:`AutoShardedClient.get_shard` |
|||
or :attr:`AutoShardedClient.shards`. |
|||
|
|||
.. versionadded:: 1.4 |
|||
|
|||
Attributes |
|||
------------ |
|||
id: :class:`int` |
|||
The shard ID for this shard. |
|||
shard_count: Optional[:class:`int`] |
|||
The shard count for this cluster. If this is ``None`` then the bot has not started yet. |
|||
""" |
|||
|
|||
__slots__ = ('_parent', 'id', 'shard_count') |
|||
|
|||
def __init__(self, parent: Shard, shard_count: Optional[int]) -> None: |
|||
self._parent: Shard = parent |
|||
self.id: int = parent.id |
|||
self.shard_count: Optional[int] = shard_count |
|||
|
|||
def is_closed(self) -> bool: |
|||
""":class:`bool`: Whether the shard connection is currently closed.""" |
|||
return not self._parent.ws.open |
|||
|
|||
async def disconnect(self) -> None: |
|||
"""|coro| |
|||
|
|||
Disconnects a shard. When this is called, the shard connection will no |
|||
longer be open. |
|||
|
|||
If the shard is already disconnected this does nothing. |
|||
""" |
|||
if self.is_closed(): |
|||
return |
|||
|
|||
await self._parent.disconnect() |
|||
|
|||
async def reconnect(self) -> None: |
|||
"""|coro| |
|||
|
|||
Disconnects and then connects the shard again. |
|||
""" |
|||
if not self.is_closed(): |
|||
await self._parent.disconnect() |
|||
await self._parent.reconnect() |
|||
|
|||
async def connect(self) -> None: |
|||
"""|coro| |
|||
|
|||
Connects a shard. If the shard is already connected this does nothing. |
|||
""" |
|||
if not self.is_closed(): |
|||
return |
|||
|
|||
await self._parent.reconnect() |
|||
|
|||
@property |
|||
def latency(self) -> float: |
|||
""":class:`float`: Measures latency between a HEARTBEAT and a HEARTBEAT_ACK in seconds for this shard.""" |
|||
return self._parent.ws.latency |
|||
|
|||
def is_ws_ratelimited(self) -> bool: |
|||
""":class:`bool`: Whether the websocket is currently rate limited. |
|||
|
|||
This can be useful to know when deciding whether you should query members |
|||
using HTTP or via the gateway. |
|||
|
|||
.. versionadded:: 1.6 |
|||
""" |
|||
return self._parent.ws.is_ratelimited() |
|||
|
|||
|
|||
class AutoShardedClient(Client): |
|||
"""A client similar to :class:`Client` except it handles the complications |
|||
of sharding for the user into a more manageable and transparent single |
|||
process bot. |
|||
|
|||
When using this client, you will be able to use it as-if it was a regular |
|||
:class:`Client` with a single shard when implementation wise internally it |
|||
is split up into multiple shards. This allows you to not have to deal with |
|||
IPC or other complicated infrastructure. |
|||
|
|||
It is recommended to use this client only if you have surpassed at least |
|||
1000 guilds. |
|||
|
|||
If no :attr:`.shard_count` is provided, then the library will use the |
|||
Bot Gateway endpoint call to figure out how many shards to use. |
|||
|
|||
If a ``shard_ids`` parameter is given, then those shard IDs will be used |
|||
to launch the internal shards. Note that :attr:`.shard_count` must be provided |
|||
if this is used. By default, when omitted, the client will launch shards from |
|||
0 to ``shard_count - 1``. |
|||
|
|||
Attributes |
|||
------------ |
|||
shard_ids: Optional[List[:class:`int`]] |
|||
An optional list of shard_ids to launch the shards with. |
|||
""" |
|||
|
|||
if TYPE_CHECKING: |
|||
_connection: AutoShardedConnectionState |
|||
|
|||
def __init__(self, *args: Any, loop: Optional[asyncio.AbstractEventLoop] = None, **kwargs: Any) -> None: |
|||
kwargs.pop('shard_id', None) |
|||
self.shard_ids: Optional[List[int]] = kwargs.pop('shard_ids', None) |
|||
super().__init__(*args, loop=loop, **kwargs) |
|||
|
|||
if self.shard_ids is not None: |
|||
if self.shard_count is None: |
|||
raise ClientException('When passing manual shard_ids, you must provide a shard_count.') |
|||
elif not isinstance(self.shard_ids, (list, tuple)): |
|||
raise ClientException('shard_ids parameter must be a list or a tuple.') |
|||
|
|||
# instead of a single websocket, we have multiple |
|||
# the key is the shard_id |
|||
self.__shards = {} |
|||
self._connection._get_websocket = self._get_websocket |
|||
self._connection._get_client = lambda: self |
|||
self.__queue = asyncio.PriorityQueue() |
|||
|
|||
def _get_websocket(self, guild_id: Optional[int] = None, *, shard_id: Optional[int] = None) -> DiscordWebSocket: |
|||
if shard_id is None: |
|||
# guild_id won't be None if shard_id is None and shard_count won't be None here |
|||
shard_id = (guild_id >> 22) % self.shard_count # type: ignore |
|||
return self.__shards[shard_id].ws |
|||
|
|||
def _get_state(self, **options: Any) -> AutoShardedConnectionState: |
|||
return AutoShardedConnectionState( |
|||
dispatch=self.dispatch, |
|||
handlers=self._handlers, |
|||
hooks=self._hooks, |
|||
http=self.http, |
|||
loop=self.loop, |
|||
**options, |
|||
) |
|||
|
|||
@property |
|||
def latency(self) -> float: |
|||
""":class:`float`: Measures latency between a HEARTBEAT and a HEARTBEAT_ACK in seconds. |
|||
|
|||
This operates similarly to :meth:`Client.latency` except it uses the average |
|||
latency of every shard's latency. To get a list of shard latency, check the |
|||
:attr:`latencies` property. Returns ``nan`` if there are no shards ready. |
|||
""" |
|||
if not self.__shards: |
|||
return float('nan') |
|||
return sum(latency for _, latency in self.latencies) / len(self.__shards) |
|||
|
|||
@property |
|||
def latencies(self) -> List[Tuple[int, float]]: |
|||
"""List[Tuple[:class:`int`, :class:`float`]]: A list of latencies between a HEARTBEAT and a HEARTBEAT_ACK in seconds. |
|||
|
|||
This returns a list of tuples with elements ``(shard_id, latency)``. |
|||
""" |
|||
return [(shard_id, shard.ws.latency) for shard_id, shard in self.__shards.items()] |
|||
|
|||
def get_shard(self, shard_id: int, /) -> Optional[ShardInfo]: |
|||
""" |
|||
Gets the shard information at a given shard ID or ``None`` if not found. |
|||
|
|||
.. versionchanged:: 2.0 |
|||
|
|||
``shard_id`` parameter is now positional-only. |
|||
|
|||
Returns |
|||
-------- |
|||
Optional[:class:`ShardInfo`] |
|||
Information about the shard with given ID. ``None`` if not found. |
|||
""" |
|||
try: |
|||
parent = self.__shards[shard_id] |
|||
except KeyError: |
|||
return None |
|||
else: |
|||
return ShardInfo(parent, self.shard_count) |
|||
|
|||
@property |
|||
def shards(self) -> Dict[int, ShardInfo]: |
|||
"""Mapping[int, :class:`ShardInfo`]: Returns a mapping of shard IDs to their respective info object.""" |
|||
return {shard_id: ShardInfo(parent, self.shard_count) for shard_id, parent in self.__shards.items()} |
|||
|
|||
async def launch_shard(self, gateway: str, shard_id: int, *, initial: bool = False) -> None: |
|||
try: |
|||
coro = DiscordWebSocket.from_client(self, initial=initial, gateway=gateway, shard_id=shard_id) |
|||
ws = await asyncio.wait_for(coro, timeout=180.0) |
|||
except Exception: |
|||
_log.exception('Failed to connect for shard_id: %s. Retrying...', shard_id) |
|||
await asyncio.sleep(5.0) |
|||
return await self.launch_shard(gateway, shard_id) |
|||
|
|||
# keep reading the shard while others connect |
|||
self.__shards[shard_id] = ret = Shard(ws, self, self.__queue.put_nowait) |
|||
ret.launch() |
|||
|
|||
async def launch_shards(self) -> None: |
|||
if self.shard_count is None: |
|||
self.shard_count, gateway = await self.http.get_bot_gateway() |
|||
else: |
|||
gateway = await self.http.get_gateway() |
|||
|
|||
self._connection.shard_count = self.shard_count |
|||
|
|||
shard_ids = self.shard_ids or range(self.shard_count) |
|||
self._connection.shard_ids = shard_ids |
|||
|
|||
for shard_id in shard_ids: |
|||
initial = shard_id == shard_ids[0] |
|||
await self.launch_shard(gateway, shard_id, initial=initial) |
|||
|
|||
self._connection.shards_launched.set() |
|||
|
|||
async def connect(self, *, reconnect: bool = True) -> None: |
|||
self._reconnect = reconnect |
|||
await self.launch_shards() |
|||
|
|||
while not self.is_closed(): |
|||
item = await self.__queue.get() |
|||
if item.type == EventType.close: |
|||
await self.close() |
|||
if isinstance(item.error, ConnectionClosed): |
|||
if item.error.code != 1000: |
|||
raise item.error |
|||
if item.error.code == 4014: |
|||
raise PrivilegedIntentsRequired(item.shard.id) from None |
|||
return |
|||
elif item.type in (EventType.identify, EventType.resume): |
|||
await item.shard.reidentify(item.error) |
|||
elif item.type == EventType.reconnect: |
|||
await item.shard.reconnect() |
|||
elif item.type == EventType.terminate: |
|||
await self.close() |
|||
raise item.error |
|||
elif item.type == EventType.clean_close: |
|||
return |
|||
|
|||
async def close(self) -> None: |
|||
"""|coro| |
|||
|
|||
Closes the connection to Discord. |
|||
""" |
|||
if self.is_closed(): |
|||
return |
|||
|
|||
self._closed = True |
|||
|
|||
for vc in self.voice_clients: |
|||
try: |
|||
await vc.disconnect(force=True) |
|||
except Exception: |
|||
pass |
|||
|
|||
to_close = [asyncio.ensure_future(shard.close(), loop=self.loop) for shard in self.__shards.values()] |
|||
if to_close: |
|||
await asyncio.wait(to_close) |
|||
|
|||
await self.http.close() |
|||
self.__queue.put_nowait(EventItem(EventType.clean_close, None, None)) |
|||
|
|||
async def change_presence( |
|||
self, |
|||
*, |
|||
activity: Optional[BaseActivity] = None, |
|||
status: Optional[Status] = None, |
|||
shard_id: Optional[int] = None, |
|||
) -> None: |
|||
"""|coro| |
|||
|
|||
Changes the client's presence. |
|||
|
|||
Example: :: |
|||
|
|||
game = discord.Game("with the API") |
|||
await client.change_presence(status=discord.Status.idle, activity=game) |
|||
|
|||
.. versionchanged:: 2.0 |
|||
Removed the ``afk`` keyword-only parameter. |
|||
|
|||
.. versionchanged:: 2.0 |
|||
This function no-longer raises ``InvalidArgument`` instead raising |
|||
:exc:`TypeError`. |
|||
|
|||
Parameters |
|||
---------- |
|||
activity: Optional[:class:`BaseActivity`] |
|||
The activity being done. ``None`` if no currently active activity is done. |
|||
status: Optional[:class:`Status`] |
|||
Indicates what status to change to. If ``None``, then |
|||
:attr:`Status.online` is used. |
|||
shard_id: Optional[:class:`int`] |
|||
The shard_id to change the presence to. If not specified |
|||
or ``None``, then it will change the presence of every |
|||
shard the bot can see. |
|||
|
|||
Raises |
|||
------ |
|||
TypeError |
|||
If the ``activity`` parameter is not of proper type. |
|||
""" |
|||
|
|||
if status is None: |
|||
status_value = 'online' |
|||
status_enum = Status.online |
|||
elif status is Status.offline: |
|||
status_value = 'invisible' |
|||
status_enum = Status.offline |
|||
else: |
|||
status_enum = status |
|||
status_value = str(status) |
|||
|
|||
if shard_id is None: |
|||
for shard in self.__shards.values(): |
|||
await shard.ws.change_presence(activity=activity, status=status_value) |
|||
|
|||
guilds = self._connection.guilds |
|||
else: |
|||
shard = self.__shards[shard_id] |
|||
await shard.ws.change_presence(activity=activity, status=status_value) |
|||
guilds = [g for g in self._connection.guilds if g.shard_id == shard_id] |
|||
|
|||
activities = () if activity is None else (activity,) |
|||
for guild in guilds: |
|||
me = guild.me |
|||
if me is None: |
|||
continue |
|||
|
|||
# Member.activities is typehinted as Tuple[ActivityType, ...], we may be setting it as Tuple[BaseActivity, ...] |
|||
me.activities = activities # type: ignore |
|||
me.status = status_enum |
|||
|
|||
def is_ws_ratelimited(self) -> bool: |
|||
""":class:`bool`: Whether the websocket is currently rate limited. |
|||
|
|||
This can be useful to know when deciding whether you should query members |
|||
using HTTP or via the gateway. |
|||
|
|||
This implementation checks if any of the shards are rate limited. |
|||
For more granular control, consider :meth:`ShardInfo.is_ws_ratelimited`. |
|||
|
|||
.. versionadded:: 1.6 |
|||
""" |
|||
return any(shard.ws.is_ratelimited() for shard in self.__shards.values()) |
|||
File diff suppressed because it is too large
@ -0,0 +1,327 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2021-present Dolfies |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from base64 import b64encode |
|||
import json |
|||
|
|||
from typing import Any, Dict, overload, Optional, TYPE_CHECKING |
|||
|
|||
from .utils import MISSING |
|||
|
|||
if TYPE_CHECKING: |
|||
from .enums import ChannelType |
|||
from .types.snowflake import Snowflake |
|||
from .state import ConnectionState |
|||
|
|||
__all__ = ( |
|||
'ContextProperties', |
|||
'Tracking', |
|||
) |
|||
|
|||
|
|||
class ContextProperties: # Thank you Discord-S.C.U.M |
|||
"""Represents the Discord X-Context-Properties header. |
|||
|
|||
This header is essential for certain actions (e.g. joining guilds, friend requesting). |
|||
""" |
|||
|
|||
__slots__ = ('_data', 'value') |
|||
|
|||
def __init__(self, data) -> None: |
|||
self._data: Dict[str, Snowflake] = data |
|||
self.value: str = self._encode_data(data) |
|||
|
|||
def _encode_data(self, data) -> str: |
|||
library = { |
|||
'Friends': 'eyJsb2NhdGlvbiI6IkZyaWVuZHMifQ==', |
|||
'ContextMenu': 'eyJsb2NhdGlvbiI6IkNvbnRleHRNZW51In0=', |
|||
'User Profile': 'eyJsb2NhdGlvbiI6IlVzZXIgUHJvZmlsZSJ9', |
|||
'Add Friend': 'eyJsb2NhdGlvbiI6IkFkZCBGcmllbmQifQ==', |
|||
'Guild Header': 'eyJsb2NhdGlvbiI6Ikd1aWxkIEhlYWRlciJ9', |
|||
'Group DM': 'eyJsb2NhdGlvbiI6Ikdyb3VwIERNIn0=', |
|||
'DM Channel': 'eyJsb2NhdGlvbiI6IkRNIENoYW5uZWwifQ==', |
|||
'/app': 'eyJsb2NhdGlvbiI6ICIvYXBwIn0=', |
|||
'Login': 'eyJsb2NhdGlvbiI6IkxvZ2luIn0=', |
|||
'Register': 'eyJsb2NhdGlvbiI6IlJlZ2lzdGVyIn0=', |
|||
'Verify Email': 'eyJsb2NhdGlvbiI6IlZlcmlmeSBFbWFpbCJ9', |
|||
'New Group DM': 'eyJsb2NhdGlvbiI6Ik5ldyBHcm91cCBETSJ9', |
|||
'Add Friends to DM': 'eyJsb2NhdGlvbiI6IkFkZCBGcmllbmRzIHRvIERNIn0=', |
|||
'None': 'e30=' |
|||
} |
|||
|
|||
try: |
|||
return library[data.get('location', 'None')] |
|||
except KeyError: |
|||
return b64encode(json.dumps(data, separators=(',', ':')).encode()).decode('utf-8') |
|||
|
|||
@classmethod |
|||
def _empty(cls) -> ContextProperties: |
|||
return cls({}) |
|||
|
|||
@classmethod |
|||
def _from_friends_page(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'Friends' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_context_menu(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'ContextMenu' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_user_profile(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'User Profile' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_add_friend_page(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'Add Friend' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_guild_header_menu(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'Guild Header' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_group_dm(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'Group DM' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_new_group_dm(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'New Group DM' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_dm_channel(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'DM Channel' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_add_to_dm(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'Add Friends to DM' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_app(cls) -> ContextProperties: |
|||
data = { |
|||
'location': '/app' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_login(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'Login' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_register(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'Register' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_verification(cls) -> ContextProperties: |
|||
data = { |
|||
'location': 'Verify Email' |
|||
} |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_accept_invite_page( |
|||
cls, |
|||
*, |
|||
guild_id: Snowflake = MISSING, |
|||
channel_id: Snowflake = MISSING, |
|||
channel_type: ChannelType = MISSING, |
|||
) -> ContextProperties: |
|||
data: Dict[str, Snowflake] = { |
|||
'location': 'Accept Invite Page', |
|||
} |
|||
if guild_id is not MISSING: |
|||
data['location_guild_id'] = str(guild_id) |
|||
if channel_id is not MISSING: |
|||
data['location_channel_id'] = str(channel_id) |
|||
if channel_type is not MISSING: |
|||
data['location_channel_type'] = int(channel_type) |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_join_guild_popup( |
|||
cls, |
|||
*, |
|||
guild_id: Snowflake = MISSING, |
|||
channel_id: Snowflake = MISSING, |
|||
channel_type: ChannelType = MISSING, |
|||
) -> ContextProperties: |
|||
data: Dict[str, Snowflake] = { |
|||
'location': 'Join Guild', |
|||
} |
|||
if guild_id is not MISSING: |
|||
data['location_guild_id'] = str(guild_id) |
|||
if channel_id is not MISSING: |
|||
data['location_channel_id'] = str(channel_id) |
|||
if channel_type is not MISSING: |
|||
data['location_channel_type'] = int(channel_type) |
|||
return cls(data) |
|||
|
|||
@classmethod |
|||
def _from_invite_embed( |
|||
cls, |
|||
*, |
|||
guild_id: Optional[Snowflake], |
|||
channel_id: Snowflake, |
|||
message_id: Snowflake, |
|||
channel_type: Optional[ChannelType], |
|||
) -> ContextProperties: |
|||
data = { |
|||
'location': 'Invite Button Embed', |
|||
'location_guild_id': str(guild_id) if guild_id else None, |
|||
'location_channel_id': str(channel_id), |
|||
'location_channel_type': int(channel_type) if channel_type else None, |
|||
'location_message_id': str(message_id), |
|||
} |
|||
return cls(data) |
|||
|
|||
@property |
|||
def location(self) -> Optional[str]: |
|||
return self._data.get('location') # type: ignore |
|||
|
|||
@property |
|||
def guild_id(self) -> Optional[int]: |
|||
data = self._data.get('location_guild_id') |
|||
if data is not None: |
|||
return int(data) |
|||
|
|||
@property |
|||
def channel_id(self) -> Optional[int]: |
|||
data = self._data.get('location_channel_id') |
|||
if data is not None: |
|||
return int(data) |
|||
|
|||
@property |
|||
def channel_type(self) -> Optional[int]: |
|||
return self._data.get('location_channel_type') # type: ignore |
|||
|
|||
@property |
|||
def message_id(self) -> Optional[int]: |
|||
data = self._data.get('location_message_id') |
|||
if data is not None: |
|||
return int(data) |
|||
|
|||
def __bool__(self) -> bool: |
|||
return self.value is not None |
|||
|
|||
def __str__(self) -> str: |
|||
return self._data.get('location', 'None') # type: ignore |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<ContextProperties location={self.location}>' |
|||
|
|||
def __eq__(self, other) -> bool: |
|||
return isinstance(other, ContextProperties) and self.value == other.value |
|||
|
|||
def __ne__(self, other) -> bool: |
|||
return not self.__eq__(other) |
|||
|
|||
|
|||
class Tracking: |
|||
"""Represents your Discord tracking settings. |
|||
|
|||
Attributes |
|||
---------- |
|||
personalization: :class:`bool` |
|||
Whether you have consented to your data being used for personalization. |
|||
usage_statistics: :class:`bool` |
|||
Whether you have consented to your data being used for usage statistics. |
|||
""" |
|||
|
|||
__slots__ = ('_state', 'personalization', 'usage_statistics') |
|||
|
|||
def __init__(self, *, data: Dict[str, Dict[str, bool]], state: ConnectionState) -> None: |
|||
self._state = state |
|||
self._update(data) |
|||
|
|||
def __bool__(self) -> bool: |
|||
return any({self.personalization, self.usage_statistics}) |
|||
|
|||
def _update(self, data: Dict[str, Dict[str, bool]]): |
|||
self.personalization = data.get('personalization', {}).get('consented', False) |
|||
self.usage_statistics = data.get('usage_statistics', {}).get('consented', False) |
|||
|
|||
@overload |
|||
async def edit(self) -> None: |
|||
... |
|||
|
|||
@overload |
|||
async def edit( |
|||
self, |
|||
*, |
|||
personalization: bool = ..., |
|||
usage_statistics: bool = ..., |
|||
) -> None: |
|||
... |
|||
|
|||
async def edit(self, **kwargs) -> None: |
|||
"""|coro| |
|||
|
|||
Edits your tracking settings. |
|||
|
|||
Parameters |
|||
---------- |
|||
personalization: :class:`bool` |
|||
Whether you have consented to your data being used for personalization. |
|||
usage_statistics: :class:`bool` |
|||
Whether you have consented to your data being used for usage statistics. |
|||
""" |
|||
payload = { |
|||
'grant': [k for k, v in kwargs.items() if v is True], |
|||
'revoke': [k for k, v in kwargs.items() if v is False], |
|||
} |
|||
data = await self._state.http.edit_tracking(payload) |
|||
self._update(data) |
|||
@ -1,239 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import TYPE_CHECKING, Dict, List, Literal, TypedDict, Union |
|||
|
|||
|
|||
from .channel import ChannelTypeWithoutThread, ThreadMetadata |
|||
from .threads import ThreadType |
|||
from .member import Member |
|||
from .message import Attachment |
|||
from .role import Role |
|||
from .snowflake import Snowflake |
|||
from .user import User |
|||
|
|||
if TYPE_CHECKING: |
|||
from .message import Message |
|||
|
|||
|
|||
InteractionType = Literal[1, 2, 3, 4, 5] |
|||
|
|||
|
|||
class _BasePartialChannel(TypedDict): |
|||
id: Snowflake |
|||
name: str |
|||
permissions: str |
|||
|
|||
|
|||
class PartialChannel(_BasePartialChannel): |
|||
type: ChannelTypeWithoutThread |
|||
|
|||
|
|||
class PartialThread(_BasePartialChannel): |
|||
type: ThreadType |
|||
thread_metadata: ThreadMetadata |
|||
parent_id: Snowflake |
|||
|
|||
|
|||
class ResolvedData(TypedDict, total=False): |
|||
users: Dict[str, User] |
|||
members: Dict[str, Member] |
|||
roles: Dict[str, Role] |
|||
channels: Dict[str, Union[PartialChannel, PartialThread]] |
|||
messages: Dict[str, Message] |
|||
attachments: Dict[str, Attachment] |
|||
|
|||
|
|||
class _BaseApplicationCommandInteractionDataOption(TypedDict): |
|||
name: str |
|||
|
|||
|
|||
class _CommandGroupApplicationCommandInteractionDataOption(_BaseApplicationCommandInteractionDataOption): |
|||
type: Literal[1, 2] |
|||
options: List[ApplicationCommandInteractionDataOption] |
|||
|
|||
|
|||
class _BaseValueApplicationCommandInteractionDataOption(_BaseApplicationCommandInteractionDataOption, total=False): |
|||
focused: bool |
|||
|
|||
|
|||
class _StringValueApplicationCommandInteractionDataOption(_BaseValueApplicationCommandInteractionDataOption): |
|||
type: Literal[3] |
|||
value: str |
|||
|
|||
|
|||
class _IntegerValueApplicationCommandInteractionDataOption(_BaseValueApplicationCommandInteractionDataOption): |
|||
type: Literal[4] |
|||
value: int |
|||
|
|||
|
|||
class _BooleanValueApplicationCommandInteractionDataOption(_BaseValueApplicationCommandInteractionDataOption): |
|||
type: Literal[5] |
|||
value: bool |
|||
|
|||
|
|||
class _SnowflakeValueApplicationCommandInteractionDataOption(_BaseValueApplicationCommandInteractionDataOption): |
|||
type: Literal[6, 7, 8, 9, 11] |
|||
value: Snowflake |
|||
|
|||
|
|||
class _NumberValueApplicationCommandInteractionDataOption(_BaseValueApplicationCommandInteractionDataOption): |
|||
type: Literal[10] |
|||
value: float |
|||
|
|||
|
|||
_ValueApplicationCommandInteractionDataOption = Union[ |
|||
_StringValueApplicationCommandInteractionDataOption, |
|||
_IntegerValueApplicationCommandInteractionDataOption, |
|||
_BooleanValueApplicationCommandInteractionDataOption, |
|||
_SnowflakeValueApplicationCommandInteractionDataOption, |
|||
_NumberValueApplicationCommandInteractionDataOption, |
|||
] |
|||
|
|||
|
|||
ApplicationCommandInteractionDataOption = Union[ |
|||
_CommandGroupApplicationCommandInteractionDataOption, |
|||
_ValueApplicationCommandInteractionDataOption, |
|||
] |
|||
|
|||
|
|||
class _BaseApplicationCommandInteractionDataOptional(TypedDict, total=False): |
|||
resolved: ResolvedData |
|||
|
|||
|
|||
class _BaseApplicationCommandInteractionData(_BaseApplicationCommandInteractionDataOptional): |
|||
id: Snowflake |
|||
name: str |
|||
|
|||
|
|||
class ChatInputApplicationCommandInteractionData(_BaseApplicationCommandInteractionData, total=False): |
|||
type: Literal[1] |
|||
options: List[ApplicationCommandInteractionDataOption] |
|||
|
|||
|
|||
class _BaseNonChatInputApplicationCommandInteractionData(_BaseApplicationCommandInteractionData): |
|||
target_id: Snowflake |
|||
|
|||
|
|||
class UserApplicationCommandInteractionData(_BaseNonChatInputApplicationCommandInteractionData): |
|||
type: Literal[2] |
|||
|
|||
|
|||
class MessageApplicationCommandInteractionData(_BaseNonChatInputApplicationCommandInteractionData): |
|||
type: Literal[3] |
|||
|
|||
|
|||
ApplicationCommandInteractionData = Union[ |
|||
ChatInputApplicationCommandInteractionData, |
|||
UserApplicationCommandInteractionData, |
|||
MessageApplicationCommandInteractionData, |
|||
] |
|||
|
|||
|
|||
class _BaseMessageComponentInteractionData(TypedDict): |
|||
custom_id: str |
|||
|
|||
|
|||
class ButtonMessageComponentInteractionData(_BaseMessageComponentInteractionData): |
|||
type: Literal[2] |
|||
|
|||
|
|||
class SelectMessageComponentInteractionData(_BaseMessageComponentInteractionData): |
|||
component_type: Literal[3] |
|||
values: List[str] |
|||
|
|||
|
|||
MessageComponentInteractionData = Union[ButtonMessageComponentInteractionData, SelectMessageComponentInteractionData] |
|||
|
|||
|
|||
class ModalSubmitTextInputInteractionData(TypedDict): |
|||
type: Literal[4] |
|||
custom_id: str |
|||
value: str |
|||
|
|||
|
|||
ModalSubmitComponentItemInteractionData = ModalSubmitTextInputInteractionData |
|||
|
|||
|
|||
class ModalSubmitActionRowInteractionData(TypedDict): |
|||
type: Literal[1] |
|||
components: List[ModalSubmitComponentItemInteractionData] |
|||
|
|||
|
|||
ModalSubmitComponentInteractionData = Union[ModalSubmitActionRowInteractionData, ModalSubmitComponentItemInteractionData] |
|||
|
|||
|
|||
class ModalSubmitInteractionData(TypedDict): |
|||
custom_id: str |
|||
components: List[ModalSubmitActionRowInteractionData] |
|||
|
|||
|
|||
InteractionData = Union[ |
|||
ApplicationCommandInteractionData, |
|||
MessageComponentInteractionData, |
|||
ModalSubmitInteractionData, |
|||
] |
|||
|
|||
|
|||
class _BaseInteractionOptional(TypedDict, total=False): |
|||
guild_id: Snowflake |
|||
channel_id: Snowflake |
|||
|
|||
|
|||
class _BaseInteraction(_BaseInteractionOptional): |
|||
id: Snowflake |
|||
application_id: Snowflake |
|||
token: str |
|||
version: Literal[1] |
|||
|
|||
|
|||
class PingInteraction(_BaseInteraction): |
|||
type: Literal[1] |
|||
|
|||
|
|||
class ApplicationCommandInteraction(_BaseInteraction): |
|||
type: Literal[2, 4] |
|||
data: ApplicationCommandInteractionData |
|||
|
|||
|
|||
class MessageComponentInteraction(_BaseInteraction): |
|||
type: Literal[3] |
|||
data: MessageComponentInteractionData |
|||
|
|||
|
|||
class ModalSubmitInteraction(_BaseInteraction): |
|||
type: Literal[5] |
|||
data: ModalSubmitInteractionData |
|||
|
|||
|
|||
Interaction = Union[PingInteraction, ApplicationCommandInteraction, MessageComponentInteraction, ModalSubmitInteraction] |
|||
|
|||
|
|||
class MessageInteraction(TypedDict): |
|||
id: Snowflake |
|||
type: InteractionType |
|||
name: str |
|||
user: User |
|||
@ -1,17 +0,0 @@ |
|||
""" |
|||
discord.ui |
|||
~~~~~~~~~~~ |
|||
|
|||
Bot UI Kit helper for the Discord API |
|||
|
|||
:copyright: (c) 2015-present Rapptz |
|||
:license: MIT, see LICENSE for more details. |
|||
|
|||
""" |
|||
|
|||
from .view import * |
|||
from .modal import * |
|||
from .item import * |
|||
from .button import * |
|||
from .select import * |
|||
from .text_input import * |
|||
@ -1,291 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import Callable, Optional, TYPE_CHECKING, Tuple, TypeVar, Union |
|||
import inspect |
|||
import os |
|||
|
|||
|
|||
from .item import Item, ItemCallbackType |
|||
from ..enums import ButtonStyle, ComponentType |
|||
from ..partial_emoji import PartialEmoji, _EmojiTag |
|||
from ..components import Button as ButtonComponent |
|||
|
|||
__all__ = ( |
|||
'Button', |
|||
'button', |
|||
) |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .view import View |
|||
from ..emoji import Emoji |
|||
|
|||
V = TypeVar('V', bound='View', covariant=True) |
|||
|
|||
|
|||
class Button(Item[V]): |
|||
"""Represents a UI button. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Parameters |
|||
------------ |
|||
style: :class:`discord.ButtonStyle` |
|||
The style of the button. |
|||
custom_id: Optional[:class:`str`] |
|||
The ID of the button that gets received during an interaction. |
|||
If this button is for a URL, it does not have a custom ID. |
|||
url: Optional[:class:`str`] |
|||
The URL this button sends you to. |
|||
disabled: :class:`bool` |
|||
Whether the button is disabled or not. |
|||
label: Optional[:class:`str`] |
|||
The label of the button, if any. |
|||
emoji: Optional[Union[:class:`.PartialEmoji`, :class:`.Emoji`, :class:`str`]] |
|||
The emoji of the button, if available. |
|||
row: Optional[:class:`int`] |
|||
The relative row this button belongs to. A Discord component can only have 5 |
|||
rows. By default, items are arranged automatically into those 5 rows. If you'd |
|||
like to control the relative positioning of the row then passing an index is advised. |
|||
For example, row=1 will show up before row=2. Defaults to ``None``, which is automatic |
|||
ordering. The row number must be between 0 and 4 (i.e. zero indexed). |
|||
""" |
|||
|
|||
__item_repr_attributes__: Tuple[str, ...] = ( |
|||
'style', |
|||
'url', |
|||
'disabled', |
|||
'label', |
|||
'emoji', |
|||
'row', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
style: ButtonStyle = ButtonStyle.secondary, |
|||
label: Optional[str] = None, |
|||
disabled: bool = False, |
|||
custom_id: Optional[str] = None, |
|||
url: Optional[str] = None, |
|||
emoji: Optional[Union[str, Emoji, PartialEmoji]] = None, |
|||
row: Optional[int] = None, |
|||
): |
|||
super().__init__() |
|||
if custom_id is not None and url is not None: |
|||
raise TypeError('cannot mix both url and custom_id with Button') |
|||
|
|||
self._provided_custom_id = custom_id is not None |
|||
if url is None and custom_id is None: |
|||
custom_id = os.urandom(16).hex() |
|||
|
|||
if url is not None: |
|||
style = ButtonStyle.link |
|||
|
|||
if emoji is not None: |
|||
if isinstance(emoji, str): |
|||
emoji = PartialEmoji.from_str(emoji) |
|||
elif isinstance(emoji, _EmojiTag): |
|||
emoji = emoji._to_partial() |
|||
else: |
|||
raise TypeError(f'expected emoji to be str, Emoji, or PartialEmoji not {emoji.__class__}') |
|||
|
|||
self._underlying = ButtonComponent._raw_construct( |
|||
type=ComponentType.button, |
|||
custom_id=custom_id, |
|||
url=url, |
|||
disabled=disabled, |
|||
label=label, |
|||
style=style, |
|||
emoji=emoji, |
|||
) |
|||
self.row = row |
|||
|
|||
@property |
|||
def style(self) -> ButtonStyle: |
|||
""":class:`discord.ButtonStyle`: The style of the button.""" |
|||
return self._underlying.style |
|||
|
|||
@style.setter |
|||
def style(self, value: ButtonStyle): |
|||
self._underlying.style = value |
|||
|
|||
@property |
|||
def custom_id(self) -> Optional[str]: |
|||
"""Optional[:class:`str`]: The ID of the button that gets received during an interaction. |
|||
|
|||
If this button is for a URL, it does not have a custom ID. |
|||
""" |
|||
return self._underlying.custom_id |
|||
|
|||
@custom_id.setter |
|||
def custom_id(self, value: Optional[str]): |
|||
if value is not None and not isinstance(value, str): |
|||
raise TypeError('custom_id must be None or str') |
|||
|
|||
self._underlying.custom_id = value |
|||
|
|||
@property |
|||
def url(self) -> Optional[str]: |
|||
"""Optional[:class:`str`]: The URL this button sends you to.""" |
|||
return self._underlying.url |
|||
|
|||
@url.setter |
|||
def url(self, value: Optional[str]): |
|||
if value is not None and not isinstance(value, str): |
|||
raise TypeError('url must be None or str') |
|||
self._underlying.url = value |
|||
|
|||
@property |
|||
def disabled(self) -> bool: |
|||
""":class:`bool`: Whether the button is disabled or not.""" |
|||
return self._underlying.disabled |
|||
|
|||
@disabled.setter |
|||
def disabled(self, value: bool): |
|||
self._underlying.disabled = bool(value) |
|||
|
|||
@property |
|||
def label(self) -> Optional[str]: |
|||
"""Optional[:class:`str`]: The label of the button, if available.""" |
|||
return self._underlying.label |
|||
|
|||
@label.setter |
|||
def label(self, value: Optional[str]): |
|||
self._underlying.label = str(value) if value is not None else value |
|||
|
|||
@property |
|||
def emoji(self) -> Optional[PartialEmoji]: |
|||
"""Optional[:class:`.PartialEmoji`]: The emoji of the button, if available.""" |
|||
return self._underlying.emoji |
|||
|
|||
@emoji.setter |
|||
def emoji(self, value: Optional[Union[str, Emoji, PartialEmoji]]): # type: ignore |
|||
if value is not None: |
|||
if isinstance(value, str): |
|||
self._underlying.emoji = PartialEmoji.from_str(value) |
|||
elif isinstance(value, _EmojiTag): |
|||
self._underlying.emoji = value._to_partial() |
|||
else: |
|||
raise TypeError(f'expected str, Emoji, or PartialEmoji, received {value.__class__} instead') |
|||
else: |
|||
self._underlying.emoji = None |
|||
|
|||
@classmethod |
|||
def from_component(cls, button: ButtonComponent) -> Self: |
|||
return cls( |
|||
style=button.style, |
|||
label=button.label, |
|||
disabled=button.disabled, |
|||
custom_id=button.custom_id, |
|||
url=button.url, |
|||
emoji=button.emoji, |
|||
row=None, |
|||
) |
|||
|
|||
@property |
|||
def type(self) -> ComponentType: |
|||
return self._underlying.type |
|||
|
|||
def to_component_dict(self): |
|||
return self._underlying.to_dict() |
|||
|
|||
def is_dispatchable(self) -> bool: |
|||
return self.custom_id is not None |
|||
|
|||
def is_persistent(self) -> bool: |
|||
if self.style is ButtonStyle.link: |
|||
return self.url is not None |
|||
return super().is_persistent() |
|||
|
|||
def refresh_component(self, button: ButtonComponent) -> None: |
|||
self._underlying = button |
|||
|
|||
|
|||
def button( |
|||
*, |
|||
label: Optional[str] = None, |
|||
custom_id: Optional[str] = None, |
|||
disabled: bool = False, |
|||
style: ButtonStyle = ButtonStyle.secondary, |
|||
emoji: Optional[Union[str, Emoji, PartialEmoji]] = None, |
|||
row: Optional[int] = None, |
|||
) -> Callable[[ItemCallbackType[V, Button[V]]], Button[V]]: |
|||
"""A decorator that attaches a button to a component. |
|||
|
|||
The function being decorated should have three parameters, ``self`` representing |
|||
the :class:`discord.ui.View`, the :class:`discord.ui.Button` being pressed and |
|||
the :class:`discord.Interaction` you receive. |
|||
|
|||
.. note:: |
|||
|
|||
Buttons with a URL cannot be created with this function. |
|||
Consider creating a :class:`Button` manually instead. |
|||
This is because buttons with a URL do not have a callback |
|||
associated with them since Discord does not do any processing |
|||
with it. |
|||
|
|||
Parameters |
|||
------------ |
|||
label: Optional[:class:`str`] |
|||
The label of the button, if any. |
|||
custom_id: Optional[:class:`str`] |
|||
The ID of the button that gets received during an interaction. |
|||
It is recommended not to set this parameter to prevent conflicts. |
|||
style: :class:`.ButtonStyle` |
|||
The style of the button. Defaults to :attr:`.ButtonStyle.grey`. |
|||
disabled: :class:`bool` |
|||
Whether the button is disabled or not. Defaults to ``False``. |
|||
emoji: Optional[Union[:class:`str`, :class:`.Emoji`, :class:`.PartialEmoji`]] |
|||
The emoji of the button. This can be in string form or a :class:`.PartialEmoji` |
|||
or a full :class:`.Emoji`. |
|||
row: Optional[:class:`int`] |
|||
The relative row this button belongs to. A Discord component can only have 5 |
|||
rows. By default, items are arranged automatically into those 5 rows. If you'd |
|||
like to control the relative positioning of the row then passing an index is advised. |
|||
For example, row=1 will show up before row=2. Defaults to ``None``, which is automatic |
|||
ordering. The row number must be between 0 and 4 (i.e. zero indexed). |
|||
""" |
|||
|
|||
def decorator(func: ItemCallbackType[V, Button[V]]) -> ItemCallbackType[V, Button[V]]: |
|||
if not inspect.iscoroutinefunction(func): |
|||
raise TypeError('button function must be a coroutine function') |
|||
|
|||
func.__discord_ui_model_type__ = Button |
|||
func.__discord_ui_model_kwargs__ = { |
|||
'style': style, |
|||
'custom_id': custom_id, |
|||
'url': None, |
|||
'disabled': disabled, |
|||
'label': label, |
|||
'emoji': emoji, |
|||
'row': row, |
|||
} |
|||
return func |
|||
|
|||
return decorator # type: ignore |
|||
@ -1,133 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import Any, Callable, Coroutine, Dict, Generic, Optional, TYPE_CHECKING, Tuple, Type, TypeVar |
|||
|
|||
from ..interactions import Interaction |
|||
|
|||
# fmt: off |
|||
__all__ = ( |
|||
'Item', |
|||
) |
|||
# fmt: on |
|||
|
|||
if TYPE_CHECKING: |
|||
from ..enums import ComponentType |
|||
from .view import View |
|||
from ..components import Component |
|||
|
|||
I = TypeVar('I', bound='Item') |
|||
V = TypeVar('V', bound='View', covariant=True) |
|||
ItemCallbackType = Callable[[V, I, Interaction], Coroutine[Any, Any, Any]] |
|||
|
|||
|
|||
class Item(Generic[V]): |
|||
"""Represents the base UI item that all UI components inherit from. |
|||
|
|||
The current UI items supported are: |
|||
|
|||
- :class:`discord.ui.Button` |
|||
- :class:`discord.ui.Select` |
|||
|
|||
.. versionadded:: 2.0 |
|||
""" |
|||
|
|||
__item_repr_attributes__: Tuple[str, ...] = ('row',) |
|||
|
|||
def __init__(self): |
|||
self._view: Optional[V] = None |
|||
self._row: Optional[int] = None |
|||
self._rendered_row: Optional[int] = None |
|||
# This works mostly well but there is a gotcha with |
|||
# the interaction with from_component, since that technically provides |
|||
# a custom_id most dispatchable items would get this set to True even though |
|||
# it might not be provided by the library user. However, this edge case doesn't |
|||
# actually affect the intended purpose of this check because from_component is |
|||
# only called upon edit and we're mainly interested during initial creation time. |
|||
self._provided_custom_id: bool = False |
|||
|
|||
def to_component_dict(self) -> Dict[str, Any]: |
|||
raise NotImplementedError |
|||
|
|||
def refresh_component(self, component: Component) -> None: |
|||
return None |
|||
|
|||
def refresh_state(self, data: Dict[str, Any]) -> None: |
|||
return None |
|||
|
|||
@classmethod |
|||
def from_component(cls: Type[I], component: Component) -> I: |
|||
return cls() |
|||
|
|||
@property |
|||
def type(self) -> ComponentType: |
|||
raise NotImplementedError |
|||
|
|||
def is_dispatchable(self) -> bool: |
|||
return False |
|||
|
|||
def is_persistent(self) -> bool: |
|||
return self._provided_custom_id |
|||
|
|||
def __repr__(self) -> str: |
|||
attrs = ' '.join(f'{key}={getattr(self, key)!r}' for key in self.__item_repr_attributes__) |
|||
return f'<{self.__class__.__name__} {attrs}>' |
|||
|
|||
@property |
|||
def row(self) -> Optional[int]: |
|||
return self._row |
|||
|
|||
@row.setter |
|||
def row(self, value: Optional[int]): |
|||
if value is None: |
|||
self._row = None |
|||
elif 5 > value >= 0: |
|||
self._row = value |
|||
else: |
|||
raise ValueError('row cannot be negative or greater than or equal to 5') |
|||
|
|||
@property |
|||
def width(self) -> int: |
|||
return 1 |
|||
|
|||
@property |
|||
def view(self) -> Optional[V]: |
|||
"""Optional[:class:`View`]: The underlying view for this item.""" |
|||
return self._view |
|||
|
|||
async def callback(self, interaction: Interaction): |
|||
"""|coro| |
|||
|
|||
The callback associated with this UI item. |
|||
|
|||
This can be overriden by subclasses. |
|||
|
|||
Parameters |
|||
----------- |
|||
interaction: :class:`.Interaction` |
|||
The interaction that triggered this UI item. |
|||
""" |
|||
pass |
|||
@ -1,212 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
import asyncio |
|||
import logging |
|||
import os |
|||
import sys |
|||
import time |
|||
import traceback |
|||
from copy import deepcopy |
|||
from typing import TYPE_CHECKING, Any, Dict, Optional, Sequence, ClassVar, List |
|||
|
|||
from ..utils import MISSING, find |
|||
from .item import Item |
|||
from .view import View |
|||
|
|||
if TYPE_CHECKING: |
|||
from ..interactions import Interaction |
|||
from ..types.interactions import ModalSubmitComponentInteractionData as ModalSubmitComponentInteractionDataPayload |
|||
|
|||
|
|||
# fmt: off |
|||
__all__ = ( |
|||
'Modal', |
|||
) |
|||
# fmt: on |
|||
|
|||
|
|||
_log = logging.getLogger(__name__) |
|||
|
|||
|
|||
class Modal(View): |
|||
"""Represents a UI modal. |
|||
|
|||
This object must be inherited to create a modal popup window within discord. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Examples |
|||
---------- |
|||
|
|||
.. code-block:: python3 |
|||
|
|||
from discord import ui |
|||
|
|||
class Questionnaire(ui.Modal, title='Questionnaire Response'): |
|||
name = ui.TextInput(label='Name') |
|||
answer = ui.TextInput(label='Answer', style=discord.TextStyle.paragraph) |
|||
|
|||
async def on_submit(self, interaction: discord.Interaction): |
|||
await interaction.response.send_message(f'Thanks for your response, {self.name}!', ephemeral=True) |
|||
|
|||
Parameters |
|||
----------- |
|||
title: :class:`str` |
|||
The title of the modal. |
|||
timeout: Optional[:class:`float`] |
|||
Timeout in seconds from last interaction with the UI before no longer accepting input. |
|||
If ``None`` then there is no timeout. |
|||
custom_id: :class:`str` |
|||
The ID of the modal that gets received during an interaction. |
|||
If not given then one is generated for you. |
|||
|
|||
Attributes |
|||
------------ |
|||
timeout: Optional[:class:`float`] |
|||
Timeout from last interaction with the UI before no longer accepting input. |
|||
If ``None`` then there is no timeout. |
|||
title: :class:`str` |
|||
The title of the modal. |
|||
children: List[:class:`Item`] |
|||
The list of children attached to this view. |
|||
custom_id: :class:`str` |
|||
The ID of the modal that gets received during an interaction. |
|||
""" |
|||
|
|||
if TYPE_CHECKING: |
|||
title: str |
|||
|
|||
__discord_ui_modal__ = True |
|||
__modal_children_items__: ClassVar[Dict[str, Item]] = {} |
|||
|
|||
def __init_subclass__(cls, *, title: str = MISSING) -> None: |
|||
if title is not MISSING: |
|||
cls.title = title |
|||
|
|||
children = {} |
|||
for base in reversed(cls.__mro__): |
|||
for name, member in base.__dict__.items(): |
|||
if isinstance(member, Item): |
|||
children[name] = member |
|||
|
|||
cls.__modal_children_items__ = children |
|||
|
|||
def _init_children(self) -> List[Item]: |
|||
children = [] |
|||
for name, item in self.__modal_children_items__.items(): |
|||
item = deepcopy(item) |
|||
setattr(self, name, item) |
|||
item._view = self |
|||
children.append(item) |
|||
return children |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
title: str = MISSING, |
|||
timeout: Optional[float] = None, |
|||
custom_id: str = MISSING, |
|||
) -> None: |
|||
if title is MISSING and getattr(self, 'title', MISSING) is MISSING: |
|||
raise ValueError('Modal must have a title') |
|||
elif title is not MISSING: |
|||
self.title = title |
|||
self.custom_id: str = os.urandom(16).hex() if custom_id is MISSING else custom_id |
|||
|
|||
super().__init__(timeout=timeout) |
|||
|
|||
async def on_submit(self, interaction: Interaction): |
|||
"""|coro| |
|||
|
|||
Called when the modal is submitted. |
|||
|
|||
Parameters |
|||
----------- |
|||
interaction: :class:`.Interaction` |
|||
The interaction that submitted this modal. |
|||
""" |
|||
pass |
|||
|
|||
async def on_error(self, error: Exception, interaction: Interaction) -> None: |
|||
"""|coro| |
|||
|
|||
A callback that is called when :meth:`on_submit` |
|||
fails with an error. |
|||
|
|||
The default implementation prints the traceback to stderr. |
|||
|
|||
Parameters |
|||
----------- |
|||
error: :class:`Exception` |
|||
The exception that was raised. |
|||
interaction: :class:`~discord.Interaction` |
|||
The interaction that led to the failure. |
|||
""" |
|||
print(f'Ignoring exception in modal {self}:', file=sys.stderr) |
|||
traceback.print_exception(error.__class__, error, error.__traceback__, file=sys.stderr) |
|||
|
|||
def refresh(self, components: Sequence[ModalSubmitComponentInteractionDataPayload]): |
|||
for component in components: |
|||
if component['type'] == 1: |
|||
self.refresh(component['components']) |
|||
else: |
|||
item = find(lambda i: i.custom_id == component['custom_id'], self.children) # type: ignore |
|||
if item is None: |
|||
_log.debug("Modal interaction referencing unknown item custom_id %s. Discarding", component['custom_id']) |
|||
continue |
|||
item.refresh_state(component) # type: ignore |
|||
|
|||
async def _scheduled_task(self, interaction: Interaction): |
|||
try: |
|||
if self.timeout: |
|||
self.__timeout_expiry = time.monotonic() + self.timeout |
|||
|
|||
allow = await self.interaction_check(interaction) |
|||
if not allow: |
|||
return |
|||
|
|||
await self.on_submit(interaction) |
|||
if not interaction.response._responded: |
|||
await interaction.response.defer() |
|||
except Exception as e: |
|||
return await self.on_error(e, interaction) |
|||
else: |
|||
# No error, so assume this will always happen |
|||
# In the future, maybe this will require checking if we set an error response. |
|||
self.stop() |
|||
|
|||
def _dispatch_submit(self, interaction: Interaction) -> None: |
|||
asyncio.create_task(self._scheduled_task(interaction), name=f'discord-ui-modal-dispatch-{self.id}') |
|||
|
|||
def to_dict(self) -> Dict[str, Any]: |
|||
payload = { |
|||
'custom_id': self.custom_id, |
|||
'title': self.title, |
|||
'components': self.to_components(), |
|||
} |
|||
|
|||
return payload |
|||
@ -1,355 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
from typing import List, Optional, TYPE_CHECKING, Tuple, TypeVar, Callable, Union |
|||
import inspect |
|||
import os |
|||
|
|||
from .item import Item, ItemCallbackType |
|||
from ..enums import ComponentType |
|||
from ..partial_emoji import PartialEmoji |
|||
from ..emoji import Emoji |
|||
from ..utils import MISSING |
|||
from ..components import ( |
|||
SelectOption, |
|||
SelectMenu, |
|||
) |
|||
|
|||
__all__ = ( |
|||
'Select', |
|||
'select', |
|||
) |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .view import View |
|||
from ..types.components import SelectMenu as SelectMenuPayload |
|||
from ..types.interactions import ( |
|||
MessageComponentInteractionData, |
|||
) |
|||
|
|||
V = TypeVar('V', bound='View', covariant=True) |
|||
|
|||
|
|||
class Select(Item[V]): |
|||
"""Represents a UI select menu. |
|||
|
|||
This is usually represented as a drop down menu. |
|||
|
|||
In order to get the selected items that the user has chosen, use :attr:`Select.values`. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Parameters |
|||
------------ |
|||
custom_id: :class:`str` |
|||
The ID of the select menu that gets received during an interaction. |
|||
If not given then one is generated for you. |
|||
placeholder: Optional[:class:`str`] |
|||
The placeholder text that is shown if nothing is selected, if any. |
|||
min_values: :class:`int` |
|||
The minimum number of items that must be chosen for this select menu. |
|||
Defaults to 1 and must be between 1 and 25. |
|||
max_values: :class:`int` |
|||
The maximum number of items that must be chosen for this select menu. |
|||
Defaults to 1 and must be between 1 and 25. |
|||
options: List[:class:`discord.SelectOption`] |
|||
A list of options that can be selected in this menu. |
|||
disabled: :class:`bool` |
|||
Whether the select is disabled or not. |
|||
row: Optional[:class:`int`] |
|||
The relative row this select menu belongs to. A Discord component can only have 5 |
|||
rows. By default, items are arranged automatically into those 5 rows. If you'd |
|||
like to control the relative positioning of the row then passing an index is advised. |
|||
For example, row=1 will show up before row=2. Defaults to ``None``, which is automatic |
|||
ordering. The row number must be between 0 and 4 (i.e. zero indexed). |
|||
""" |
|||
|
|||
__item_repr_attributes__: Tuple[str, ...] = ( |
|||
'placeholder', |
|||
'min_values', |
|||
'max_values', |
|||
'options', |
|||
'disabled', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
custom_id: str = MISSING, |
|||
placeholder: Optional[str] = None, |
|||
min_values: int = 1, |
|||
max_values: int = 1, |
|||
options: List[SelectOption] = MISSING, |
|||
disabled: bool = False, |
|||
row: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
self._selected_values: List[str] = [] |
|||
self._provided_custom_id = custom_id is not MISSING |
|||
custom_id = os.urandom(16).hex() if custom_id is MISSING else custom_id |
|||
options = [] if options is MISSING else options |
|||
self._underlying = SelectMenu._raw_construct( |
|||
custom_id=custom_id, |
|||
type=ComponentType.select, |
|||
placeholder=placeholder, |
|||
min_values=min_values, |
|||
max_values=max_values, |
|||
options=options, |
|||
disabled=disabled, |
|||
) |
|||
self.row = row |
|||
|
|||
@property |
|||
def custom_id(self) -> str: |
|||
""":class:`str`: The ID of the select menu that gets received during an interaction.""" |
|||
return self._underlying.custom_id |
|||
|
|||
@custom_id.setter |
|||
def custom_id(self, value: str): |
|||
if not isinstance(value, str): |
|||
raise TypeError('custom_id must be None or str') |
|||
|
|||
self._underlying.custom_id = value |
|||
|
|||
@property |
|||
def placeholder(self) -> Optional[str]: |
|||
"""Optional[:class:`str`]: The placeholder text that is shown if nothing is selected, if any.""" |
|||
return self._underlying.placeholder |
|||
|
|||
@placeholder.setter |
|||
def placeholder(self, value: Optional[str]): |
|||
if value is not None and not isinstance(value, str): |
|||
raise TypeError('placeholder must be None or str') |
|||
|
|||
self._underlying.placeholder = value |
|||
|
|||
@property |
|||
def min_values(self) -> int: |
|||
""":class:`int`: The minimum number of items that must be chosen for this select menu.""" |
|||
return self._underlying.min_values |
|||
|
|||
@min_values.setter |
|||
def min_values(self, value: int): |
|||
self._underlying.min_values = int(value) |
|||
|
|||
@property |
|||
def max_values(self) -> int: |
|||
""":class:`int`: The maximum number of items that must be chosen for this select menu.""" |
|||
return self._underlying.max_values |
|||
|
|||
@max_values.setter |
|||
def max_values(self, value: int): |
|||
self._underlying.max_values = int(value) |
|||
|
|||
@property |
|||
def options(self) -> List[SelectOption]: |
|||
"""List[:class:`discord.SelectOption`]: A list of options that can be selected in this menu.""" |
|||
return self._underlying.options |
|||
|
|||
@options.setter |
|||
def options(self, value: List[SelectOption]): |
|||
if not isinstance(value, list): |
|||
raise TypeError('options must be a list of SelectOption') |
|||
if not all(isinstance(obj, SelectOption) for obj in value): |
|||
raise TypeError('all list items must subclass SelectOption') |
|||
|
|||
self._underlying.options = value |
|||
|
|||
def add_option( |
|||
self, |
|||
*, |
|||
label: str, |
|||
value: str = MISSING, |
|||
description: Optional[str] = None, |
|||
emoji: Optional[Union[str, Emoji, PartialEmoji]] = None, |
|||
default: bool = False, |
|||
): |
|||
"""Adds an option to the select menu. |
|||
|
|||
To append a pre-existing :class:`discord.SelectOption` use the |
|||
:meth:`append_option` method instead. |
|||
|
|||
Parameters |
|||
----------- |
|||
label: :class:`str` |
|||
The label of the option. This is displayed to users. |
|||
Can only be up to 100 characters. |
|||
value: :class:`str` |
|||
The value of the option. This is not displayed to users. |
|||
If not given, defaults to the label. Can only be up to 100 characters. |
|||
description: Optional[:class:`str`] |
|||
An additional description of the option, if any. |
|||
Can only be up to 100 characters. |
|||
emoji: Optional[Union[:class:`str`, :class:`.Emoji`, :class:`.PartialEmoji`]] |
|||
The emoji of the option, if available. This can either be a string representing |
|||
the custom or unicode emoji or an instance of :class:`.PartialEmoji` or :class:`.Emoji`. |
|||
default: :class:`bool` |
|||
Whether this option is selected by default. |
|||
|
|||
Raises |
|||
------- |
|||
ValueError |
|||
The number of options exceeds 25. |
|||
""" |
|||
|
|||
option = SelectOption( |
|||
label=label, |
|||
value=value, |
|||
description=description, |
|||
emoji=emoji, |
|||
default=default, |
|||
) |
|||
|
|||
self.append_option(option) |
|||
|
|||
def append_option(self, option: SelectOption): |
|||
"""Appends an option to the select menu. |
|||
|
|||
Parameters |
|||
----------- |
|||
option: :class:`discord.SelectOption` |
|||
The option to append to the select menu. |
|||
|
|||
Raises |
|||
------- |
|||
ValueError |
|||
The number of options exceeds 25. |
|||
""" |
|||
|
|||
if len(self._underlying.options) > 25: |
|||
raise ValueError('maximum number of options already provided') |
|||
|
|||
self._underlying.options.append(option) |
|||
|
|||
@property |
|||
def disabled(self) -> bool: |
|||
""":class:`bool`: Whether the select is disabled or not.""" |
|||
return self._underlying.disabled |
|||
|
|||
@disabled.setter |
|||
def disabled(self, value: bool): |
|||
self._underlying.disabled = bool(value) |
|||
|
|||
@property |
|||
def values(self) -> List[str]: |
|||
"""List[:class:`str`]: A list of values that have been selected by the user.""" |
|||
return self._selected_values |
|||
|
|||
@property |
|||
def width(self) -> int: |
|||
return 5 |
|||
|
|||
def to_component_dict(self) -> SelectMenuPayload: |
|||
return self._underlying.to_dict() |
|||
|
|||
def refresh_component(self, component: SelectMenu) -> None: |
|||
self._underlying = component |
|||
|
|||
def refresh_state(self, data: MessageComponentInteractionData) -> None: |
|||
self._selected_values = data.get('values', []) |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: SelectMenu) -> Self: |
|||
return cls( |
|||
custom_id=component.custom_id, |
|||
placeholder=component.placeholder, |
|||
min_values=component.min_values, |
|||
max_values=component.max_values, |
|||
options=component.options, |
|||
disabled=component.disabled, |
|||
row=None, |
|||
) |
|||
|
|||
@property |
|||
def type(self) -> ComponentType: |
|||
return self._underlying.type |
|||
|
|||
def is_dispatchable(self) -> bool: |
|||
return True |
|||
|
|||
|
|||
def select( |
|||
*, |
|||
placeholder: Optional[str] = None, |
|||
custom_id: str = MISSING, |
|||
min_values: int = 1, |
|||
max_values: int = 1, |
|||
options: List[SelectOption] = MISSING, |
|||
disabled: bool = False, |
|||
row: Optional[int] = None, |
|||
) -> Callable[[ItemCallbackType[V, Select[V]]], Select[V]]: |
|||
"""A decorator that attaches a select menu to a component. |
|||
|
|||
The function being decorated should have three parameters, ``self`` representing |
|||
the :class:`discord.ui.View`, the :class:`discord.ui.Select` being pressed and |
|||
the :class:`discord.Interaction` you receive. |
|||
|
|||
In order to get the selected items that the user has chosen within the callback |
|||
use :attr:`Select.values`. |
|||
|
|||
Parameters |
|||
------------ |
|||
placeholder: Optional[:class:`str`] |
|||
The placeholder text that is shown if nothing is selected, if any. |
|||
custom_id: :class:`str` |
|||
The ID of the select menu that gets received during an interaction. |
|||
It is recommended not to set this parameter to prevent conflicts. |
|||
row: Optional[:class:`int`] |
|||
The relative row this select menu belongs to. A Discord component can only have 5 |
|||
rows. By default, items are arranged automatically into those 5 rows. If you'd |
|||
like to control the relative positioning of the row then passing an index is advised. |
|||
For example, row=1 will show up before row=2. Defaults to ``None``, which is automatic |
|||
ordering. The row number must be between 0 and 4 (i.e. zero indexed). |
|||
min_values: :class:`int` |
|||
The minimum number of items that must be chosen for this select menu. |
|||
Defaults to 1 and must be between 1 and 25. |
|||
max_values: :class:`int` |
|||
The maximum number of items that must be chosen for this select menu. |
|||
Defaults to 1 and must be between 1 and 25. |
|||
options: List[:class:`discord.SelectOption`] |
|||
A list of options that can be selected in this menu. |
|||
disabled: :class:`bool` |
|||
Whether the select is disabled or not. Defaults to ``False``. |
|||
""" |
|||
|
|||
def decorator(func: ItemCallbackType[V, Select[V]]) -> ItemCallbackType[V, Select[V]]: |
|||
if not inspect.iscoroutinefunction(func): |
|||
raise TypeError('select function must be a coroutine function') |
|||
|
|||
func.__discord_ui_model_type__ = Select |
|||
func.__discord_ui_model_kwargs__ = { |
|||
'placeholder': placeholder, |
|||
'custom_id': custom_id, |
|||
'row': row, |
|||
'min_values': min_values, |
|||
'max_values': max_values, |
|||
'options': options, |
|||
'disabled': disabled, |
|||
} |
|||
return func |
|||
|
|||
return decorator # type: ignore |
|||
@ -1,235 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
import os |
|||
from typing import TYPE_CHECKING, Optional, Tuple, TypeVar |
|||
|
|||
from ..components import TextInput as TextInputComponent |
|||
from ..enums import ComponentType, TextStyle |
|||
from ..utils import MISSING |
|||
from .item import Item |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from ..types.components import TextInput as TextInputPayload |
|||
from ..types.interactions import ModalSubmitTextInputInteractionData as ModalSubmitTextInputInteractionDataPayload |
|||
from .view import View |
|||
|
|||
|
|||
# fmt: off |
|||
__all__ = ( |
|||
'TextInput', |
|||
) |
|||
# fmt: on |
|||
|
|||
V = TypeVar('V', bound='View', covariant=True) |
|||
|
|||
|
|||
class TextInput(Item[V]): |
|||
"""Represents a UI text input. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Parameters |
|||
------------ |
|||
label: :class:`str` |
|||
The label to display above the text input. |
|||
custom_id: :class:`str` |
|||
The ID of the text input that gets received during an interaction. |
|||
If not given then one is generated for you. |
|||
style: :class:`discord.TextStyle` |
|||
The style of the text input. |
|||
placeholder: Optional[:class:`str`] |
|||
The placeholder text to display when the text input is empty. |
|||
default: Optional[:class:`str`] |
|||
The default value of the text input. |
|||
required: :class:`bool` |
|||
Whether the text input is required. |
|||
min_length: Optional[:class:`int`] |
|||
The minimum length of the text input. |
|||
max_length: Optional[:class:`int`] |
|||
The maximum length of the text input. |
|||
row: Optional[:class:`int`] |
|||
The relative row this text input belongs to. A Discord component can only have 5 |
|||
rows. By default, items are arranged automatically into those 5 rows. If you'd |
|||
like to control the relative positioning of the row then passing an index is advised. |
|||
For example, row=1 will show up before row=2. Defaults to ``None``, which is automatic |
|||
ordering. The row number must be between 0 and 4 (i.e. zero indexed). |
|||
""" |
|||
|
|||
__item_repr_attributes__: Tuple[str, ...] = ( |
|||
'label', |
|||
'placeholder', |
|||
'required', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
label: str, |
|||
style: TextStyle = TextStyle.short, |
|||
custom_id: str = MISSING, |
|||
placeholder: Optional[str] = None, |
|||
default: Optional[str] = None, |
|||
required: bool = True, |
|||
min_length: Optional[int] = None, |
|||
max_length: Optional[int] = None, |
|||
row: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
self._value: Optional[str] = default |
|||
self._provided_custom_id = custom_id is not MISSING |
|||
custom_id = os.urandom(16).hex() if custom_id is MISSING else custom_id |
|||
self._underlying = TextInputComponent._raw_construct( |
|||
type=ComponentType.text_input, |
|||
label=label, |
|||
style=style, |
|||
custom_id=custom_id, |
|||
placeholder=placeholder, |
|||
value=default, |
|||
required=required, |
|||
min_length=min_length, |
|||
max_length=max_length, |
|||
) |
|||
self.row: Optional[int] = row |
|||
|
|||
def __str__(self) -> str: |
|||
return self.value or '' |
|||
|
|||
@property |
|||
def custom_id(self) -> str: |
|||
""":class:`str`: The ID of the select menu that gets received during an interaction.""" |
|||
return self._underlying.custom_id |
|||
|
|||
@custom_id.setter |
|||
def custom_id(self, value: str) -> None: |
|||
if not isinstance(value, str): |
|||
raise TypeError('custom_id must be None or str') |
|||
|
|||
self._underlying.custom_id = value |
|||
|
|||
@property |
|||
def width(self) -> int: |
|||
return 5 |
|||
|
|||
@property |
|||
def value(self) -> Optional[str]: |
|||
"""Optional[:class:`str`]: The value of the text input.""" |
|||
return self._value |
|||
|
|||
@property |
|||
def label(self) -> str: |
|||
""":class:`str`: The label of the text input.""" |
|||
return self._underlying.label |
|||
|
|||
@label.setter |
|||
def label(self, value: str) -> None: |
|||
self._underlying.label = value |
|||
|
|||
@property |
|||
def placeholder(self) -> Optional[str]: |
|||
""":class:`str`: The placeholder text to display when the text input is empty.""" |
|||
return self._underlying.placeholder |
|||
|
|||
@placeholder.setter |
|||
def placeholder(self, value: Optional[str]) -> None: |
|||
self._underlying.placeholder = value |
|||
|
|||
@property |
|||
def required(self) -> bool: |
|||
""":class:`bool`: Whether the text input is required.""" |
|||
return self._underlying.required |
|||
|
|||
@required.setter |
|||
def required(self, value: bool) -> None: |
|||
self._underlying.required = value |
|||
|
|||
@property |
|||
def min_length(self) -> Optional[int]: |
|||
""":class:`int`: The minimum length of the text input.""" |
|||
return self._underlying.min_length |
|||
|
|||
@min_length.setter |
|||
def min_length(self, value: Optional[int]) -> None: |
|||
self._underlying.min_length = value |
|||
|
|||
@property |
|||
def max_length(self) -> Optional[int]: |
|||
""":class:`int`: The maximum length of the text input.""" |
|||
return self._underlying.max_length |
|||
|
|||
@max_length.setter |
|||
def max_length(self, value: Optional[int]) -> None: |
|||
self._underlying.max_length = value |
|||
|
|||
@property |
|||
def style(self) -> TextStyle: |
|||
""":class:`discord.TextStyle`: The style of the text input.""" |
|||
return self._underlying.style |
|||
|
|||
@style.setter |
|||
def style(self, value: TextStyle) -> None: |
|||
self._underlying.style = value |
|||
|
|||
@property |
|||
def default(self) -> Optional[str]: |
|||
""":class:`str`: The default value of the text input.""" |
|||
return self._underlying.value |
|||
|
|||
@default.setter |
|||
def default(self, value: Optional[str]) -> None: |
|||
self._underlying.value = value |
|||
|
|||
def to_component_dict(self) -> TextInputPayload: |
|||
return self._underlying.to_dict() |
|||
|
|||
def refresh_component(self, component: TextInputComponent) -> None: |
|||
self._underlying = component |
|||
|
|||
def refresh_state(self, data: ModalSubmitTextInputInteractionDataPayload) -> None: |
|||
self._value = data.get('value', None) |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: TextInputComponent) -> Self: |
|||
return cls( |
|||
label=component.label, |
|||
style=component.style, |
|||
custom_id=component.custom_id, |
|||
placeholder=component.placeholder, |
|||
default=component.value, |
|||
required=component.required, |
|||
min_length=component.min_length, |
|||
max_length=component.max_length, |
|||
row=None, |
|||
) |
|||
|
|||
@property |
|||
def type(self) -> ComponentType: |
|||
return ComponentType.text_input |
|||
|
|||
def is_dispatchable(self) -> bool: |
|||
return False |
|||
@ -1,571 +0,0 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
from typing import Any, Callable, ClassVar, Dict, Iterator, List, Optional, Sequence, TYPE_CHECKING, Tuple |
|||
from functools import partial |
|||
from itertools import groupby |
|||
|
|||
import traceback |
|||
import asyncio |
|||
import logging |
|||
import sys |
|||
import time |
|||
import os |
|||
from .item import Item, ItemCallbackType |
|||
from ..components import ( |
|||
Component, |
|||
ActionRow as ActionRowComponent, |
|||
_component_factory, |
|||
Button as ButtonComponent, |
|||
SelectMenu as SelectComponent, |
|||
) |
|||
|
|||
# fmt: off |
|||
__all__ = ( |
|||
'View', |
|||
) |
|||
# fmt: on |
|||
|
|||
|
|||
if TYPE_CHECKING: |
|||
from ..interactions import Interaction |
|||
from ..message import Message |
|||
from ..types.components import Component as ComponentPayload |
|||
from ..types.interactions import ModalSubmitComponentInteractionData as ModalSubmitComponentInteractionDataPayload |
|||
from ..state import ConnectionState |
|||
from .modal import Modal |
|||
|
|||
|
|||
_log = logging.getLogger(__name__) |
|||
|
|||
|
|||
def _walk_all_components(components: List[Component]) -> Iterator[Component]: |
|||
for item in components: |
|||
if isinstance(item, ActionRowComponent): |
|||
yield from item.children |
|||
else: |
|||
yield item |
|||
|
|||
|
|||
def _component_to_item(component: Component) -> Item: |
|||
if isinstance(component, ButtonComponent): |
|||
from .button import Button |
|||
|
|||
return Button.from_component(component) |
|||
if isinstance(component, SelectComponent): |
|||
from .select import Select |
|||
|
|||
return Select.from_component(component) |
|||
return Item.from_component(component) |
|||
|
|||
|
|||
class _ViewWeights: |
|||
# fmt: off |
|||
__slots__ = ( |
|||
'weights', |
|||
) |
|||
# fmt: on |
|||
|
|||
def __init__(self, children: List[Item]): |
|||
self.weights: List[int] = [0, 0, 0, 0, 0] |
|||
|
|||
key = lambda i: sys.maxsize if i.row is None else i.row |
|||
children = sorted(children, key=key) |
|||
for row, group in groupby(children, key=key): |
|||
for item in group: |
|||
self.add_item(item) |
|||
|
|||
def find_open_space(self, item: Item) -> int: |
|||
for index, weight in enumerate(self.weights): |
|||
if weight + item.width <= 5: |
|||
return index |
|||
|
|||
raise ValueError('could not find open space for item') |
|||
|
|||
def add_item(self, item: Item) -> None: |
|||
if item.row is not None: |
|||
total = self.weights[item.row] + item.width |
|||
if total > 5: |
|||
raise ValueError(f'item would not fit at row {item.row} ({total} > 5 width)') |
|||
self.weights[item.row] = total |
|||
item._rendered_row = item.row |
|||
else: |
|||
index = self.find_open_space(item) |
|||
self.weights[index] += item.width |
|||
item._rendered_row = index |
|||
|
|||
def remove_item(self, item: Item) -> None: |
|||
if item._rendered_row is not None: |
|||
self.weights[item._rendered_row] -= item.width |
|||
item._rendered_row = None |
|||
|
|||
def clear(self) -> None: |
|||
self.weights = [0, 0, 0, 0, 0] |
|||
|
|||
|
|||
class View: |
|||
"""Represents a UI view. |
|||
|
|||
This object must be inherited to create a UI within Discord. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Parameters |
|||
----------- |
|||
timeout: Optional[:class:`float`] |
|||
Timeout in seconds from last interaction with the UI before no longer accepting input. |
|||
If ``None`` then there is no timeout. |
|||
|
|||
Attributes |
|||
------------ |
|||
timeout: Optional[:class:`float`] |
|||
Timeout from last interaction with the UI before no longer accepting input. |
|||
If ``None`` then there is no timeout. |
|||
children: List[:class:`Item`] |
|||
The list of children attached to this view. |
|||
""" |
|||
|
|||
__discord_ui_view__: ClassVar[bool] = True |
|||
__discord_ui_modal__: ClassVar[bool] = False |
|||
__view_children_items__: ClassVar[List[ItemCallbackType[Any, Any]]] = [] |
|||
|
|||
def __init_subclass__(cls) -> None: |
|||
children: List[ItemCallbackType[Any, Any]] = [] |
|||
for base in reversed(cls.__mro__): |
|||
for member in base.__dict__.values(): |
|||
if hasattr(member, '__discord_ui_model_type__'): |
|||
children.append(member) |
|||
|
|||
if len(children) > 25: |
|||
raise TypeError('View cannot have more than 25 children') |
|||
|
|||
cls.__view_children_items__ = children |
|||
|
|||
def _init_children(self) -> List[Item]: |
|||
children = [] |
|||
for func in self.__view_children_items__: |
|||
item: Item = func.__discord_ui_model_type__(**func.__discord_ui_model_kwargs__) |
|||
item.callback = partial(func, self, item) # type: ignore |
|||
item._view = self |
|||
setattr(self, func.__name__, item) |
|||
children.append(item) |
|||
return children |
|||
|
|||
def __init__(self, *, timeout: Optional[float] = 180.0): |
|||
self.timeout = timeout |
|||
self.children: List[Item] = self._init_children() |
|||
self.__weights = _ViewWeights(self.children) |
|||
loop = asyncio.get_running_loop() |
|||
self.id: str = os.urandom(16).hex() |
|||
self.__cancel_callback: Optional[Callable[[View], None]] = None |
|||
self.__timeout_expiry: Optional[float] = None |
|||
self.__timeout_task: Optional[asyncio.Task[None]] = None |
|||
self.__stopped: asyncio.Future[bool] = loop.create_future() |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} timeout={self.timeout} children={len(self.children)}>' |
|||
|
|||
async def __timeout_task_impl(self) -> None: |
|||
while True: |
|||
# Guard just in case someone changes the value of the timeout at runtime |
|||
if self.timeout is None: |
|||
return |
|||
|
|||
if self.__timeout_expiry is None: |
|||
return self._dispatch_timeout() |
|||
|
|||
# Check if we've elapsed our currently set timeout |
|||
now = time.monotonic() |
|||
if now >= self.__timeout_expiry: |
|||
return self._dispatch_timeout() |
|||
|
|||
# Wait N seconds to see if timeout data has been refreshed |
|||
await asyncio.sleep(self.__timeout_expiry - now) |
|||
|
|||
def to_components(self) -> List[Dict[str, Any]]: |
|||
def key(item: Item) -> int: |
|||
return item._rendered_row or 0 |
|||
|
|||
children = sorted(self.children, key=key) |
|||
components: List[Dict[str, Any]] = [] |
|||
for _, group in groupby(children, key=key): |
|||
children = [item.to_component_dict() for item in group] |
|||
if not children: |
|||
continue |
|||
|
|||
components.append( |
|||
{ |
|||
'type': 1, |
|||
'components': children, |
|||
} |
|||
) |
|||
|
|||
return components |
|||
|
|||
@classmethod |
|||
def from_message(cls, message: Message, /, *, timeout: Optional[float] = 180.0) -> View: |
|||
"""Converts a message's components into a :class:`View`. |
|||
|
|||
The :attr:`.Message.components` of a message are read-only |
|||
and separate types from those in the ``discord.ui`` namespace. |
|||
In order to modify and edit message components they must be |
|||
converted into a :class:`View` first. |
|||
|
|||
Parameters |
|||
----------- |
|||
message: :class:`discord.Message` |
|||
The message with components to convert into a view. |
|||
timeout: Optional[:class:`float`] |
|||
The timeout of the converted view. |
|||
|
|||
Returns |
|||
-------- |
|||
:class:`View` |
|||
The converted view. This always returns a :class:`View` and not |
|||
one of its subclasses. |
|||
""" |
|||
view = View(timeout=timeout) |
|||
for component in _walk_all_components(message.components): |
|||
view.add_item(_component_to_item(component)) |
|||
return view |
|||
|
|||
@property |
|||
def _expires_at(self) -> Optional[float]: |
|||
if self.timeout: |
|||
return time.monotonic() + self.timeout |
|||
return None |
|||
|
|||
def add_item(self, item: Item) -> None: |
|||
"""Adds an item to the view. |
|||
|
|||
Parameters |
|||
----------- |
|||
item: :class:`Item` |
|||
The item to add to the view. |
|||
|
|||
Raises |
|||
-------- |
|||
TypeError |
|||
An :class:`Item` was not passed. |
|||
ValueError |
|||
Maximum number of children has been exceeded (25) |
|||
or the row the item is trying to be added to is full. |
|||
""" |
|||
|
|||
if len(self.children) > 25: |
|||
raise ValueError('maximum number of children exceeded') |
|||
|
|||
if not isinstance(item, Item): |
|||
raise TypeError(f'expected Item not {item.__class__!r}') |
|||
|
|||
self.__weights.add_item(item) |
|||
|
|||
item._view = self |
|||
self.children.append(item) |
|||
|
|||
def remove_item(self, item: Item) -> None: |
|||
"""Removes an item from the view. |
|||
|
|||
Parameters |
|||
----------- |
|||
item: :class:`Item` |
|||
The item to remove from the view. |
|||
""" |
|||
|
|||
try: |
|||
self.children.remove(item) |
|||
except ValueError: |
|||
pass |
|||
else: |
|||
self.__weights.remove_item(item) |
|||
|
|||
def clear_items(self) -> None: |
|||
"""Removes all items from the view.""" |
|||
self.children.clear() |
|||
self.__weights.clear() |
|||
|
|||
async def interaction_check(self, interaction: Interaction) -> bool: |
|||
"""|coro| |
|||
|
|||
A callback that is called when an interaction happens within the view |
|||
that checks whether the view should process item callbacks for the interaction. |
|||
|
|||
This is useful to override if, for example, you want to ensure that the |
|||
interaction author is a given user. |
|||
|
|||
The default implementation of this returns ``True``. |
|||
|
|||
.. note:: |
|||
|
|||
If an exception occurs within the body then the check |
|||
is considered a failure and :meth:`on_error` is called. |
|||
|
|||
Parameters |
|||
----------- |
|||
interaction: :class:`~discord.Interaction` |
|||
The interaction that occurred. |
|||
|
|||
Returns |
|||
--------- |
|||
:class:`bool` |
|||
Whether the view children's callbacks should be called. |
|||
""" |
|||
return True |
|||
|
|||
async def on_timeout(self) -> None: |
|||
"""|coro| |
|||
|
|||
A callback that is called when a view's timeout elapses without being explicitly stopped. |
|||
""" |
|||
pass |
|||
|
|||
async def on_error(self, error: Exception, item: Item, interaction: Interaction) -> None: |
|||
"""|coro| |
|||
|
|||
A callback that is called when an item's callback or :meth:`interaction_check` |
|||
fails with an error. |
|||
|
|||
The default implementation prints the traceback to stderr. |
|||
|
|||
Parameters |
|||
----------- |
|||
error: :class:`Exception` |
|||
The exception that was raised. |
|||
item: :class:`Item` |
|||
The item that failed the dispatch. |
|||
interaction: :class:`~discord.Interaction` |
|||
The interaction that led to the failure. |
|||
""" |
|||
print(f'Ignoring exception in view {self} for item {item}:', file=sys.stderr) |
|||
traceback.print_exception(error.__class__, error, error.__traceback__, file=sys.stderr) |
|||
|
|||
async def _scheduled_task(self, item: Item, interaction: Interaction): |
|||
try: |
|||
if self.timeout: |
|||
self.__timeout_expiry = time.monotonic() + self.timeout |
|||
|
|||
allow = await self.interaction_check(interaction) |
|||
if not allow: |
|||
return |
|||
|
|||
await item.callback(interaction) |
|||
if not interaction.response._responded: |
|||
await interaction.response.defer() |
|||
except Exception as e: |
|||
return await self.on_error(e, item, interaction) |
|||
|
|||
def _start_listening_from_store(self, store: ViewStore) -> None: |
|||
self.__cancel_callback = partial(store.remove_view) |
|||
if self.timeout: |
|||
loop = asyncio.get_running_loop() |
|||
if self.__timeout_task is not None: |
|||
self.__timeout_task.cancel() |
|||
|
|||
self.__timeout_expiry = time.monotonic() + self.timeout |
|||
self.__timeout_task = loop.create_task(self.__timeout_task_impl()) |
|||
|
|||
def _dispatch_timeout(self): |
|||
if self.__stopped.done(): |
|||
return |
|||
|
|||
if self.__cancel_callback: |
|||
self.__cancel_callback(self) |
|||
self.__cancel_callback = None |
|||
|
|||
self.__stopped.set_result(True) |
|||
asyncio.create_task(self.on_timeout(), name=f'discord-ui-view-timeout-{self.id}') |
|||
|
|||
def _dispatch_item(self, item: Item, interaction: Interaction): |
|||
if self.__stopped.done(): |
|||
return |
|||
|
|||
asyncio.create_task(self._scheduled_task(item, interaction), name=f'discord-ui-view-dispatch-{self.id}') |
|||
|
|||
def refresh(self, components: List[Component]): |
|||
# This is pretty hacky at the moment |
|||
# fmt: off |
|||
old_state: Dict[Tuple[int, str], Item] = { |
|||
(item.type.value, item.custom_id): item # type: ignore |
|||
for item in self.children |
|||
if item.is_dispatchable() |
|||
} |
|||
# fmt: on |
|||
children: List[Item] = [] |
|||
for component in _walk_all_components(components): |
|||
try: |
|||
older = old_state[(component.type.value, component.custom_id)] # type: ignore |
|||
except (KeyError, AttributeError): |
|||
children.append(_component_to_item(component)) |
|||
else: |
|||
older.refresh_component(component) |
|||
children.append(older) |
|||
|
|||
self.children = children |
|||
|
|||
def stop(self) -> None: |
|||
"""Stops listening to interaction events from this view. |
|||
|
|||
This operation cannot be undone. |
|||
""" |
|||
if not self.__stopped.done(): |
|||
self.__stopped.set_result(False) |
|||
|
|||
self.__timeout_expiry = None |
|||
if self.__timeout_task is not None: |
|||
self.__timeout_task.cancel() |
|||
self.__timeout_task = None |
|||
|
|||
if self.__cancel_callback: |
|||
self.__cancel_callback(self) |
|||
self.__cancel_callback = None |
|||
|
|||
def is_finished(self) -> bool: |
|||
""":class:`bool`: Whether the view has finished interacting.""" |
|||
return self.__stopped.done() |
|||
|
|||
def is_dispatching(self) -> bool: |
|||
""":class:`bool`: Whether the view has been added for dispatching purposes.""" |
|||
return self.__cancel_callback is not None |
|||
|
|||
def is_persistent(self) -> bool: |
|||
""":class:`bool`: Whether the view is set up as persistent. |
|||
|
|||
A persistent view has all their components with a set ``custom_id`` and |
|||
a :attr:`timeout` set to ``None``. |
|||
""" |
|||
return self.timeout is None and all(item.is_persistent() for item in self.children) |
|||
|
|||
async def wait(self) -> bool: |
|||
"""Waits until the view has finished interacting. |
|||
|
|||
A view is considered finished when :meth:`stop` is called |
|||
or it times out. |
|||
|
|||
Returns |
|||
-------- |
|||
:class:`bool` |
|||
If ``True``, then the view timed out. If ``False`` then |
|||
the view finished normally. |
|||
""" |
|||
return await self.__stopped |
|||
|
|||
|
|||
class ViewStore: |
|||
def __init__(self, state: ConnectionState): |
|||
# (component_type, message_id, custom_id): (View, Item) |
|||
self._views: Dict[Tuple[int, Optional[int], str], Tuple[View, Item]] = {} |
|||
# message_id: View |
|||
self._synced_message_views: Dict[int, View] = {} |
|||
# custom_id: Modal |
|||
self._modals: Dict[str, Modal] = {} |
|||
self._state: ConnectionState = state |
|||
|
|||
@property |
|||
def persistent_views(self) -> Sequence[View]: |
|||
# fmt: off |
|||
views = { |
|||
view.id: view |
|||
for (_, (view, _)) in self._views.items() |
|||
if view.is_persistent() |
|||
} |
|||
# fmt: on |
|||
return list(views.values()) |
|||
|
|||
def __verify_integrity(self): |
|||
to_remove: List[Tuple[int, Optional[int], str]] = [] |
|||
for (k, (view, _)) in self._views.items(): |
|||
if view.is_finished(): |
|||
to_remove.append(k) |
|||
|
|||
for k in to_remove: |
|||
del self._views[k] |
|||
|
|||
def add_view(self, view: View, message_id: Optional[int] = None): |
|||
view._start_listening_from_store(self) |
|||
if view.__discord_ui_modal__: |
|||
self._modals[view.custom_id] = view # type: ignore |
|||
return |
|||
|
|||
self.__verify_integrity() |
|||
|
|||
for item in view.children: |
|||
if item.is_dispatchable(): |
|||
self._views[(item.type.value, message_id, item.custom_id)] = (view, item) # type: ignore |
|||
|
|||
if message_id is not None: |
|||
self._synced_message_views[message_id] = view |
|||
|
|||
def remove_view(self, view: View): |
|||
if view.__discord_ui_modal__: |
|||
self._modals.pop(view.custom_id, None) # type: ignore |
|||
return |
|||
|
|||
for item in view.children: |
|||
if item.is_dispatchable(): |
|||
self._views.pop((item.type.value, item.custom_id), None) # type: ignore |
|||
|
|||
for key, value in self._synced_message_views.items(): |
|||
if value.id == view.id: |
|||
del self._synced_message_views[key] |
|||
break |
|||
|
|||
def dispatch_view(self, component_type: int, custom_id: str, interaction: Interaction): |
|||
self.__verify_integrity() |
|||
message_id: Optional[int] = interaction.message and interaction.message.id |
|||
key = (component_type, message_id, custom_id) |
|||
# Fallback to None message_id searches in case a persistent view |
|||
# was added without an associated message_id |
|||
value = self._views.get(key) or self._views.get((component_type, None, custom_id)) |
|||
if value is None: |
|||
return |
|||
|
|||
view, item = value |
|||
item.refresh_state(interaction.data) # type: ignore |
|||
view._dispatch_item(item, interaction) |
|||
|
|||
def dispatch_modal( |
|||
self, |
|||
custom_id: str, |
|||
interaction: Interaction, |
|||
components: List[ModalSubmitComponentInteractionDataPayload], |
|||
): |
|||
modal = self._modals.get(custom_id) |
|||
if modal is None: |
|||
_log.debug("Modal interaction referencing unknown custom_id %s. Discarding", custom_id) |
|||
return |
|||
|
|||
modal.refresh(components) |
|||
modal._dispatch_submit(interaction) |
|||
|
|||
def is_message_tracked(self, message_id: int): |
|||
return message_id in self._synced_message_views |
|||
|
|||
def remove_message_tracking(self, message_id: int) -> Optional[View]: |
|||
return self._synced_message_views.pop(message_id, None) |
|||
|
|||
def update_from_message(self, message_id: int, components: List[ComponentPayload]): |
|||
# pre-req: is_message_tracked == true |
|||
view = self._synced_message_views[message_id] |
|||
view.refresh([_component_factory(d) for d in components]) |
|||
@ -0,0 +1,187 @@ |
|||
""" |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015-present Rapptz |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a |
|||
copy of this software and associated documentation files (the "Software"), |
|||
to deal in the Software without restriction, including without limitation |
|||
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|||
and/or sell copies of the Software, and to permit persons to whom the |
|||
Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|||
DEALINGS IN THE SOFTWARE. |
|||
""" |
|||
|
|||
from __future__ import annotations |
|||
|
|||
from typing import List, Optional, TYPE_CHECKING, Union |
|||
|
|||
from .object import Object |
|||
from .partial_emoji import PartialEmoji |
|||
from .utils import _get_as_snowflake, MISSING |
|||
|
|||
if TYPE_CHECKING: |
|||
from .abc import Snowflake |
|||
from .emoji import Emoji |
|||
from .guild import Guild |
|||
from .state import ConnectionState |
|||
from .types.welcome_screen import ( |
|||
WelcomeScreen as WelcomeScreenPayload, |
|||
WelcomeScreenChannel as WelcomeScreenChannelPayload, |
|||
) |
|||
|
|||
__all__ = ( |
|||
'WelcomeChannel', |
|||
'WelcomeScreen', |
|||
) |
|||
|
|||
|
|||
class WelcomeChannel: |
|||
"""Represents a channel shown on a :class:`WelcomeScreen`. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
Attributes |
|||
----------- |
|||
channel: :class:`abc.Snowflake` |
|||
The channel that is being shown. |
|||
description: :class:`str` |
|||
The description of the channel. |
|||
emoji: Optional[Union[:class:`PartialEmoji`, :class:`Emoji`] |
|||
The emoji shown under the description. |
|||
""" |
|||
|
|||
def __init__( |
|||
self, *, channel: Snowflake, description: str, emoji: Optional[Union[PartialEmoji, Emoji]] = None |
|||
) -> None: |
|||
self.channel = channel |
|||
self.description = description |
|||
self.emoji = emoji |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<WelcomeChannel channel={self.channel!r} description={self.description} emoji={self.emoji!r}>' |
|||
|
|||
@classmethod |
|||
def _from_dict(cls, *, data: WelcomeScreenChannelPayload, state: ConnectionState) -> WelcomeChannel: |
|||
channel_id = _get_as_snowflake(data, 'channel_id') |
|||
channel = state.get_channel(channel_id) or Object(id=channel_id) |
|||
|
|||
emoji = None |
|||
if (emoji_id := _get_as_snowflake(data, 'emoji_id')) is not None: |
|||
emoji = state.get_emoji(emoji_id) |
|||
elif (emoji_name := data.get('emoji_name')) is not None: |
|||
emoji = PartialEmoji(name=emoji_name) |
|||
|
|||
return cls(channel=channel, description=data.get('description', ''), emoji=emoji) |
|||
|
|||
def _to_dict(self) -> WelcomeScreenChannelPayload: |
|||
data = { |
|||
'channel_id': self.channel.id, |
|||
'description': self.description, |
|||
'emoji_id': None, |
|||
'emoji_name': None, |
|||
} |
|||
if (emoji := self.emoji) is not None: |
|||
data['emoji_id'] = emoji.id |
|||
data['emoji_name'] = emoji.name |
|||
|
|||
return data |
|||
|
|||
|
|||
class WelcomeScreen: |
|||
"""Represents a :class:`Guild`'s welcome screen. |
|||
|
|||
.. versionadded:: 2.0 |
|||
|
|||
.. container:: operations |
|||
|
|||
.. describe:: bool(b) |
|||
|
|||
Returns whether the welcome screen is enabled. |
|||
|
|||
Attributes |
|||
----------- |
|||
guild: Union[:class:`Guild`, :class:`PartialInviteGuild`] |
|||
The guild the welcome screen is for. |
|||
description: :class:`str` |
|||
The text shown on the welcome screen. |
|||
welcome_channels: List[:class:`WelcomeChannel`] |
|||
The channels shown on the welcome screen. |
|||
""" |
|||
|
|||
def __init__(self, *, data: WelcomeScreenPayload, guild: Guild) -> None: |
|||
self.guild = guild |
|||
self._update(data) |
|||
|
|||
def _update(self, data: WelcomeScreenPayload) -> None: |
|||
state = self.guild._state |
|||
channels = data.get('welcome_channels', []) |
|||
|
|||
self.welcome_channels = [WelcomeChannel._from_dict(data=channel, state=state) for channel in channels] |
|||
self.description = data.get('description', '') |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<WelcomeScreen enabled={self.enabled} description={self.description} welcome_channels={self.welcome_channels!r}>' |
|||
|
|||
def __bool__(self) -> bool: |
|||
return self.enabled |
|||
|
|||
@property |
|||
def enabled(self) -> bool: |
|||
""":class:`bool`: Whether the welcome screen is displayed.""" |
|||
return 'WELCOME_SCREEN_ENABLED' in self.guild.features |
|||
|
|||
async def edit( |
|||
self, |
|||
*, |
|||
description: str = MISSING, |
|||
welcome_channels: List[WelcomeChannel] = MISSING, |
|||
enabled: bool = MISSING, |
|||
): |
|||
"""|coro| |
|||
|
|||
Edit the welcome screen. |
|||
You must have the :attr:`~Permissions.manage_guild` permission to do this. |
|||
|
|||
All parameters are optional. |
|||
|
|||
Parameters |
|||
------------ |
|||
enabled: :class:`bool` |
|||
Whether the welcome screen will be shown. |
|||
description: :class:`str` |
|||
The welcome screen's description. |
|||
welcome_channels: Optional[List[:class:`WelcomeChannel`]] |
|||
The welcome channels (in order). |
|||
|
|||
Raises |
|||
------- |
|||
HTTPException |
|||
Editing the welcome screen failed failed. |
|||
Forbidden |
|||
You don't have permissions to edit the welcome screen. |
|||
""" |
|||
payload = {} |
|||
|
|||
if enabled is not MISSING: |
|||
payload['enabled'] = enabled |
|||
if description is not MISSING: |
|||
payload['description'] = description |
|||
if welcome_channels is not MISSING: |
|||
channels = [channel._to_dict() for channel in welcome_channels] if welcome_channels else [] |
|||
payload['welcome_channels'] = channels |
|||
|
|||
if payload: |
|||
guild = self.guild |
|||
data = await guild._state.http.edit_welcome_screen(guild.id, payload) |
|||
self._update(data) |
|||
@ -1,96 +0,0 @@ |
|||
:orphan: |
|||
|
|||
.. _discord-intro: |
|||
|
|||
Creating a Bot Account |
|||
======================== |
|||
|
|||
In order to work with the library and the Discord API in general, we must first create a Discord Bot account. |
|||
|
|||
Creating a Bot account is a pretty straightforward process. |
|||
|
|||
1. Make sure you're logged on to the `Discord website <https://discord.com>`_. |
|||
2. Navigate to the `application page <https://discord.com/developers/applications>`_ |
|||
3. Click on the "New Application" button. |
|||
|
|||
.. image:: /images/discord_create_app_button.png |
|||
:alt: The new application button. |
|||
|
|||
4. Give the application a name and click "Create". |
|||
|
|||
.. image:: /images/discord_create_app_form.png |
|||
:alt: The new application form filled in. |
|||
|
|||
5. Create a Bot User by navigating to the "Bot" tab and clicking "Add Bot". |
|||
|
|||
- Click "Yes, do it!" to continue. |
|||
|
|||
.. image:: /images/discord_create_bot_user.png |
|||
:alt: The Add Bot button. |
|||
6. Make sure that **Public Bot** is ticked if you want others to invite your bot. |
|||
|
|||
- You should also make sure that **Require OAuth2 Code Grant** is unchecked unless you |
|||
are developing a service that needs it. If you're unsure, then **leave it unchecked**. |
|||
|
|||
.. image:: /images/discord_bot_user_options.png |
|||
:alt: How the Bot User options should look like for most people. |
|||
|
|||
7. Copy the token using the "Copy" button. |
|||
|
|||
- **This is not the Client Secret at the General Information page.** |
|||
|
|||
.. warning:: |
|||
|
|||
It should be worth noting that this token is essentially your bot's |
|||
password. You should **never** share this with someone else. In doing so, |
|||
someone can log in to your bot and do malicious things, such as leaving |
|||
servers, ban all members inside a server, or pinging everyone maliciously. |
|||
|
|||
The possibilities are endless, so **do not share this token.** |
|||
|
|||
If you accidentally leaked your token, click the "Regenerate" button as soon |
|||
as possible. This revokes your old token and re-generates a new one. |
|||
Now you need to use the new token to login. |
|||
|
|||
And that's it. You now have a bot account and you can login with that token. |
|||
|
|||
.. _discord_invite_bot: |
|||
|
|||
Inviting Your Bot |
|||
------------------- |
|||
|
|||
So you've made a Bot User but it's not actually in any server. |
|||
|
|||
If you want to invite your bot you must create an invite URL for it. |
|||
|
|||
1. Make sure you're logged on to the `Discord website <https://discord.com>`_. |
|||
2. Navigate to the `application page <https://discord.com/developers/applications>`_ |
|||
3. Click on your bot's page. |
|||
4. Go to the "OAuth2" tab. |
|||
|
|||
.. image:: /images/discord_oauth2.png |
|||
:alt: How the OAuth2 page should look like. |
|||
|
|||
5. Tick the "bot" checkbox under "scopes". |
|||
|
|||
.. image:: /images/discord_oauth2_scope.png |
|||
:alt: The scopes checkbox with "bot" ticked. |
|||
|
|||
6. Tick the permissions required for your bot to function under "Bot Permissions". |
|||
|
|||
- Please be aware of the consequences of requiring your bot to have the "Administrator" permission. |
|||
|
|||
- Bot owners must have 2FA enabled for certain actions and permissions when added in servers that have Server-Wide 2FA enabled. Check the `2FA support page <https://support.discord.com/hc/en-us/articles/219576828-Setting-up-Two-Factor-Authentication>`_ for more information. |
|||
|
|||
.. image:: /images/discord_oauth2_perms.png |
|||
:alt: The permission checkboxes with some permissions checked. |
|||
|
|||
7. Now the resulting URL can be used to add your bot to a server. Copy and paste the URL into your browser, choose a server to invite the bot to, and click "Authorize". |
|||
|
|||
|
|||
.. note:: |
|||
|
|||
The person adding the bot needs "Manage Server" permissions to do so. |
|||
|
|||
If you want to generate this URL dynamically at run-time inside your bot and using the |
|||
:class:`discord.Permissions` interface, you can use :func:`discord.utils.oauth_url`. |
|||
|
Before Width: | Height: | Size: 9.2 KiB |
|
Before Width: | Height: | Size: 47 KiB |
|
Before Width: | Height: | Size: 1.5 KiB |
|
Before Width: | Height: | Size: 12 KiB |
|
Before Width: | Height: | Size: 16 KiB |
|
Before Width: | Height: | Size: 29 KiB |
|
Before Width: | Height: | Size: 52 KiB |
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue