feat: redo CV2 and New Modal implementation

discord/components.py

@@ -173,7 +173,7 @@ def __init__(self, data: ComponentPayload):
 
     @property
     def width(self):
-        """Return the sum of the children's widths."""
+        """Return the sum of the item's widths."""
         t = 0
         for item in self.children:
             t += 1 if item.type is ComponentType.button else 5

discord/ui/action_row.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+from functools import partial
+from typing import TYPE_CHECKING, ClassVar, Iterator, TypeVar
+
+from ..components import ActionRow as ActionRowComponent
+from ..components import SelectOption, _component_factory
+from ..enums import ButtonStyle, ChannelType, ComponentType
+from ..utils import find, get
+from .button import Button
+from .file import File
+from .item import Item, ItemCallbackType
+from .select import Select
+
+__all__ = ("ActionRow",)
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from ..emoji import AppEmoji, GuildEmoji
+    from ..partial_emoji import PartialEmoji, _EmojiTag
+    from ..types.components import ActionRow as ActionRowPayload
+    from .view import View
+
+
+A = TypeVar("A", bound="ActionRow")
+V = TypeVar("V", bound="View", covariant=True)
+
+
+class ActionRow(Item[V]):
+    """Represents a UI Action Row used in :class:`discord.ui.View`.
+
+    The items supported are as follows:
+
+    - :class:`discord.ui.Select`
+    - :class:`discord.ui.Button`
+
+    .. versionadded:: 2.7
+
+    Parameters
+    ----------
+    *items: :class:`Item`
+        The initial items in this action row.
+    id: Optional[:class:`int`]
+        The action's ID.
+    """
+
+    __item_repr_attributes__: tuple[str, ...] = (
+        "items",
+        "id",
+    )
+
+    __row_children_items__: ClassVar[list[ItemCallbackType]] = []
+
+    def __init_subclass__(cls) -> None:
+        children: list[ItemCallbackType] = []
+        for base in reversed(cls.__mro__):
+            for member in base.__dict__.values():
+                if hasattr(member, "__discord_ui_model_type__"):
+                    children.append(member)
+
+        cls.__row_children_items__ = children
+
+    def __init__(
+        self,
+        *items: Item,
+        id: int | None = None,
+    ):
+        super().__init__()
+
+        self.items: list[Item] = []
+
+        self._underlying = ActionRowComponent._raw_construct(
+            type=ComponentType.action_row,
+            id=id,
+            components=[],
+        )
+
+        for func in self.__row_children_items__:
+            item: Item = func.__discord_ui_model_type__(
+                **func.__discord_ui_model_kwargs__
+            )
+            item.callback = partial(func, self, item)
+            self.add_item(item)
+            setattr(self, func.__name__, item)
+        for i in items:
+            self.add_item(i)
+
+    def _add_component_from_item(self, item: Item):
+        self._underlying.components.append(item._underlying)
+
+    def _set_components(self, items: list[Item]):
+        self._underlying.components.clear()
+        for item in items:
+            self._add_component_from_item(item)
+
+    def add_item(self, item: Item) -> Self:
+        """Adds an item to the action row.
+
+        Parameters
+        ----------
+        item: :class:`Item`
+            The item to add to the action row.
+
+        Raises
+        ------
+        TypeError
+            An :class:`Item` was not passed.
+        """
+
+        if not isinstance(item, Item):
+            raise TypeError(f"expected Item not {item.__class__!r}")
+
+        item._view = self.view
+        item.parent = self
+
+        self.items.append(item)
+        self._add_component_from_item(item)
+        return self
+
+    def remove_item(self, item: Item | str | int) -> Self:
+        """Removes an item from the action row. If an int or str is passed, it will remove by Item :attr:`id` or ``custom_id`` respectively.
+
+        Parameters
+        ----------
+        item: Union[:class:`Item`, :class:`int`, :class:`str`]
+            The item, ``id``, or item ``custom_id`` to remove from the action row.
+        """
+
+        if isinstance(item, (str, int)):
+            item = self.get_item(item)
+        try:
+            self.items.remove(item)
+        except ValueError:
+            pass
+        return self
+
+    def get_item(self, id: str | int) -> Item | None:
+        """Get an item from this action row. Roughly equivalent to `utils.get(row.items, ...)`.
+        If an ``int`` is provided, the item will be retrieved by ``id``, otherwise by ``custom_id``.
+
+        Parameters
+        ----------
+        id: Union[:class:`str`, :class:`int`]
+            The id or custom_id of the item to get.
+
+        Returns
+        -------
+        Optional[:class:`Item`]
+            The item with the matching ``id`` or ``custom_id`` if it exists.
+        """
+        if not id:
+            return None
+        attr = "id" if isinstance(id, int) else "custom_id"
+        child = find(lambda i: getattr(i, attr, None) == id, self.items)
+        return child
+
+    def add_button(
+        self,
+        *,
+        style: ButtonStyle = ButtonStyle.secondary,
+        label: str | None = None,
+        disabled: bool = False,
+        custom_id: str | None = None,
+        url: str | None = None,
+        emoji: str | GuildEmoji | AppEmoji | PartialEmoji | None = None,
+        sku_id: int | None = None,
+        id: int | None = None,
+    ) -> Self:
+        """Adds a :class:`Button` to the action row.
+
+        To append a pre-existing :class:`Button`, use the
+        :meth:`add_item` method, instead.
+
+        Parameters
+        ----------
+        style: :class:`discord.ButtonStyle`
+            The style of the button.
+        custom_id: Optional[:class:`str`]
+            The custom 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. Maximum of 80 chars.
+        emoji: Optional[Union[:class:`.PartialEmoji`, :class:`GuildEmoji`, :class:`AppEmoji`, :class:`str`]]
+            The emoji of the button, if any.
+        sku_id: Optional[Union[:class:`int`]]
+            The ID of the SKU this button refers to.
+        id: Optional[:class:`int`]
+            The button's ID.
+        """
+
+        button = Button(
+            style=style,
+            label=label,
+            disabled=disabled,
+            custom_id=custom_id,
+            url=url,
+            emoji=emoji,
+            sku_id=sku_id,
+            id=id,
+        )
+
+        return self.add_item(button)
+
+    def add_select(
+        self,
+        select_type: ComponentType = ComponentType.string_select,
+        *,
+        custom_id: str | None = None,
+        placeholder: str | None = None,
+        min_values: int = 1,
+        max_values: int = 1,
+        options: list[SelectOption] | None = None,
+        channel_types: list[ChannelType] | None = None,
+        disabled: bool = False,
+        id: int | None = None,
+    ) -> Self:
+        """Adds a :class:`TextDisplay` to the container.
+
+        Parameters
+        ----------
+        select_type: :class:`discord.ComponentType`
+            The type of select to create. Must be one of
+            :attr:`discord.ComponentType.string_select`, :attr:`discord.ComponentType.user_select`,
+            :attr:`discord.ComponentType.role_select`, :attr:`discord.ComponentType.mentionable_select`,
+            or :attr:`discord.ComponentType.channel_select`.
+        custom_id: :class:`str`
+            The custom 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.
+            Only valid for selects of type :attr:`discord.ComponentType.string_select`.
+        channel_types: List[:class:`discord.ChannelType`]
+            A list of channel types that can be selected in this menu.
+            Only valid for selects of type :attr:`discord.ComponentType.channel_select`.
+        disabled: :class:`bool`
+            Whether the select is disabled or not. Defaults to ``False``.
+        id: Optional[:class:`int`]
+            The select menu's ID.
+        """
+
+        select = Select(
+            select_type=select_type,
+            custom_id=custom_id,
+            placeholder=placeholder,
+            min_values=min_values,
+            max_values=max_values,
+            options=options or [],
+            channel_types=channel_types or [],
+            disabled=disabled,
+            id=id,
+        )
+
+        return self.add_item(select)
+
+    @Item.view.setter
+    def view(self, value):
+        self._view = value
+        for item in self.items:
+            item.parent = self
+            item._view = value
+
+    @property
+    def type(self) -> ComponentType:
+        return self._underlying.type
+
+    @property
+    def width(self) -> int:
+        return 5
+
+    def is_dispatchable(self) -> bool:
+        return any(item.is_dispatchable() for item in self.items)
+
+    def is_persistent(self) -> bool:
+        return all(item.is_persistent() for item in self.items)
+
+    def refresh_component(self, component: ActionRowComponent) -> None:
+        self._underlying = component
+        i = 0
+        for y in component.components:
+            x = self.items[i]
+            x.refresh_component(y)
+            i += 1
+
+    def disable_all_items(self, *, exclusions: list[Item] | None = None) -> Self:
+        """
+        Disables all items in the row.
+
+        Parameters
+        ----------
+        exclusions: Optional[List[:class:`Item`]]
+            A list of items in `self.items` to not disable.
+        """
+        for item in self.walk_items():
+            if exclusions is None or item not in exclusions:
+                item.disabled = True
+        return self
+
+    def enable_all_items(self, *, exclusions: list[Item] | None = None) -> Self:
+        """
+        Enables all items in the row.
+
+        Parameters
+        ----------
+        exclusions: Optional[List[:class:`Item`]]
+            A list of items in `self.items` to not enable.
+        """
+        for item in self.walk_items():
+            if hasattr(item, "disabled") and (
+                exclusions is None or item not in exclusions
+            ):
+                item.disabled = False
+        return self
+
+    def walk_items(self) -> Iterator[Item]:
+        yield from self.items
+
+    def to_component_dict(self) -> ActionRowPayload:
+        self._set_components(self.items)
+        return self._underlying.to_dict()
+
+    @classmethod
+    def from_component(cls: type[A], component: ActionRowComponent) -> A:
+        from .view import _component_to_item, _walk_all_components
+
+        items = [
+            _component_to_item(c) for c in _walk_all_components(component.components)
+        ]
+        return cls(
+            *items,
+            id=component.id,
+        )
+
+    callback = None