blord0
2 weeks ago
committed by
GitHub
GitHub
132 changed files with 7502 additions and 1144 deletions
@ -0,0 +1,369 @@ |
|||
""" |
|||
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, Iterable, Optional, Set, List, Union |
|||
|
|||
from .mixins import Hashable |
|||
from .enums import OnboardingMode, OnboardingPromptType, try_enum |
|||
from .partial_emoji import PartialEmoji |
|||
from .utils import cached_slot_property, MISSING |
|||
from . import utils |
|||
|
|||
__all__ = ( |
|||
'Onboarding', |
|||
'OnboardingPrompt', |
|||
'OnboardingPromptOption', |
|||
) |
|||
|
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .abc import GuildChannel, Snowflake |
|||
from .emoji import Emoji |
|||
from .guild import Guild |
|||
from .partial_emoji import PartialEmoji |
|||
from .role import Role |
|||
from .threads import Thread |
|||
from .types.onboarding import ( |
|||
Prompt as PromptPayload, |
|||
PromptOption as PromptOptionPayload, |
|||
CreatePromptOption as CreatePromptOptionPayload, |
|||
Onboarding as OnboardingPayload, |
|||
) |
|||
from .state import ConnectionState |
|||
|
|||
|
|||
class OnboardingPromptOption(Hashable): |
|||
"""Represents a onboarding prompt option. |
|||
|
|||
This can be manually created for :meth:`Guild.edit_onboarding`. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Parameters |
|||
----------- |
|||
title: :class:`str` |
|||
The title of this prompt option. |
|||
emoji: Union[:class:`Emoji`, :class:`PartialEmoji`, :class:`str`] |
|||
The emoji tied to this option. May be a custom emoji, or a unicode emoji. I |
|||
f this is a string, it will be converted to a :class:`PartialEmoji`. |
|||
description: Optional[:class:`str`] |
|||
The description of this prompt option. |
|||
channels: Iterable[Union[:class:`abc.Snowflake`, :class:`int`]] |
|||
The channels the user will be added to if this option is selected. |
|||
roles: Iterable[Union[:class:`abc.Snowflake`, :class:`int`]] |
|||
The roles the user will be given if this option is selected. |
|||
|
|||
Attributes |
|||
----------- |
|||
id: :class:`int` |
|||
The ID of this prompt option. If this was manually created then the ID will be ``0``. |
|||
title: :class:`str` |
|||
The title of this prompt option. |
|||
description: Optional[:class:`str`] |
|||
The description of this prompt option. |
|||
emoji: Optional[Union[:class:`Emoji`, :class:`PartialEmoji`]] |
|||
The emoji tied to this option. May be a custom emoji, or a unicode emoji. |
|||
channel_ids: Set[:class:`int`] |
|||
The IDs of the channels the user will be added to if this option is selected. |
|||
role_ids: Set[:class:`int`] |
|||
The IDs of the roles the user will be given if this option is selected. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'title', |
|||
'emoji', |
|||
'description', |
|||
'id', |
|||
'channel_ids', |
|||
'role_ids', |
|||
'_guild', |
|||
'_cs_channels', |
|||
'_cs_roles', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
title: str, |
|||
emoji: Union[Emoji, PartialEmoji, str] = MISSING, |
|||
description: Optional[str] = None, |
|||
channels: Iterable[Union[Snowflake, int]] = MISSING, |
|||
roles: Iterable[Union[Snowflake, int]] = MISSING, |
|||
) -> None: |
|||
self.id: int = 0 |
|||
self.title: str = title |
|||
self.description: Optional[str] = description |
|||
self.emoji: Optional[Union[Emoji, PartialEmoji]] = ( |
|||
PartialEmoji.from_str(emoji) if isinstance(emoji, str) else emoji if emoji is not MISSING else None |
|||
) |
|||
|
|||
self.channel_ids: Set[int] = ( |
|||
{c.id if not isinstance(c, int) else c for c in channels} if channels is not MISSING else set() |
|||
) |
|||
self.role_ids: Set[int] = {c.id if not isinstance(c, int) else c for c in roles} if roles is not MISSING else set() |
|||
self._guild: Optional[Guild] = None |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<OnboardingPromptOption id={self.id!r} title={self.title!r} emoji={self.emoji!r}>' |
|||
|
|||
@classmethod |
|||
def from_dict(cls, *, data: PromptOptionPayload, state: ConnectionState, guild: Guild) -> Self: |
|||
instance = cls( |
|||
title=data['title'], |
|||
description=data['description'], |
|||
emoji=state.get_emoji_from_partial_payload(data['emoji']) if 'emoji' in data else MISSING, |
|||
channels=[int(id) for id in data['channel_ids']], |
|||
roles=[int(id) for id in data['role_ids']], |
|||
) |
|||
instance._guild = guild |
|||
instance.id = int(data['id']) |
|||
return instance |
|||
|
|||
def to_dict( |
|||
self, |
|||
) -> CreatePromptOptionPayload: |
|||
res: CreatePromptOptionPayload = { |
|||
'title': self.title, |
|||
'description': self.description, |
|||
'channel_ids': list(self.channel_ids), |
|||
'role_ids': list(self.role_ids), |
|||
} |
|||
if self.emoji: |
|||
res.update((self.emoji._to_partial())._to_onboarding_prompt_option_payload()) # type: ignore |
|||
return res |
|||
|
|||
@property |
|||
def guild(self) -> Guild: |
|||
""":class:`Guild`: The guild this prompt option is related to. |
|||
|
|||
Raises |
|||
------- |
|||
ValueError |
|||
If the prompt option was created manually. |
|||
""" |
|||
if self._guild is None: |
|||
raise ValueError('This prompt does not have an associated guild because it was created manually.') |
|||
return self._guild |
|||
|
|||
@cached_slot_property('_cs_channels') |
|||
def channels(self) -> List[Union[GuildChannel, Thread]]: |
|||
"""List[Union[:class:`abc.GuildChannel`, :class:`Thread`]]: The list of channels which will be made visible if this option is selected. |
|||
|
|||
Raises |
|||
------- |
|||
ValueError |
|||
IF the prompt option is manually created, therefore has no guild. |
|||
""" |
|||
it = filter(None, map(self.guild._resolve_channel, self.channel_ids)) |
|||
return utils._unique(it) |
|||
|
|||
@cached_slot_property('_cs_roles') |
|||
def roles(self) -> List[Role]: |
|||
"""List[:class:`Role`]: The list of roles given to the user if this option is selected. |
|||
|
|||
Raises |
|||
------- |
|||
ValueError |
|||
If the prompt option is manually created, therefore has no guild. |
|||
""" |
|||
it = filter(None, map(self.guild.get_role, self.role_ids)) |
|||
return utils._unique(it) |
|||
|
|||
|
|||
class OnboardingPrompt: |
|||
"""Represents a onboarding prompt. |
|||
|
|||
This can be manually created for :meth:`Guild.edit_onboarding`. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Parameters |
|||
----------- |
|||
type: :class:`OnboardingPromptType` |
|||
The type of this prompt. |
|||
title: :class:`str` |
|||
The title of this prompt. |
|||
options: List[:class:`OnboardingPromptOption`] |
|||
The options of this prompt. |
|||
single_select: :class:`bool` |
|||
Whether this prompt is single select. |
|||
Defaults to ``True``. |
|||
required: :class:`bool` |
|||
Whether this prompt is required. |
|||
Defaults to ``True``. |
|||
in_onboarding: :class:`bool` |
|||
Whether this prompt is in the onboarding flow. |
|||
Defaults to ``True``. |
|||
|
|||
Attributes |
|||
----------- |
|||
id: :class:`int` |
|||
The ID of this prompt. If this was manually created then the ID will be ``0``. |
|||
type: :class:`OnboardingPromptType` |
|||
The type of this prompt. |
|||
title: :class:`str` |
|||
The title of this prompt. |
|||
options: List[:class:`OnboardingPromptOption`] |
|||
The options of this prompt. |
|||
single_select: :class:`bool` |
|||
Whether this prompt is single select. |
|||
required: :class:`bool` |
|||
Whether this prompt is required. |
|||
in_onboarding: :class:`bool` |
|||
Whether this prompt is in the onboarding flow. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'id', |
|||
'type', |
|||
'title', |
|||
'options', |
|||
'single_select', |
|||
'required', |
|||
'in_onboarding', |
|||
'_guild', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
type: OnboardingPromptType, |
|||
title: str, |
|||
options: List[OnboardingPromptOption], |
|||
single_select: bool = True, |
|||
required: bool = True, |
|||
in_onboarding: bool = True, |
|||
) -> None: |
|||
self.id: int = 0 |
|||
self.type: OnboardingPromptType = type |
|||
self.title: str = title |
|||
self.options: List[OnboardingPromptOption] = options |
|||
self.single_select: bool = single_select |
|||
self.required: bool = required |
|||
self.in_onboarding: bool = in_onboarding |
|||
|
|||
self._guild: Optional[Guild] = None |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<OnboardingPrompt id={self.id!r} title={self.title!r}, type={self.type!r}>' |
|||
|
|||
@classmethod |
|||
def from_dict(cls, *, data: PromptPayload, state: ConnectionState, guild: Guild) -> Self: |
|||
instance = cls( |
|||
type=try_enum(OnboardingPromptType, data['type']), |
|||
title=data['title'], |
|||
options=[ |
|||
OnboardingPromptOption.from_dict(data=option_data, state=state, guild=guild) # type: ignore |
|||
for option_data in data['options'] |
|||
], |
|||
single_select=data['single_select'], |
|||
required=data['required'], |
|||
in_onboarding=data['in_onboarding'], |
|||
) |
|||
instance.id = int(data['id']) |
|||
return instance |
|||
|
|||
def to_dict(self, *, id: int) -> PromptPayload: |
|||
return { |
|||
'id': id, |
|||
'type': self.type.value, |
|||
'title': self.title, |
|||
'options': [option.to_dict() for option in self.options], |
|||
'single_select': self.single_select, |
|||
'required': self.required, |
|||
'in_onboarding': self.in_onboarding, |
|||
} |
|||
|
|||
@property |
|||
def guild(self) -> Guild: |
|||
""":class:`Guild`: The guild this prompt is related to. |
|||
|
|||
Raises |
|||
------ |
|||
ValueError |
|||
If the prompt was created manually. |
|||
""" |
|||
if self._guild is None: |
|||
raise ValueError('This prompt does not have an associated guild because it was created manually.') |
|||
return self._guild |
|||
|
|||
def get_option(self, option_id: int, /) -> Optional[OnboardingPromptOption]: |
|||
"""Optional[:class:`OnboardingPromptOption`]: The option with the given ID, if found.""" |
|||
return next((option for option in self.options if option.id == option_id), None) |
|||
|
|||
|
|||
class Onboarding: |
|||
"""Represents a guild's onboarding configuration. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Attributes |
|||
----------- |
|||
guild: :class:`Guild` |
|||
The guild the onboarding configuration is for. |
|||
prompts: List[:class:`OnboardingPrompt`] |
|||
The list of prompts shown during the onboarding and customize community flows. |
|||
default_channel_ids: Set[:class:`int`] |
|||
The IDs of the channels exposed to a new user by default. |
|||
enabled: :class:`bool`: |
|||
Whether onboarding is enabled in this guild. |
|||
mode: :class:`OnboardingMode` |
|||
The mode of onboarding for this guild. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'_state', |
|||
'_cs_default_channels', |
|||
'guild', |
|||
'prompts', |
|||
'default_channel_ids', |
|||
'enabled', |
|||
'mode', |
|||
) |
|||
|
|||
def __init__(self, *, data: OnboardingPayload, guild: Guild, state: ConnectionState) -> None: |
|||
self._state: ConnectionState = state |
|||
self.guild: Guild = guild |
|||
self.default_channel_ids: Set[int] = {int(channel_id) for channel_id in data['default_channel_ids']} |
|||
self.prompts: List[OnboardingPrompt] = [ |
|||
OnboardingPrompt.from_dict(data=prompt_data, state=state, guild=guild) for prompt_data in data['prompts'] |
|||
] |
|||
self.enabled: bool = data['enabled'] |
|||
self.mode: OnboardingMode = try_enum(OnboardingMode, data.get('mode', 0)) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<Onboarding guild={self.guild!r} enabled={self.enabled!r} mode={self.mode!r}>' |
|||
|
|||
@cached_slot_property('_cs_default_channels') |
|||
def default_channels(self) -> List[Union[GuildChannel, Thread]]: |
|||
"""List[Union[:class:`abc.GuildChannel`, :class:`Thread`]]: The list of channels exposed to a new user by default.""" |
|||
it = filter(None, map(self.guild._resolve_channel, self.default_channel_ids)) |
|||
return utils._unique(it) |
|||
|
|||
def get_prompt(self, prompt_id: int, /) -> Optional[OnboardingPrompt]: |
|||
"""Optional[:class:`OnboardingPrompt`]: The prompt with the given ID, if found.""" |
|||
return next((prompt for prompt in self.prompts if prompt.id == prompt_id), None) |
|||
@ -0,0 +1,72 @@ |
|||
""" |
|||
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, Literal, Optional, TypedDict, List, Union |
|||
|
|||
from .emoji import PartialEmoji |
|||
from .snowflake import Snowflake |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import NotRequired |
|||
|
|||
|
|||
PromptType = Literal[0, 1] |
|||
OnboardingMode = Literal[0, 1] |
|||
|
|||
|
|||
class _PromptOption(TypedDict): |
|||
channel_ids: List[Snowflake] |
|||
role_ids: List[Snowflake] |
|||
title: str |
|||
description: Optional[str] |
|||
|
|||
|
|||
class CreatePromptOption(_PromptOption): |
|||
emoji_id: NotRequired[Snowflake] |
|||
emoji_name: NotRequired[str] |
|||
emoji_animated: NotRequired[bool] |
|||
|
|||
|
|||
class PromptOption(_PromptOption): |
|||
id: Snowflake |
|||
emoji: NotRequired[PartialEmoji] |
|||
|
|||
|
|||
class Prompt(TypedDict): |
|||
id: Snowflake |
|||
options: List[Union[PromptOption, CreatePromptOption]] |
|||
title: str |
|||
single_select: bool |
|||
required: bool |
|||
in_onboarding: bool |
|||
type: PromptType |
|||
|
|||
|
|||
class Onboarding(TypedDict): |
|||
guild_id: Snowflake |
|||
prompts: List[Prompt] |
|||
default_channel_ids: List[Snowflake] |
|||
enabled: bool |
|||
mode: OnboardingMode |
|||
@ -0,0 +1,588 @@ |
|||
""" |
|||
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, |
|||
Callable, |
|||
ClassVar, |
|||
Coroutine, |
|||
Dict, |
|||
Generator, |
|||
List, |
|||
Literal, |
|||
Optional, |
|||
Sequence, |
|||
Type, |
|||
TypeVar, |
|||
Union, |
|||
overload, |
|||
) |
|||
|
|||
from .item import Item, ContainedItemCallbackType as ItemCallbackType |
|||
from .button import Button, button as _button |
|||
from .select import select as _select, Select, UserSelect, RoleSelect, ChannelSelect, MentionableSelect |
|||
from ..components import ActionRow as ActionRowComponent |
|||
from ..enums import ButtonStyle, ComponentType, ChannelType |
|||
from ..partial_emoji import PartialEmoji |
|||
from ..utils import MISSING, get as _utils_get |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .view import LayoutView |
|||
from .select import ( |
|||
BaseSelectT, |
|||
ValidDefaultValues, |
|||
MentionableSelectT, |
|||
ChannelSelectT, |
|||
RoleSelectT, |
|||
UserSelectT, |
|||
SelectT, |
|||
) |
|||
from ..emoji import Emoji |
|||
from ..components import SelectOption |
|||
from ..interactions import Interaction |
|||
from .container import Container |
|||
|
|||
SelectCallbackDecorator = Callable[[ItemCallbackType['S', BaseSelectT]], BaseSelectT] |
|||
|
|||
S = TypeVar('S', bound=Union['ActionRow', 'Container', 'LayoutView'], covariant=True) |
|||
V = TypeVar('V', bound='LayoutView', covariant=True) |
|||
|
|||
__all__ = ('ActionRow',) |
|||
|
|||
|
|||
class _ActionRowCallback: |
|||
__slots__ = ('row', 'callback', 'item') |
|||
|
|||
def __init__(self, callback: ItemCallbackType[S, Any], row: ActionRow, item: Item[Any]) -> None: |
|||
self.callback: ItemCallbackType[Any, Any] = callback |
|||
self.row: ActionRow = row |
|||
self.item: Item[Any] = item |
|||
|
|||
def __call__(self, interaction: Interaction) -> Coroutine[Any, Any, Any]: |
|||
return self.callback(self.row, interaction, self.item) |
|||
|
|||
|
|||
class ActionRow(Item[V]): |
|||
r"""Represents a UI action row. |
|||
|
|||
This is a top-level layout component that can only be used on :class:`LayoutView` |
|||
and can contain :class:`Button`\s and :class:`Select`\s in it. |
|||
|
|||
Action rows can only have 5 children. This can be inherited. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Examples |
|||
-------- |
|||
|
|||
.. code-block:: python3 |
|||
|
|||
import discord |
|||
from discord import ui |
|||
|
|||
# you can subclass it and add components with the decorators |
|||
class MyActionRow(ui.ActionRow): |
|||
@ui.button(label='Click Me!') |
|||
async def click_me(self, interaction: discord.Interaction, button: discord.ui.Button): |
|||
await interaction.response.send_message('You clicked me!') |
|||
|
|||
# or use it directly on LayoutView |
|||
class MyView(ui.LayoutView): |
|||
row = ui.ActionRow() |
|||
# or you can use your subclass: |
|||
# row = MyActionRow() |
|||
|
|||
# you can add items with row.button and row.select |
|||
@row.button(label='A button!') |
|||
async def row_button(self, interaction: discord.Interaction, button: discord.ui.Button): |
|||
await interaction.response.send_message('You clicked a button!') |
|||
|
|||
Parameters |
|||
---------- |
|||
\*children: :class:`Item` |
|||
The initial children of this action row. |
|||
id: Optional[:class:`int`] |
|||
The ID of this component. This must be unique across the view. |
|||
""" |
|||
|
|||
__action_row_children_items__: ClassVar[List[ItemCallbackType[Self, Any]]] = [] |
|||
__discord_ui_action_row__: ClassVar[bool] = True |
|||
__item_repr_attributes__ = ('id',) |
|||
|
|||
def __init__( |
|||
self, |
|||
*children: Item[V], |
|||
id: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
self._children: List[Item[V]] = self._init_children() |
|||
self._children.extend(children) |
|||
self._weight: int = sum(i.width for i in self._children) |
|||
|
|||
if self._weight > 5: |
|||
raise ValueError('maximum number of children exceeded') |
|||
|
|||
self.id = id |
|||
|
|||
def __init_subclass__(cls) -> None: |
|||
super().__init_subclass__() |
|||
|
|||
children: Dict[str, ItemCallbackType[Self, Any]] = {} |
|||
for base in reversed(cls.__mro__): |
|||
for name, member in base.__dict__.items(): |
|||
if hasattr(member, '__discord_ui_model_type__'): |
|||
children[name] = member |
|||
|
|||
if len(children) > 5: |
|||
raise TypeError('ActionRow cannot have more than 5 children') |
|||
|
|||
cls.__action_row_children_items__ = list(children.values()) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} children={len(self._children)}>' |
|||
|
|||
def _init_children(self) -> List[Item[Any]]: |
|||
children = [] |
|||
|
|||
for func in self.__action_row_children_items__: |
|||
item: Item = func.__discord_ui_model_type__(**func.__discord_ui_model_kwargs__) |
|||
item.callback = _ActionRowCallback(func, self, item) # type: ignore |
|||
item._parent = getattr(func, '__discord_ui_parent__', self) |
|||
setattr(self, func.__name__, item) |
|||
children.append(item) |
|||
return children |
|||
|
|||
def _update_view(self, view) -> None: |
|||
self._view = view |
|||
for child in self._children: |
|||
child._view = view |
|||
|
|||
def _has_children(self): |
|||
return True |
|||
|
|||
def _is_v2(self) -> bool: |
|||
# although it is not really a v2 component the only usecase here is for |
|||
# LayoutView which basically represents the top-level payload of components |
|||
# and ActionRow is only allowed there anyways. |
|||
# If the user tries to add any V2 component to a View instead of LayoutView |
|||
# it should error anyways. |
|||
return True |
|||
|
|||
@property |
|||
def width(self): |
|||
return 5 |
|||
|
|||
@property |
|||
def type(self) -> Literal[ComponentType.action_row]: |
|||
return ComponentType.action_row |
|||
|
|||
@property |
|||
def children(self) -> List[Item[V]]: |
|||
"""List[:class:`Item`]: The list of children attached to this action row.""" |
|||
return self._children.copy() |
|||
|
|||
def walk_children(self) -> Generator[Item[V], Any, None]: |
|||
"""An iterator that recursively walks through all the children of this action row |
|||
and its children, if applicable. |
|||
|
|||
Yields |
|||
------ |
|||
:class:`Item` |
|||
An item in the action row. |
|||
""" |
|||
|
|||
for child in self.children: |
|||
yield child |
|||
|
|||
def content_length(self) -> int: |
|||
""":class:`int`: Returns the total length of all text content in this action row.""" |
|||
from .text_display import TextDisplay |
|||
|
|||
return sum(len(item.content) for item in self._children if isinstance(item, TextDisplay)) |
|||
|
|||
def add_item(self, item: Item[Any]) -> Self: |
|||
"""Adds an item to this action row. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
|
|||
Parameters |
|||
---------- |
|||
item: :class:`Item` |
|||
The item to add to the action row. |
|||
|
|||
Raises |
|||
------ |
|||
TypeError |
|||
An :class:`Item` was not passed. |
|||
ValueError |
|||
Maximum number of children has been exceeded (5) |
|||
or (40) for the entire view. |
|||
""" |
|||
|
|||
if (self._weight + item.width) > 5: |
|||
raise ValueError('maximum number of children exceeded') |
|||
|
|||
if len(self._children) >= 5: |
|||
raise ValueError('maximum number of children exceeded') |
|||
|
|||
if not isinstance(item, Item): |
|||
raise TypeError(f'expected Item not {item.__class__.__name__}') |
|||
|
|||
if self._view: |
|||
self._view._add_count(1) |
|||
|
|||
item._update_view(self.view) |
|||
item._parent = self |
|||
self._weight += 1 |
|||
self._children.append(item) |
|||
|
|||
return self |
|||
|
|||
def remove_item(self, item: Item[Any]) -> Self: |
|||
"""Removes an item from the action row. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
|
|||
Parameters |
|||
---------- |
|||
item: :class:`Item` |
|||
The item to remove from the action row. |
|||
""" |
|||
|
|||
try: |
|||
self._children.remove(item) |
|||
except ValueError: |
|||
pass |
|||
else: |
|||
if self._view: |
|||
self._view._add_count(-1) |
|||
self._weight -= 1 |
|||
|
|||
return self |
|||
|
|||
def find_item(self, id: int, /) -> Optional[Item[V]]: |
|||
"""Gets an item with :attr:`Item.id` set as ``id``, or ``None`` if |
|||
not found. |
|||
|
|||
.. warning:: |
|||
|
|||
This is **not the same** as ``custom_id``. |
|||
|
|||
Parameters |
|||
---------- |
|||
id: :class:`int` |
|||
The ID of the component. |
|||
|
|||
Returns |
|||
------- |
|||
Optional[:class:`Item`] |
|||
The item found, or ``None``. |
|||
""" |
|||
return _utils_get(self.walk_children(), id=id) |
|||
|
|||
def clear_items(self) -> Self: |
|||
"""Removes all items from the action row. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
""" |
|||
if self._view: |
|||
self._view._add_count(-len(self._children)) |
|||
self._children.clear() |
|||
self._weight = 0 |
|||
return self |
|||
|
|||
def to_component_dict(self) -> Dict[str, Any]: |
|||
components = [] |
|||
for component in self.children: |
|||
components.append(component.to_component_dict()) |
|||
|
|||
base = { |
|||
'type': self.type.value, |
|||
'components': components, |
|||
} |
|||
if self.id is not None: |
|||
base['id'] = self.id |
|||
return base |
|||
|
|||
def button( |
|||
self, |
|||
*, |
|||
label: Optional[str] = None, |
|||
custom_id: Optional[str] = None, |
|||
disabled: bool = False, |
|||
style: ButtonStyle = ButtonStyle.secondary, |
|||
emoji: Optional[Union[str, Emoji, PartialEmoji]] = None, |
|||
id: Optional[int] = None, |
|||
) -> Callable[[ItemCallbackType[S, Button[V]]], Button[V]]: |
|||
"""A decorator that attaches a button to the action row. |
|||
|
|||
The function being decorated should have three parameters, ``self`` representing |
|||
the :class:`discord.ui.ActionRow`, the :class:`discord.Interaction` you receive and |
|||
the :class:`discord.ui.Button` being pressed. |
|||
.. note:: |
|||
|
|||
Buttons with a URL or a SKU cannot be created with this function. |
|||
Consider creating a :class:`Button` manually and adding it via |
|||
:meth:`ActionRow.add_item` instead. This is beacuse these buttons |
|||
cannot have a callback associated with them since Discord does not |
|||
do any processing with them. |
|||
|
|||
Parameters |
|||
---------- |
|||
label: Optional[:class:`str`] |
|||
The label of the button, if any. |
|||
Can only be up to 80 characters. |
|||
custom_id: Optional[:class:`str`] |
|||
The ID of the button that gets received during an interaction. |
|||
It is recommended to not set this parameters to prevent conflicts. |
|||
Can only be up to 100 characters. |
|||
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`. |
|||
id: Optional[:class:`int`] |
|||
The ID of the component. This must be unique across the view. |
|||
|
|||
.. versionadded:: 2.6 |
|||
""" |
|||
|
|||
def decorator(func: ItemCallbackType[S, Button[V]]) -> ItemCallbackType[S, Button[V]]: |
|||
ret = _button( |
|||
label=label, |
|||
custom_id=custom_id, |
|||
disabled=disabled, |
|||
style=style, |
|||
emoji=emoji, |
|||
row=None, |
|||
id=id, |
|||
)(func) |
|||
ret.__discord_ui_parent__ = self # type: ignore |
|||
return ret # type: ignore |
|||
|
|||
return decorator # type: ignore |
|||
|
|||
@overload |
|||
def select( |
|||
self, |
|||
*, |
|||
cls: Type[SelectT] = Select[Any], |
|||
options: List[SelectOption] = MISSING, |
|||
channel_types: List[ChannelType] = ..., |
|||
placeholder: Optional[str] = ..., |
|||
custom_id: str = ..., |
|||
min_values: int = ..., |
|||
max_values: int = ..., |
|||
disabled: bool = ..., |
|||
id: Optional[int] = ..., |
|||
) -> SelectCallbackDecorator[S, SelectT]: ... |
|||
|
|||
@overload |
|||
def select( |
|||
self, |
|||
*, |
|||
cls: Type[UserSelectT] = UserSelect[Any], |
|||
options: List[SelectOption] = MISSING, |
|||
channel_types: List[ChannelType] = ..., |
|||
placeholder: Optional[str] = ..., |
|||
custom_id: str = ..., |
|||
min_values: int = ..., |
|||
max_values: int = ..., |
|||
disabled: bool = ..., |
|||
default_values: Sequence[ValidDefaultValues] = ..., |
|||
id: Optional[int] = ..., |
|||
) -> SelectCallbackDecorator[S, UserSelectT]: ... |
|||
|
|||
@overload |
|||
def select( |
|||
self, |
|||
*, |
|||
cls: Type[RoleSelectT] = RoleSelect[Any], |
|||
options: List[SelectOption] = MISSING, |
|||
channel_types: List[ChannelType] = ..., |
|||
placeholder: Optional[str] = ..., |
|||
custom_id: str = ..., |
|||
min_values: int = ..., |
|||
max_values: int = ..., |
|||
disabled: bool = ..., |
|||
default_values: Sequence[ValidDefaultValues] = ..., |
|||
id: Optional[int] = ..., |
|||
) -> SelectCallbackDecorator[S, RoleSelectT]: ... |
|||
|
|||
@overload |
|||
def select( |
|||
self, |
|||
*, |
|||
cls: Type[ChannelSelectT] = ChannelSelect[Any], |
|||
options: List[SelectOption] = MISSING, |
|||
channel_types: List[ChannelType] = ..., |
|||
placeholder: Optional[str] = ..., |
|||
custom_id: str = ..., |
|||
min_values: int = ..., |
|||
max_values: int = ..., |
|||
disabled: bool = ..., |
|||
default_values: Sequence[ValidDefaultValues] = ..., |
|||
id: Optional[int] = ..., |
|||
) -> SelectCallbackDecorator[S, ChannelSelectT]: ... |
|||
|
|||
@overload |
|||
def select( |
|||
self, |
|||
*, |
|||
cls: Type[MentionableSelectT] = MentionableSelect[Any], |
|||
options: List[SelectOption] = MISSING, |
|||
channel_types: List[ChannelType] = MISSING, |
|||
placeholder: Optional[str] = ..., |
|||
custom_id: str = ..., |
|||
min_values: int = ..., |
|||
max_values: int = ..., |
|||
disabled: bool = ..., |
|||
default_values: Sequence[ValidDefaultValues] = ..., |
|||
id: Optional[int] = ..., |
|||
) -> SelectCallbackDecorator[S, MentionableSelectT]: ... |
|||
|
|||
def select( |
|||
self, |
|||
*, |
|||
cls: Type[BaseSelectT] = Select[Any], |
|||
options: List[SelectOption] = MISSING, |
|||
channel_types: List[ChannelType] = MISSING, |
|||
placeholder: Optional[str] = None, |
|||
custom_id: str = MISSING, |
|||
min_values: int = 1, |
|||
max_values: int = 1, |
|||
disabled: bool = False, |
|||
default_values: Sequence[ValidDefaultValues] = MISSING, |
|||
id: Optional[int] = None, |
|||
) -> SelectCallbackDecorator[S, BaseSelectT]: |
|||
"""A decorator that attaches a select menu to the action row. |
|||
|
|||
The function being decorated should have three parameters, ``self`` representing |
|||
the :class:`discord.ui.ActionRow`, the :class:`discord.Interaction` you receive and |
|||
the chosen select class. |
|||
|
|||
To obtain the selected values inside the callback, you can use the ``values`` attribute of the chosen class in the callback. The list of values |
|||
will depend on the type of select menu used. View the table below for more information. |
|||
|
|||
+----------------------------------------+-----------------------------------------------------------------------------------------------------------------+ |
|||
| Select Type | Resolved Values | |
|||
+========================================+=================================================================================================================+ |
|||
| :class:`discord.ui.Select` | List[:class:`str`] | |
|||
+----------------------------------------+-----------------------------------------------------------------------------------------------------------------+ |
|||
| :class:`discord.ui.UserSelect` | List[Union[:class:`discord.Member`, :class:`discord.User`]] | |
|||
+----------------------------------------+-----------------------------------------------------------------------------------------------------------------+ |
|||
| :class:`discord.ui.RoleSelect` | List[:class:`discord.Role`] | |
|||
+----------------------------------------+-----------------------------------------------------------------------------------------------------------------+ |
|||
| :class:`discord.ui.MentionableSelect` | List[Union[:class:`discord.Role`, :class:`discord.Member`, :class:`discord.User`]] | |
|||
+----------------------------------------+-----------------------------------------------------------------------------------------------------------------+ |
|||
| :class:`discord.ui.ChannelSelect` | List[Union[:class:`~discord.app_commands.AppCommandChannel`, :class:`~discord.app_commands.AppCommandThread`]] | |
|||
+----------------------------------------+-----------------------------------------------------------------------------------------------------------------+ |
|||
|
|||
Example |
|||
--------- |
|||
.. code-block:: python3 |
|||
|
|||
class MyView(discord.ui.LayoutView): |
|||
action_row = discord.ui.ActionRow() |
|||
|
|||
@action_row.select(cls=ChannelSelect, channel_types=[discord.ChannelType.text]) |
|||
async def select_channels(self, interaction: discord.Interaction, select: ChannelSelect): |
|||
return await interaction.response.send_message(f'You selected {select.values[0].mention}') |
|||
|
|||
Parameters |
|||
------------ |
|||
cls: Union[Type[:class:`discord.ui.Select`], Type[:class:`discord.ui.UserSelect`], Type[:class:`discord.ui.RoleSelect`], \ |
|||
Type[:class:`discord.ui.MentionableSelect`], Type[:class:`discord.ui.ChannelSelect`]] |
|||
The class to use for the select menu. Defaults to :class:`discord.ui.Select`. You can use other |
|||
select types to display different select menus to the user. See the table above for the different |
|||
values you can get from each select type. Subclasses work as well, however the callback in the subclass will |
|||
get overridden. |
|||
placeholder: Optional[:class:`str`] |
|||
The placeholder text that is shown if nothing is selected, if any. |
|||
Can only be up to 150 characters. |
|||
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. |
|||
Can only be up to 100 characters. |
|||
min_values: :class:`int` |
|||
The minimum number of items that must be chosen for this select menu. |
|||
Defaults to 1 and must be between 0 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. This can only be used with |
|||
:class:`Select` instances. |
|||
Can only contain up to 25 items. |
|||
channel_types: List[:class:`~discord.ChannelType`] |
|||
The types of channels to show in the select menu. Defaults to all channels. This can only be used |
|||
with :class:`ChannelSelect` instances. |
|||
disabled: :class:`bool` |
|||
Whether the select is disabled or not. Defaults to ``False``. |
|||
default_values: Sequence[:class:`~discord.abc.Snowflake`] |
|||
A list of objects representing the default values for the select menu. This cannot be used with regular :class:`Select` instances. |
|||
If ``cls`` is :class:`MentionableSelect` and :class:`.Object` is passed, then the type must be specified in the constructor. |
|||
Number of items must be in range of ``min_values`` and ``max_values``. |
|||
id: Optional[:class:`int`] |
|||
The ID of the component. This must be unique across the view. |
|||
|
|||
.. versionadded:: 2.6 |
|||
""" |
|||
|
|||
def decorator(func: ItemCallbackType[S, BaseSelectT]) -> ItemCallbackType[S, BaseSelectT]: |
|||
r = _select( # type: ignore |
|||
cls=cls, # type: ignore |
|||
placeholder=placeholder, |
|||
custom_id=custom_id, |
|||
min_values=min_values, |
|||
max_values=max_values, |
|||
options=options, |
|||
channel_types=channel_types, |
|||
disabled=disabled, |
|||
default_values=default_values, |
|||
id=id, |
|||
)(func) |
|||
r.__discord_ui_parent__ = self |
|||
return r |
|||
|
|||
return decorator # type: ignore |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: ActionRowComponent) -> ActionRow: |
|||
from .view import _component_to_item |
|||
|
|||
self = cls(id=component.id) |
|||
for cmp in component.children: |
|||
self.add_item(_component_to_item(cmp, self)) |
|||
return self |
|||
@ -0,0 +1,375 @@ |
|||
""" |
|||
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 copy |
|||
from typing import ( |
|||
TYPE_CHECKING, |
|||
Any, |
|||
ClassVar, |
|||
Coroutine, |
|||
Dict, |
|||
Generator, |
|||
List, |
|||
Literal, |
|||
Optional, |
|||
TypeVar, |
|||
Union, |
|||
) |
|||
|
|||
from .item import Item, ContainedItemCallbackType as ItemCallbackType |
|||
from .view import _component_to_item, LayoutView |
|||
from ..enums import ComponentType |
|||
from ..utils import get as _utils_get |
|||
from ..colour import Colour, Color |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from ..components import Container as ContainerComponent |
|||
from ..interactions import Interaction |
|||
|
|||
S = TypeVar('S', bound='Container', covariant=True) |
|||
V = TypeVar('V', bound='LayoutView', covariant=True) |
|||
|
|||
__all__ = ('Container',) |
|||
|
|||
|
|||
class _ContainerCallback: |
|||
__slots__ = ('container', 'callback', 'item') |
|||
|
|||
def __init__(self, callback: ItemCallbackType[S, Any], container: Container, item: Item[Any]) -> None: |
|||
self.callback: ItemCallbackType[Any, Any] = callback |
|||
self.container: Container = container |
|||
self.item: Item[Any] = item |
|||
|
|||
def __call__(self, interaction: Interaction) -> Coroutine[Any, Any, Any]: |
|||
return self.callback(self.container, interaction, self.item) |
|||
|
|||
|
|||
class Container(Item[V]): |
|||
r"""Represents a UI container. |
|||
|
|||
This is a top-level layout component that can only be used on :class:`LayoutView` |
|||
and can contain :class:`ActionRow`\s, :class:`TextDisplay`\s, :class:`Section`\s, |
|||
:class:`MediaGallery`\s, :class:`File`\s, and :class:`Separator`\s in it. |
|||
|
|||
This can be inherited. |
|||
|
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Examples |
|||
-------- |
|||
|
|||
.. code-block:: python3 |
|||
|
|||
import discord |
|||
from discord import ui |
|||
|
|||
# you can subclass it and add components as you would add them |
|||
# in a LayoutView |
|||
class MyContainer(ui.Container): |
|||
action_row = ui.ActionRow() |
|||
|
|||
@action_row.button(label='A button in a container!') |
|||
async def a_button(self, interaction: discord.Interaction, button: discord.ui.Button): |
|||
await interaction.response.send_message('You clicked a button!') |
|||
|
|||
# or use it directly on LayoutView |
|||
class MyView(ui.LayoutView): |
|||
container = ui.Container(ui.TextDisplay('I am a text display on a container!')) |
|||
# or you can use your subclass: |
|||
# container = MyContainer() |
|||
|
|||
Parameters |
|||
---------- |
|||
\*children: :class:`Item` |
|||
The initial children of this container. |
|||
accent_colour: Optional[Union[:class:`.Colour`, :class:`int`]] |
|||
The colour of the container. Defaults to ``None``. |
|||
accent_color: Optional[Union[:class:`.Colour`, :class:`int`]] |
|||
The color of the container. Defaults to ``None``. |
|||
spoiler: :class:`bool` |
|||
Whether to flag this container as a spoiler. Defaults |
|||
to ``False``. |
|||
id: Optional[:class:`int`] |
|||
The ID of this component. This must be unique across the view. |
|||
""" |
|||
|
|||
__container_children_items__: ClassVar[Dict[str, Union[ItemCallbackType[Self, Any], Item[Any]]]] = {} |
|||
__discord_ui_container__: ClassVar[bool] = True |
|||
__item_repr_attributes__ = ( |
|||
'accent_colour', |
|||
'spoiler', |
|||
'id', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*children: Item[V], |
|||
accent_colour: Optional[Union[Colour, int]] = None, |
|||
accent_color: Optional[Union[Color, int]] = None, |
|||
spoiler: bool = False, |
|||
id: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
self._children: List[Item[V]] = self._init_children() |
|||
for child in children: |
|||
self.add_item(child) |
|||
|
|||
self.spoiler: bool = spoiler |
|||
self._colour = accent_colour if accent_colour is not None else accent_color |
|||
self.id = id |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} children={len(self._children)}>' |
|||
|
|||
def _init_children(self) -> List[Item[Any]]: |
|||
children = [] |
|||
parents = {} |
|||
|
|||
for name, raw in self.__container_children_items__.items(): |
|||
if isinstance(raw, Item): |
|||
item = raw.copy() |
|||
item._parent = self |
|||
setattr(self, name, item) |
|||
children.append(item) |
|||
parents[raw] = item |
|||
else: |
|||
# action rows can be created inside containers, and then callbacks can exist here |
|||
# so we create items based off them |
|||
item: Item = raw.__discord_ui_model_type__(**raw.__discord_ui_model_kwargs__) |
|||
item.callback = _ContainerCallback(raw, self, item) # type: ignore |
|||
setattr(self, raw.__name__, item) |
|||
# this should not fail because in order for a function to be here it should be from |
|||
# an action row and must have passed the check in __init_subclass__, but still |
|||
# guarding it |
|||
parent = getattr(raw, '__discord_ui_parent__', None) |
|||
if parent is None: |
|||
raise ValueError(f'{raw.__name__} is not a valid item for a Container') |
|||
parents.get(parent, parent)._children.append(item) |
|||
# we do not append it to the children list because technically these buttons and |
|||
# selects are not from the container but the action row itself. |
|||
|
|||
return children |
|||
|
|||
def __init_subclass__(cls) -> None: |
|||
super().__init_subclass__() |
|||
|
|||
children: Dict[str, Union[ItemCallbackType[Self, Any], Item[Any]]] = {} |
|||
for base in reversed(cls.__mro__): |
|||
for name, member in base.__dict__.items(): |
|||
if isinstance(member, Item): |
|||
children[name] = member |
|||
if hasattr(member, '__discord_ui_model_type__') and getattr(member, '__discord_ui_parent__', None): |
|||
children[name] = copy.copy(member) |
|||
|
|||
cls.__container_children_items__ = children |
|||
|
|||
def _update_view(self, view) -> bool: |
|||
self._view = view |
|||
for child in self._children: |
|||
child._update_view(view) |
|||
return True |
|||
|
|||
def _has_children(self): |
|||
return True |
|||
|
|||
@property |
|||
def children(self) -> List[Item[V]]: |
|||
"""List[:class:`Item`]: The children of this container.""" |
|||
return self._children.copy() |
|||
|
|||
@children.setter |
|||
def children(self, value: List[Item[V]]) -> None: |
|||
self._children = value |
|||
|
|||
@property |
|||
def accent_colour(self) -> Optional[Union[Colour, int]]: |
|||
"""Optional[Union[:class:`discord.Colour`, :class:`int`]]: The colour of the container, or ``None``.""" |
|||
return self._colour |
|||
|
|||
@accent_colour.setter |
|||
def accent_colour(self, value: Optional[Union[Colour, int]]) -> None: |
|||
if value is not None and not isinstance(value, (int, Colour)): |
|||
raise TypeError(f'expected an int, or Colour, not {value.__class__.__name__!r}') |
|||
|
|||
self._colour = value |
|||
|
|||
accent_color = accent_colour |
|||
|
|||
@property |
|||
def type(self) -> Literal[ComponentType.container]: |
|||
return ComponentType.container |
|||
|
|||
@property |
|||
def width(self): |
|||
return 5 |
|||
|
|||
def _is_v2(self) -> bool: |
|||
return True |
|||
|
|||
def to_components(self) -> List[Dict[str, Any]]: |
|||
components = [] |
|||
for i in self._children: |
|||
components.append(i.to_component_dict()) |
|||
return components |
|||
|
|||
def to_component_dict(self) -> Dict[str, Any]: |
|||
components = self.to_components() |
|||
|
|||
colour = None |
|||
if self._colour: |
|||
colour = self._colour if isinstance(self._colour, int) else self._colour.value |
|||
|
|||
base = { |
|||
'type': self.type.value, |
|||
'accent_color': colour, |
|||
'spoiler': self.spoiler, |
|||
'components': components, |
|||
} |
|||
if self.id is not None: |
|||
base['id'] = self.id |
|||
return base |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: ContainerComponent) -> Self: |
|||
self = cls( |
|||
accent_colour=component.accent_colour, |
|||
spoiler=component.spoiler, |
|||
id=component.id, |
|||
) |
|||
self._children = [_component_to_item(cmp, self) for cmp in component.children] |
|||
return self |
|||
|
|||
def walk_children(self) -> Generator[Item[V], None, None]: |
|||
"""An iterator that recursively walks through all the children of this container |
|||
and its children, if applicable. |
|||
|
|||
Yields |
|||
------ |
|||
:class:`Item` |
|||
An item in the container. |
|||
""" |
|||
|
|||
for child in self.children: |
|||
yield child |
|||
|
|||
if child._has_children(): |
|||
yield from child.walk_children() # type: ignore |
|||
|
|||
def content_length(self) -> int: |
|||
""":class:`int`: Returns the total length of all text content in this container.""" |
|||
from .text_display import TextDisplay |
|||
|
|||
return sum(len(item.content) for item in self.walk_children() if isinstance(item, TextDisplay)) |
|||
|
|||
def add_item(self, item: Item[Any]) -> Self: |
|||
"""Adds an item to this container. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
|
|||
Parameters |
|||
---------- |
|||
item: :class:`Item` |
|||
The item to append. |
|||
|
|||
Raises |
|||
------ |
|||
TypeError |
|||
An :class:`Item` was not passed. |
|||
ValueError |
|||
Maximum number of children has been exceeded (40) for the entire view. |
|||
""" |
|||
if not isinstance(item, Item): |
|||
raise TypeError(f'expected Item not {item.__class__.__name__}') |
|||
|
|||
if item._has_children() and self._view: |
|||
self._view._add_count(len(tuple(item.walk_children()))) # type: ignore |
|||
elif self._view: |
|||
self._view._add_count(1) |
|||
|
|||
self._children.append(item) |
|||
item._update_view(self.view) |
|||
item._parent = self |
|||
return self |
|||
|
|||
def remove_item(self, item: Item[Any]) -> Self: |
|||
"""Removes an item from this container. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
|
|||
Parameters |
|||
---------- |
|||
item: :class:`Item` |
|||
The item to remove from the container. |
|||
""" |
|||
|
|||
try: |
|||
self._children.remove(item) |
|||
except ValueError: |
|||
pass |
|||
else: |
|||
if self._view: |
|||
if item._has_children(): |
|||
self._view._add_count(-len(tuple(item.walk_children()))) # type: ignore |
|||
else: |
|||
self._view._add_count(-1) |
|||
return self |
|||
|
|||
def find_item(self, id: int, /) -> Optional[Item[V]]: |
|||
"""Gets an item with :attr:`Item.id` set as ``id``, or ``None`` if |
|||
not found. |
|||
|
|||
.. warning:: |
|||
|
|||
This is **not the same** as ``custom_id``. |
|||
|
|||
Parameters |
|||
---------- |
|||
id: :class:`int` |
|||
The ID of the component. |
|||
|
|||
Returns |
|||
------- |
|||
Optional[:class:`Item`] |
|||
The item found, or ``None``. |
|||
""" |
|||
return _utils_get(self.walk_children(), id=id) |
|||
|
|||
def clear_items(self) -> Self: |
|||
"""Removes all the items from the container. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
""" |
|||
|
|||
if self._view: |
|||
self._view._add_count(-len(tuple(self.walk_children()))) |
|||
self._children.clear() |
|||
return self |
|||
@ -0,0 +1,159 @@ |
|||
""" |
|||
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, Literal, Optional, TypeVar, Union |
|||
|
|||
|
|||
from .item import Item |
|||
from ..components import FileComponent, UnfurledMediaItem |
|||
from ..enums import ComponentType |
|||
from ..utils import MISSING |
|||
from ..file import File as SendableFile |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .view import LayoutView |
|||
|
|||
V = TypeVar('V', bound='LayoutView', covariant=True) |
|||
|
|||
__all__ = ('File',) |
|||
|
|||
|
|||
class File(Item[V]): |
|||
"""Represents a UI file component. |
|||
|
|||
This is a top-level layout component that can only be used on :class:`LayoutView`. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Example |
|||
------- |
|||
|
|||
.. code-block:: python3 |
|||
|
|||
import discord |
|||
from discord import ui |
|||
|
|||
class MyView(ui.LayoutView): |
|||
file = ui.File('attachment://file.txt') |
|||
# attachment://file.txt points to an attachment uploaded alongside this view |
|||
|
|||
Parameters |
|||
---------- |
|||
media: Union[:class:`str`, :class:`.UnfurledMediaItem`, :class:`discord.File`] |
|||
This file's media. If this is a string it must point to a local |
|||
file uploaded within the parent view of this item, and must |
|||
meet the ``attachment://<filename>`` format. |
|||
spoiler: :class:`bool` |
|||
Whether to flag this file as a spoiler. Defaults to ``False``. |
|||
id: Optional[:class:`int`] |
|||
The ID of this component. This must be unique across the view. |
|||
""" |
|||
|
|||
__item_repr_attributes__ = ( |
|||
'media', |
|||
'spoiler', |
|||
'id', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
media: Union[str, UnfurledMediaItem, SendableFile], |
|||
*, |
|||
spoiler: bool = MISSING, |
|||
id: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
if isinstance(media, SendableFile): |
|||
self._underlying = FileComponent._raw_construct( |
|||
media=UnfurledMediaItem(media.uri), |
|||
spoiler=media.spoiler if spoiler is MISSING else spoiler, |
|||
id=id, |
|||
) |
|||
else: |
|||
self._underlying = FileComponent._raw_construct( |
|||
media=UnfurledMediaItem(media) if isinstance(media, str) else media, |
|||
spoiler=bool(spoiler), |
|||
id=id, |
|||
) |
|||
self.id = id |
|||
|
|||
def _is_v2(self): |
|||
return True |
|||
|
|||
@property |
|||
def width(self): |
|||
return 5 |
|||
|
|||
@property |
|||
def type(self) -> Literal[ComponentType.file]: |
|||
return self._underlying.type |
|||
|
|||
@property |
|||
def media(self) -> UnfurledMediaItem: |
|||
""":class:`.UnfurledMediaItem`: Returns this file media.""" |
|||
return self._underlying.media |
|||
|
|||
@media.setter |
|||
def media(self, value: Union[str, SendableFile, UnfurledMediaItem]) -> None: |
|||
if isinstance(value, str): |
|||
self._underlying.media = UnfurledMediaItem(value) |
|||
elif isinstance(value, UnfurledMediaItem): |
|||
self._underlying.media = value |
|||
elif isinstance(value, SendableFile): |
|||
self._underlying.media = UnfurledMediaItem(value.uri) |
|||
else: |
|||
raise TypeError(f'expected a str or UnfurledMediaItem or File, not {value.__class__.__name__!r}') |
|||
|
|||
@property |
|||
def url(self) -> str: |
|||
""":class:`str`: Returns this file's url.""" |
|||
return self._underlying.media.url |
|||
|
|||
@url.setter |
|||
def url(self, value: str) -> None: |
|||
self._underlying.media = UnfurledMediaItem(value) |
|||
|
|||
@property |
|||
def spoiler(self) -> bool: |
|||
""":class:`bool`: Returns whether this file should be flagged as a spoiler.""" |
|||
return self._underlying.spoiler |
|||
|
|||
@spoiler.setter |
|||
def spoiler(self, value: bool) -> None: |
|||
self._underlying.spoiler = value |
|||
|
|||
def to_component_dict(self): |
|||
return self._underlying.to_dict() |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: FileComponent) -> Self: |
|||
return cls( |
|||
media=component.media, |
|||
spoiler=component.spoiler, |
|||
id=component.id, |
|||
) |
|||
@ -0,0 +1,140 @@ |
|||
""" |
|||
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, Generator, Literal, Optional, Tuple, TypeVar |
|||
|
|||
from ..components import LabelComponent |
|||
from ..enums import ComponentType |
|||
from ..utils import MISSING |
|||
from .item import Item |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from ..types.components import LabelComponent as LabelComponentPayload |
|||
from .view import View |
|||
|
|||
|
|||
# fmt: off |
|||
__all__ = ( |
|||
'Label', |
|||
) |
|||
# fmt: on |
|||
|
|||
V = TypeVar('V', bound='View', covariant=True) |
|||
|
|||
|
|||
class Label(Item[V]): |
|||
"""Represents a UI label within a modal. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Parameters |
|||
------------ |
|||
text: :class:`str` |
|||
The text to display above the input field. |
|||
Can only be up to 45 characters. |
|||
description: Optional[:class:`str`] |
|||
The description text to display right below the label text. |
|||
Can only be up to 100 characters. |
|||
component: Union[:class:`discord.ui.TextInput`, :class:`discord.ui.Select`] |
|||
The component to display below the label. |
|||
id: Optional[:class:`int`] |
|||
The ID of the component. This must be unique across the view. |
|||
|
|||
Attributes |
|||
------------ |
|||
text: :class:`str` |
|||
The text to display above the input field. |
|||
Can only be up to 45 characters. |
|||
description: Optional[:class:`str`] |
|||
The description text to display right below the label text. |
|||
Can only be up to 100 characters. |
|||
component: :class:`Item` |
|||
The component to display below the label. Currently only |
|||
supports :class:`TextInput` and :class:`Select`. |
|||
""" |
|||
|
|||
__item_repr_attributes__: Tuple[str, ...] = ( |
|||
'text', |
|||
'description', |
|||
'component', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
text: str, |
|||
component: Item[V], |
|||
description: Optional[str] = None, |
|||
id: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
self.component: Item[V] = component |
|||
self.text: str = text |
|||
self.description: Optional[str] = description |
|||
self.id = id |
|||
|
|||
@property |
|||
def width(self) -> int: |
|||
return 5 |
|||
|
|||
def _has_children(self) -> bool: |
|||
return True |
|||
|
|||
def walk_children(self) -> Generator[Item[V], None, None]: |
|||
yield self.component |
|||
|
|||
def to_component_dict(self) -> LabelComponentPayload: |
|||
payload: LabelComponentPayload = { |
|||
'type': ComponentType.label.value, |
|||
'label': self.text, |
|||
'component': self.component.to_component_dict(), # type: ignore |
|||
} |
|||
if self.description: |
|||
payload['description'] = self.description |
|||
if self.id is not None: |
|||
payload['id'] = self.id |
|||
return payload |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: LabelComponent) -> Self: |
|||
from .view import _component_to_item |
|||
|
|||
self = cls( |
|||
text=component.label, |
|||
component=MISSING, |
|||
description=component.description, |
|||
) |
|||
self.component = _component_to_item(component.component, self) |
|||
return self |
|||
|
|||
@property |
|||
def type(self) -> Literal[ComponentType.label]: |
|||
return ComponentType.label |
|||
|
|||
def is_dispatchable(self) -> bool: |
|||
return False |
|||
@ -0,0 +1,263 @@ |
|||
""" |
|||
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, List, Literal, Optional, TypeVar, Union |
|||
|
|||
from .item import Item |
|||
from ..enums import ComponentType |
|||
from ..utils import MISSING |
|||
from ..file import File |
|||
from ..components import ( |
|||
MediaGalleryItem, |
|||
MediaGalleryComponent, |
|||
UnfurledMediaItem, |
|||
) |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .view import LayoutView |
|||
|
|||
V = TypeVar('V', bound='LayoutView', covariant=True) |
|||
|
|||
__all__ = ('MediaGallery',) |
|||
|
|||
|
|||
class MediaGallery(Item[V]): |
|||
r"""Represents a UI media gallery. |
|||
|
|||
Can contain up to 10 :class:`.MediaGalleryItem`\s. |
|||
|
|||
This is a top-level layout component that can only be used on :class:`LayoutView`. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Parameters |
|||
---------- |
|||
\*items: :class:`.MediaGalleryItem` |
|||
The initial items of this gallery. |
|||
id: Optional[:class:`int`] |
|||
The ID of this component. This must be unique across the view. |
|||
""" |
|||
|
|||
__item_repr_attributes__ = ( |
|||
'items', |
|||
'id', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*items: MediaGalleryItem, |
|||
id: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
|
|||
self._underlying = MediaGalleryComponent._raw_construct( |
|||
items=list(items), |
|||
id=id, |
|||
) |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} items={len(self._underlying.items)}>' |
|||
|
|||
@property |
|||
def items(self) -> List[MediaGalleryItem]: |
|||
"""List[:class:`.MediaGalleryItem`]: Returns a read-only list of this gallery's items.""" |
|||
return self._underlying.items.copy() |
|||
|
|||
@items.setter |
|||
def items(self, value: List[MediaGalleryItem]) -> None: |
|||
if len(value) > 10: |
|||
raise ValueError('media gallery only accepts up to 10 items') |
|||
|
|||
self._underlying.items = value |
|||
|
|||
@property |
|||
def id(self) -> Optional[int]: |
|||
"""Optional[:class:`int`]: The ID of this component.""" |
|||
return self._underlying.id |
|||
|
|||
@id.setter |
|||
def id(self, value: Optional[int]) -> None: |
|||
self._underlying.id = value |
|||
|
|||
def to_component_dict(self): |
|||
return self._underlying.to_dict() |
|||
|
|||
def _is_v2(self) -> bool: |
|||
return True |
|||
|
|||
def add_item( |
|||
self, |
|||
*, |
|||
media: Union[str, File, UnfurledMediaItem], |
|||
description: Optional[str] = MISSING, |
|||
spoiler: bool = MISSING, |
|||
) -> Self: |
|||
"""Adds an item to this gallery. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
|
|||
Parameters |
|||
---------- |
|||
media: Union[:class:`str`, :class:`discord.File`, :class:`.UnfurledMediaItem`] |
|||
The media item data. This can be a string representing a local |
|||
file uploaded as an attachment in the message, which can be accessed |
|||
using the ``attachment://<filename>`` format, or an arbitrary url. |
|||
description: Optional[:class:`str`] |
|||
The description to show within this item. Up to 256 characters. Defaults |
|||
to ``None``. |
|||
spoiler: :class:`bool` |
|||
Whether this item should be flagged as a spoiler. Defaults to ``False``. |
|||
|
|||
Raises |
|||
------ |
|||
ValueError |
|||
Maximum number of items has been exceeded (10). |
|||
""" |
|||
|
|||
if len(self._underlying.items) >= 10: |
|||
raise ValueError('maximum number of items has been exceeded') |
|||
|
|||
item = MediaGalleryItem(media, description=description, spoiler=spoiler) |
|||
self._underlying.items.append(item) |
|||
return self |
|||
|
|||
def append_item(self, item: MediaGalleryItem) -> Self: |
|||
"""Appends an item to this gallery. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
|
|||
Parameters |
|||
---------- |
|||
item: :class:`.MediaGalleryItem` |
|||
The item to add to the gallery. |
|||
|
|||
Raises |
|||
------ |
|||
TypeError |
|||
A :class:`.MediaGalleryItem` was not passed. |
|||
ValueError |
|||
Maximum number of items has been exceeded (10). |
|||
""" |
|||
|
|||
if len(self._underlying.items) >= 10: |
|||
raise ValueError('maximum number of items has been exceeded') |
|||
|
|||
if not isinstance(item, MediaGalleryItem): |
|||
raise TypeError(f'expected MediaGalleryItem, not {item.__class__.__name__!r}') |
|||
|
|||
self._underlying.items.append(item) |
|||
return self |
|||
|
|||
def insert_item_at( |
|||
self, |
|||
index: int, |
|||
*, |
|||
media: Union[str, File, UnfurledMediaItem], |
|||
description: Optional[str] = MISSING, |
|||
spoiler: bool = MISSING, |
|||
) -> Self: |
|||
"""Inserts an item before a specified index to the media gallery. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
|
|||
Parameters |
|||
---------- |
|||
index: :class:`int` |
|||
The index of where to insert the field. |
|||
media: Union[:class:`str`, :class:`discord.File`, :class:`.UnfurledMediaItem`] |
|||
The media item data. This can be a string representing a local |
|||
file uploaded as an attachment in the message, which can be accessed |
|||
using the ``attachment://<filename>`` format, or an arbitrary url. |
|||
description: Optional[:class:`str`] |
|||
The description to show within this item. Up to 256 characters. Defaults |
|||
to ``None``. |
|||
spoiler: :class:`bool` |
|||
Whether this item should be flagged as a spoiler. Defaults to ``False``. |
|||
|
|||
Raises |
|||
------ |
|||
ValueError |
|||
Maximum number of items has been exceeded (10). |
|||
""" |
|||
|
|||
if len(self._underlying.items) >= 10: |
|||
raise ValueError('maximum number of items has been exceeded') |
|||
|
|||
item = MediaGalleryItem( |
|||
media, |
|||
description=description, |
|||
spoiler=spoiler, |
|||
) |
|||
self._underlying.items.insert(index, item) |
|||
return self |
|||
|
|||
def remove_item(self, item: MediaGalleryItem) -> Self: |
|||
"""Removes an item from the gallery. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
|
|||
Parameters |
|||
---------- |
|||
item: :class:`.MediaGalleryItem` |
|||
The item to remove from the gallery. |
|||
""" |
|||
|
|||
try: |
|||
self._underlying.items.remove(item) |
|||
except ValueError: |
|||
pass |
|||
return self |
|||
|
|||
def clear_items(self) -> Self: |
|||
"""Removes all items from the gallery. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
""" |
|||
|
|||
self._underlying.items.clear() |
|||
return self |
|||
|
|||
@property |
|||
def type(self) -> Literal[ComponentType.media_gallery]: |
|||
return self._underlying.type |
|||
|
|||
@property |
|||
def width(self): |
|||
return 5 |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: MediaGalleryComponent) -> Self: |
|||
return cls( |
|||
*component.items, |
|||
id=component.id, |
|||
) |
|||
@ -0,0 +1,261 @@ |
|||
""" |
|||
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, Generator, List, Literal, Optional, TypeVar, Union, ClassVar |
|||
|
|||
from .item import Item |
|||
from .text_display import TextDisplay |
|||
from ..enums import ComponentType |
|||
from ..utils import MISSING, get as _utils_get |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .view import LayoutView |
|||
from ..components import SectionComponent |
|||
|
|||
V = TypeVar('V', bound='LayoutView', covariant=True) |
|||
|
|||
__all__ = ('Section',) |
|||
|
|||
|
|||
class Section(Item[V]): |
|||
r"""Represents a UI section. |
|||
|
|||
This is a top-level layout component that can only be used on :class:`LayoutView`. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Parameters |
|||
---------- |
|||
\*children: Union[:class:`str`, :class:`TextDisplay`] |
|||
The text displays of this section. Up to 3. |
|||
accessory: :class:`Item` |
|||
The section accessory. |
|||
id: Optional[:class:`int`] |
|||
The ID of this component. This must be unique across the view. |
|||
|
|||
Attributes |
|||
---------- |
|||
accessory: :class:`Item` |
|||
The section accessory. |
|||
""" |
|||
|
|||
__item_repr_attributes__ = ( |
|||
'accessory', |
|||
'id', |
|||
) |
|||
__discord_ui_section__: ClassVar[bool] = True |
|||
|
|||
__slots__ = ( |
|||
'_children', |
|||
'accessory', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*children: Union[Item[V], str], |
|||
accessory: Item[V], |
|||
id: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
self._children: List[Item[V]] = [] |
|||
if children: |
|||
if len(children) > 3: |
|||
raise ValueError('maximum number of children exceeded') |
|||
self._children.extend( |
|||
[c if isinstance(c, Item) else TextDisplay(c) for c in children], |
|||
) |
|||
self.accessory: Item[V] = accessory |
|||
self.id = id |
|||
|
|||
def __repr__(self) -> str: |
|||
return f'<{self.__class__.__name__} children={len(self._children)}>' |
|||
|
|||
@property |
|||
def type(self) -> Literal[ComponentType.section]: |
|||
return ComponentType.section |
|||
|
|||
@property |
|||
def children(self) -> List[Item[V]]: |
|||
"""List[:class:`Item`]: The list of children attached to this section.""" |
|||
return self._children.copy() |
|||
|
|||
@property |
|||
def width(self): |
|||
return 5 |
|||
|
|||
def _is_v2(self) -> bool: |
|||
return True |
|||
|
|||
def walk_children(self) -> Generator[Item[V], None, None]: |
|||
"""An iterator that recursively walks through all the children of this section |
|||
and its children, if applicable. This includes the `accessory`. |
|||
|
|||
Yields |
|||
------ |
|||
:class:`Item` |
|||
An item in this section. |
|||
""" |
|||
|
|||
for child in self.children: |
|||
yield child |
|||
yield self.accessory |
|||
|
|||
def _update_view(self, view) -> None: |
|||
self._view = view |
|||
self.accessory._view = view |
|||
for child in self._children: |
|||
child._view = view |
|||
|
|||
def _has_children(self): |
|||
return True |
|||
|
|||
def content_length(self) -> int: |
|||
""":class:`int`: Returns the total length of all text content in this section.""" |
|||
from .text_display import TextDisplay |
|||
|
|||
return sum(len(item.content) for item in self._children if isinstance(item, TextDisplay)) |
|||
|
|||
def add_item(self, item: Union[str, Item[Any]]) -> Self: |
|||
"""Adds an item to this section. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
|
|||
Parameters |
|||
---------- |
|||
item: Union[:class:`str`, :class:`Item`] |
|||
The item to append, if it is a string it automatically wrapped around |
|||
:class:`TextDisplay`. |
|||
|
|||
Raises |
|||
------ |
|||
TypeError |
|||
An :class:`Item` or :class:`str` was not passed. |
|||
ValueError |
|||
Maximum number of children has been exceeded (3) or (40) |
|||
for the entire view. |
|||
""" |
|||
|
|||
if len(self._children) >= 3: |
|||
raise ValueError('maximum number of children exceeded (3)') |
|||
|
|||
if not isinstance(item, (Item, str)): |
|||
raise TypeError(f'expected Item or str not {item.__class__.__name__}') |
|||
|
|||
if self._view: |
|||
self._view._add_count(1) |
|||
|
|||
item = item if isinstance(item, Item) else TextDisplay(item) |
|||
item._update_view(self.view) |
|||
item._parent = self |
|||
self._children.append(item) |
|||
|
|||
return self |
|||
|
|||
def remove_item(self, item: Item[Any]) -> Self: |
|||
"""Removes an item from this section. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
|
|||
Parameters |
|||
---------- |
|||
item: :class:`Item` |
|||
The item to remove from the section. |
|||
""" |
|||
|
|||
try: |
|||
self._children.remove(item) |
|||
except ValueError: |
|||
pass |
|||
else: |
|||
if self._view: |
|||
self._view._add_count(-1) |
|||
|
|||
return self |
|||
|
|||
def find_item(self, id: int, /) -> Optional[Item[V]]: |
|||
"""Gets an item with :attr:`Item.id` set as ``id``, or ``None`` if |
|||
not found. |
|||
|
|||
.. warning:: |
|||
|
|||
This is **not the same** as ``custom_id``. |
|||
|
|||
Parameters |
|||
---------- |
|||
id: :class:`int` |
|||
The ID of the component. |
|||
|
|||
Returns |
|||
------- |
|||
Optional[:class:`Item`] |
|||
The item found, or ``None``. |
|||
""" |
|||
return _utils_get(self.walk_children(), id=id) |
|||
|
|||
def clear_items(self) -> Self: |
|||
"""Removes all the items from the section. |
|||
|
|||
This function returns the class instance to allow for fluent-style |
|||
chaining. |
|||
""" |
|||
if self._view: |
|||
self._view._add_count(-len(self._children)) # we don't count the accessory because it is required |
|||
|
|||
self._children.clear() |
|||
return self |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: SectionComponent) -> Self: |
|||
from .view import _component_to_item |
|||
|
|||
# using MISSING as accessory so we can create the new one with the parent set |
|||
self = cls(id=component.id, accessory=MISSING) |
|||
self.accessory = _component_to_item(component.accessory, self) |
|||
self.id = component.id |
|||
self._children = [_component_to_item(c, self) for c in component.children] |
|||
|
|||
return self |
|||
|
|||
def to_components(self) -> List[Dict[str, Any]]: |
|||
components = [] |
|||
|
|||
for component in self._children: |
|||
components.append(component.to_component_dict()) |
|||
return components |
|||
|
|||
def to_component_dict(self) -> Dict[str, Any]: |
|||
data = { |
|||
'type': self.type.value, |
|||
'components': self.to_components(), |
|||
'accessory': self.accessory.to_component_dict(), |
|||
} |
|||
if self.id is not None: |
|||
data['id'] = self.id |
|||
return data |
|||
@ -0,0 +1,125 @@ |
|||
""" |
|||
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, Literal, Optional, TypeVar |
|||
|
|||
from .item import Item |
|||
from ..components import SeparatorComponent |
|||
from ..enums import SeparatorSpacing, ComponentType |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .view import LayoutView |
|||
|
|||
V = TypeVar('V', bound='LayoutView', covariant=True) |
|||
|
|||
__all__ = ('Separator',) |
|||
|
|||
|
|||
class Separator(Item[V]): |
|||
"""Represents a UI separator. |
|||
|
|||
This is a top-level layout component that can only be used on :class:`LayoutView`. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Parameters |
|||
---------- |
|||
visible: :class:`bool` |
|||
Whether this separator is visible. On the client side this |
|||
is whether a divider line should be shown or not. |
|||
spacing: :class:`.SeparatorSpacing` |
|||
The spacing of this separator. |
|||
id: Optional[:class:`int`] |
|||
The ID of this component. This must be unique across the view. |
|||
""" |
|||
|
|||
__slots__ = ('_underlying',) |
|||
__item_repr_attributes__ = ( |
|||
'visible', |
|||
'spacing', |
|||
'id', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
*, |
|||
visible: bool = True, |
|||
spacing: SeparatorSpacing = SeparatorSpacing.small, |
|||
id: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
self._underlying = SeparatorComponent._raw_construct( |
|||
spacing=spacing, |
|||
visible=visible, |
|||
id=id, |
|||
) |
|||
self.id = id |
|||
|
|||
def _is_v2(self): |
|||
return True |
|||
|
|||
@property |
|||
def visible(self) -> bool: |
|||
""":class:`bool`: Whether this separator is visible. |
|||
|
|||
On the client side this is whether a divider line should |
|||
be shown or not. |
|||
""" |
|||
return self._underlying.visible |
|||
|
|||
@visible.setter |
|||
def visible(self, value: bool) -> None: |
|||
self._underlying.visible = value |
|||
|
|||
@property |
|||
def spacing(self) -> SeparatorSpacing: |
|||
""":class:`.SeparatorSpacing`: The spacing of this separator.""" |
|||
return self._underlying.spacing |
|||
|
|||
@spacing.setter |
|||
def spacing(self, value: SeparatorSpacing) -> None: |
|||
self._underlying.spacing = value |
|||
|
|||
@property |
|||
def width(self): |
|||
return 5 |
|||
|
|||
@property |
|||
def type(self) -> Literal[ComponentType.separator]: |
|||
return self._underlying.type |
|||
|
|||
def to_component_dict(self): |
|||
return self._underlying.to_dict() |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: SeparatorComponent) -> Self: |
|||
return cls( |
|||
visible=component.visible, |
|||
spacing=component.spacing, |
|||
id=component.id, |
|||
) |
|||
@ -0,0 +1,90 @@ |
|||
""" |
|||
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, Literal, Optional, TypeVar |
|||
|
|||
from .item import Item |
|||
from ..components import TextDisplay as TextDisplayComponent |
|||
from ..enums import ComponentType |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .view import LayoutView |
|||
|
|||
V = TypeVar('V', bound='LayoutView', covariant=True) |
|||
|
|||
__all__ = ('TextDisplay',) |
|||
|
|||
|
|||
class TextDisplay(Item[V]): |
|||
"""Represents a UI text display. |
|||
|
|||
This is a top-level layout component that can only be used on :class:`LayoutView` or :class:`Section`. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Parameters |
|||
---------- |
|||
content: :class:`str` |
|||
The content of this text display. Up to 4000 characters. |
|||
id: Optional[:class:`int`] |
|||
The ID of this component. This must be unique across the view. |
|||
""" |
|||
|
|||
__slots__ = ('content',) |
|||
|
|||
def __init__(self, content: str, *, id: Optional[int] = None) -> None: |
|||
super().__init__() |
|||
self.content: str = content |
|||
self.id = id |
|||
|
|||
def to_component_dict(self): |
|||
base = { |
|||
'type': self.type.value, |
|||
'content': self.content, |
|||
} |
|||
if self.id is not None: |
|||
base['id'] = self.id |
|||
return base |
|||
|
|||
@property |
|||
def width(self): |
|||
return 5 |
|||
|
|||
@property |
|||
def type(self) -> Literal[ComponentType.text_display]: |
|||
return ComponentType.text_display |
|||
|
|||
def _is_v2(self) -> bool: |
|||
return True |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: TextDisplayComponent) -> Self: |
|||
return cls( |
|||
content=component.content, |
|||
id=component.id, |
|||
) |
|||
@ -0,0 +1,144 @@ |
|||
""" |
|||
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, Literal, Optional, TypeVar, Union |
|||
|
|||
from .item import Item |
|||
from ..enums import ComponentType |
|||
from ..components import UnfurledMediaItem |
|||
from ..file import File |
|||
from ..utils import MISSING |
|||
|
|||
if TYPE_CHECKING: |
|||
from typing_extensions import Self |
|||
|
|||
from .view import LayoutView |
|||
from ..components import ThumbnailComponent |
|||
|
|||
V = TypeVar('V', bound='LayoutView', covariant=True) |
|||
|
|||
__all__ = ('Thumbnail',) |
|||
|
|||
|
|||
class Thumbnail(Item[V]): |
|||
"""Represents a UI Thumbnail. This currently can only be used as a :class:`Section`\'s accessory. |
|||
|
|||
.. versionadded:: 2.6 |
|||
|
|||
Parameters |
|||
---------- |
|||
media: Union[:class:`str`, :class:`discord.File`, :class:`discord.UnfurledMediaItem`] |
|||
The media of the thumbnail. This can be a URL or a reference |
|||
to an attachment that matches the ``attachment://filename.extension`` |
|||
structure. |
|||
description: Optional[:class:`str`] |
|||
The description of this thumbnail. Up to 256 characters. Defaults to ``None``. |
|||
spoiler: :class:`bool` |
|||
Whether to flag this thumbnail as a spoiler. Defaults to ``False``. |
|||
id: Optional[:class:`int`] |
|||
The ID of this component. This must be unique across the view. |
|||
""" |
|||
|
|||
__slots__ = ( |
|||
'_media', |
|||
'description', |
|||
'spoiler', |
|||
) |
|||
__item_repr_attributes__ = ( |
|||
'media', |
|||
'description', |
|||
'spoiler', |
|||
'row', |
|||
'id', |
|||
) |
|||
|
|||
def __init__( |
|||
self, |
|||
media: Union[str, File, UnfurledMediaItem], |
|||
*, |
|||
description: Optional[str] = MISSING, |
|||
spoiler: bool = MISSING, |
|||
id: Optional[int] = None, |
|||
) -> None: |
|||
super().__init__() |
|||
|
|||
if isinstance(media, File): |
|||
description = description if description is not MISSING else media.description |
|||
spoiler = spoiler if spoiler is not MISSING else media.spoiler |
|||
media = media.uri |
|||
|
|||
self._media: UnfurledMediaItem = UnfurledMediaItem(media) if isinstance(media, str) else media |
|||
self.description: Optional[str] = None if description is MISSING else description |
|||
self.spoiler: bool = bool(spoiler) |
|||
|
|||
self.id = id |
|||
|
|||
@property |
|||
def width(self): |
|||
return 5 |
|||
|
|||
@property |
|||
def media(self) -> UnfurledMediaItem: |
|||
""":class:`discord.UnfurledMediaItem`: This thumbnail unfurled media data.""" |
|||
return self._media |
|||
|
|||
@media.setter |
|||
def media(self, value: Union[str, File, UnfurledMediaItem]) -> None: |
|||
if isinstance(value, str): |
|||
self._media = UnfurledMediaItem(value) |
|||
elif isinstance(value, UnfurledMediaItem): |
|||
self._media = value |
|||
elif isinstance(value, File): |
|||
self._media = UnfurledMediaItem(value.uri) |
|||
else: |
|||
raise TypeError(f'expected a str or UnfurledMediaItem, not {value.__class__.__name__!r}') |
|||
|
|||
@property |
|||
def type(self) -> Literal[ComponentType.thumbnail]: |
|||
return ComponentType.thumbnail |
|||
|
|||
def _is_v2(self) -> bool: |
|||
return True |
|||
|
|||
def to_component_dict(self) -> Dict[str, Any]: |
|||
base = { |
|||
'type': self.type.value, |
|||
'spoiler': self.spoiler, |
|||
'media': self.media.to_dict(), |
|||
'description': self.description, |
|||
} |
|||
if self.id is not None: |
|||
base['id'] = self.id |
|||
return base |
|||
|
|||
@classmethod |
|||
def from_component(cls, component: ThumbnailComponent) -> Self: |
|||
return cls( |
|||
media=component.media.url, |
|||
description=component.description, |
|||
spoiler=component.spoiler, |
|||
id=component.id, |
|||
) |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue