feat: Add support for default_values in Selects (#2899)

Signed-off-by: Lala Sabathil <[email protected]>
Signed-off-by: plun1331 <[email protected]>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Lala Sabathil <[email protected]>
Co-authored-by: Paillat <[email protected]>
Co-authored-by: Lala Sabathil <[email protected]>
Co-authored-by: plun1331 <[email protected]>

Author: 5 people

CHANGELOG.md

@@ -20,6 +20,14 @@ These changes are available on the `master` branch, but have not yet been releas
 - Added support for setting guild-specific `avatar`, `banner`, and `bio` for the bot
   user through `Member.edit`.
   ([#2908](https://github.com/Pycord-Development/pycord/pull/2908))
+- Added support for select default values.
+  ([#2899](https://github.com/Pycord-Development/pycord/pull/2899))
+  - Adds a new generic parameter to selects to type `ui.Select.values` return type.
+  - Adds `SelectDefaultValue` object to create select default values.
+  - Adds `SelectDefaultValueType` enum.
+  - Adds pre-typed and pre-constructed with select_type `ui.Select` aliases for the
+    different select types: `ui.StringSelect`, `ui.UserSelect`, `ui.RoleSelect`,
+    `ui.MentionableSelect`, and `ui.ChannelSelect`.
 
 ### Changed
 

discord/abc.py

@@ -235,7 +235,7 @@ class User(Snowflake, Protocol):
     name: str
     discriminator: str
     global_name: str | None
-    avatar: Asset
+    avatar: Asset | None
     bot: bool
 
     @property

discord/components.py

@@ -25,7 +25,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, ClassVar, Iterator, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, Iterator, TypeVar, overload
 
 from .asset import AssetMixin
 from .colour import Colour
@@ -34,6 +34,7 @@
     ChannelType,
     ComponentType,
     InputTextStyle,
+    SelectDefaultValueType,
     SeparatorSpacingSize,
     try_enum,
 )
@@ -42,9 +43,9 @@
 from .utils import MISSING, find, get_slots
 
 if TYPE_CHECKING:
+    from . import abc
     from .emoji import AppEmoji, GuildEmoji
     from .types.components import ActionRow as ActionRowPayload
-    from .types.components import BaseComponent as BaseComponentPayload
     from .types.components import ButtonComponent as ButtonComponentPayload
     from .types.components import Component as ComponentPayload
     from .types.components import ContainerComponent as ContainerComponentPayload
@@ -54,6 +55,7 @@
     from .types.components import MediaGalleryComponent as MediaGalleryComponentPayload
     from .types.components import MediaGalleryItem as MediaGalleryItemPayload
     from .types.components import SectionComponent as SectionComponentPayload
+    from .types.components import SelectDefaultValue as SelectDefaultValuePayload
     from .types.components import SelectMenu as SelectMenuPayload
     from .types.components import SelectOption as SelectOptionPayload
     from .types.components import SeparatorComponent as SeparatorComponentPayload
@@ -78,6 +80,7 @@
     "Separator",
     "Container",
     "Label",
+    "SelectDefaultValue",
 )
 
 C = TypeVar("C", bound="Component")
@@ -437,6 +440,7 @@ class SelectMenu(Component):
         "channel_types",
         "disabled",
         "required",
+        "default_values",
     )
 
     __repr_info__: ClassVar[tuple[str, ...]] = __slots__
@@ -457,6 +461,9 @@ def __init__(self, data: SelectMenuPayload):
             try_enum(ChannelType, ct) for ct in data.get("channel_types", [])
         ]
         self.required: bool | None = data.get("required")
+        self.default_values: list[SelectDefaultValue] = SelectDefaultValue._from_data(
+            data.get("default_values")
+        )
 
     def to_dict(self) -> SelectMenuPayload:
         payload: SelectMenuPayload = {
@@ -476,10 +483,187 @@ def to_dict(self) -> SelectMenuPayload:
             payload["placeholder"] = self.placeholder
         if self.required is not None:
             payload["required"] = self.required
+        if self.type is not ComponentType.string_select:
+            payload["default_values"] = [dv.to_dict() for dv in self.default_values]
 
         return payload
 
 
+class SelectDefaultValue:
+    r"""Represents a :class:`discord.SelectMenu`\s default value.
+
+    This is only applicable to selects of type other than :attr:`ComponentType.string_select`.
+
+    .. versionadded:: 2.7
+
+    Parameters
+    ----------
+    object: :class:`abc.Snowflake`
+        The model type this select default value is based of.
+
+        Below, is a table defining the model instance type and the default value type it will be mapped:
+
+        +-----------------------------------+--------------------------------------------------------------------------+
+        | Model Type                        | Default Value Type                                                       |
+        +-----------------------------------+--------------------------------------------------------------------------+
+        | :class:`discord.User`             | :attr:`discord.SelectDefaultValueType.user`                              |
+        +-----------------------------------+--------------------------------------------------------------------------+
+        | :class:`discord.Member`           | :attr:`discord.SelectDefaultValueType.user`                              |
+        +-----------------------------------+--------------------------------------------------------------------------+
+        | :class:`discord.Role`             | :attr:`discord.SelectDefaultValueType.role`                              |
+        +-----------------------------------+--------------------------------------------------------------------------+
+        | :class:`discord.abc.GuildChannel` | :attr:`discord.SelectDefaultValueType.channel`                           |
+        +-----------------------------------+--------------------------------------------------------------------------+
+        | :class:`discord.Object`           | depending on :attr:`discord.Object.type`, it will be mapped to any above |
+        +-----------------------------------+--------------------------------------------------------------------------+
+
+        If you pass a model that is not defined in the table, ``TypeError`` will be raised.
+
+        .. note::
+
+            The :class:`discord.abc.GuildChannel` protocol includes :class:`discord.TextChannel`, :class:`discord.VoiceChannel`, :class:`discord.StageChannel`,
+            :class:`discord.ForumChannel`, :class:`discord.Thread`, :class:`discord.MediaChannel`. This list is not exhaustive, and is bound to change
+            based of the new channel types Discord adds.
+
+    id: :class:`int`
+        The ID of the default value. This cannot be used with ``object``.
+    type: :class:`SelectDefaultValueType`
+        The default value type. This cannot be used with ``object``.
+
+    Raises
+    ------
+    TypeError
+        You did not provide any parameter, you provided all parameters, or you provided ``id`` but not ``type``.
+    """
+
+    __slots__ = ("id", "type")
+
+    @overload
+    def __init__(
+        self,
+        object: abc.Snowflake,
+        /,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        /,
+        *,
+        id: int,
+        type: SelectDefaultValueType,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        object: abc.Snowflake = MISSING,
+        /,
+        *,
+        id: int = MISSING,
+        type: SelectDefaultValueType = MISSING,
+    ) -> None:
+        self.id: int = id
+        self.type: SelectDefaultValueType = type
+        if object is not MISSING:
+            if any(p is not MISSING for p in (id, type)):
+                raise TypeError("you cannot pass id or type when passing object")
+            self._handle_model(object, inst=self)
+        elif id is not MISSING and type is not MISSING:
+            self.id = id
+            self.type = type
+        else:
+            raise TypeError("you must provide an object model, or an id and type")
+
+    def __repr__(self) -> str:
+        return f"<SelectDefaultValue id={self.id} type={self.type}>"
+
+    @classmethod
+    def _from_data(
+        cls, default_values: list[SelectDefaultValuePayload] | None
+    ) -> list[SelectDefaultValue]:
+        if not default_values:
+            return []
+        return [
+            cls(id=int(d["id"]), type=try_enum(SelectDefaultValueType, d["type"]))
+            for d in default_values
+        ]
+
+    @classmethod
+    def _handle_model(
+        cls,
+        model: abc.Snowflake,
+        select_type: ComponentType | None = None,
+        inst: SelectDefaultValue | None = None,
+    ) -> SelectDefaultValue:
+        # preventing >circular imports<
+        from discord import Member, Object, Role, User, abc
+        from discord.user import _UserTag
+
+        instances_mapping: dict[
+            type, tuple[tuple[ComponentType, ...], SelectDefaultValueType]
+        ] = {
+            Role: (
+                (ComponentType.role_select, ComponentType.mentionable_select),
+                SelectDefaultValueType.role,
+            ),
+            User: (
+                (ComponentType.user_select, ComponentType.mentionable_select),
+                SelectDefaultValueType.user,
+            ),
+            Member: (
+                (ComponentType.user_select, ComponentType.mentionable_select),
+                SelectDefaultValueType.user,
+            ),
+            _UserTag: (
+                (ComponentType.user_select, ComponentType.mentionable_select),
+                SelectDefaultValueType.user,
+            ),
+            abc.GuildChannel: (
+                (ComponentType.channel_select,),
+                SelectDefaultValueType.channel,
+            ),
+        }
+
+        obj_id = model.id
+        obj_type = model.__class__
+
+        if isinstance(model, Object):
+            obj_type = model.type
+
+        sel_types = None
+        def_type = None
+
+        for typ, (st, dt) in instances_mapping.items():
+            if issubclass(obj_type, typ):
+                sel_types = st
+                def_type = dt
+                break
+
+        if sel_types is None or def_type is None:
+            raise TypeError(
+                f"{obj_type.__name__} is not a valid instance for a select default value"
+            )
+
+        # we can't actually check select types when not in a select context
+        if select_type is not None and select_type not in sel_types:
+            raise TypeError(
+                f"{model.__class__.__name__} objects can not be set as a default value for {select_type.value} selects",
+            )
+
+        if inst is None:
+            return cls(id=obj_id, type=def_type)
+        else:
+            inst.id = obj_id
+            inst.type = def_type
+            return inst
+
+    def to_dict(self) -> SelectDefaultValuePayload:
+        return {
+            "id": self.id,
+            "type": self.type.value,
+        }
+
+
 class SelectOption:
     """Represents a :class:`discord.SelectMenu`'s option.
 

discord/enums.py

@@ -83,6 +83,7 @@
     "ThreadArchiveDuration",
     "SubscriptionStatus",
     "SeparatorSpacingSize",
+    "SelectDefaultValueType",
 )
 
 
@@ -1120,6 +1121,14 @@ def __int__(self):
         return self.value
 
 
+class SelectDefaultValueType(Enum):
+    """Represents the default value type of a select menu."""
+
+    channel = "channel"
+    role = "role"
+    user = "user"
+
+
 T = TypeVar("T")
 
 

discord/object.py

@@ -33,6 +33,8 @@
 if TYPE_CHECKING:
     import datetime
 
+    from .abc import Snowflake
+
     SupportsIntCast = Union[SupportsInt, str, bytes, bytearray]
 
 __all__ = ("Object",)
@@ -70,9 +72,11 @@ class Object(Hashable):
     ----------
     id: :class:`int`
         The ID of the object.
+    type: type[:class:`abc.Snowflake`]
+        The model this object's ID is based off.
     """
 
-    def __init__(self, id: SupportsIntCast):
+    def __init__(self, id: SupportsIntCast, type: type[Snowflake] = utils.MISSING):
         try:
             id = int(id)
         except ValueError:
@@ -81,6 +85,7 @@ def __init__(self, id: SupportsIntCast):
             ) from None
         else:
             self.id = id
+        self.type: type[Snowflake] = type or self.__class__
 
     def __repr__(self) -> str:
         return f"<Object id={self.id!r}>"

discord/types/components.py

@@ -37,6 +37,7 @@
 ButtonStyle = Literal[1, 2, 3, 4, 5, 6]
 InputTextStyle = Literal[1, 2]
 SeparatorSpacingSize = Literal[1, 2]
+SelectDefaultValueType = Literal["channel", "role", "user"]
 
 
 class BaseComponent(TypedDict):
@@ -46,7 +47,7 @@ class BaseComponent(TypedDict):
 
 class ActionRow(BaseComponent):
     type: Literal[1]
-    components: list[ButtonComponent, InputText, SelectMenu]
+    components: list[ButtonComponent | InputText | SelectMenu]
 
 
 class ButtonComponent(BaseComponent):
@@ -80,6 +81,11 @@ class SelectOption(TypedDict):
     default: bool
 
 
+class SelectDefaultValue(TypedDict):
+    id: Snowflake
+    type: SelectDefaultValueType
+
+
 class SelectMenu(BaseComponent):
     placeholder: NotRequired[str]
     min_values: NotRequired[int]
@@ -90,6 +96,7 @@ class SelectMenu(BaseComponent):
     type: Literal[3, 5, 6, 7, 8]
     custom_id: str
     required: NotRequired[bool]
+    default_values: NotRequired[list[SelectDefaultValue]]
 
 
 class TextDisplayComponent(BaseComponent):
@@ -100,7 +107,7 @@ class TextDisplayComponent(BaseComponent):
 class SectionComponent(BaseComponent):
     type: Literal[9]
     components: list[TextDisplayComponent]
-    accessory: NotRequired[ThumbnailComponent, ButtonComponent]
+    accessory: NotRequired[ThumbnailComponent | ButtonComponent]
 
 
 class UnfurledMediaItem(TypedDict):

discord/ui/button.py

@@ -294,7 +294,7 @@ def button(
     emoji: str | GuildEmoji | AppEmoji | PartialEmoji | None = None,
     row: int | None = None,
     id: int | None = None,
-) -> Callable[[ItemCallbackType], ItemCallbackType]:
+) -> Callable[[ItemCallbackType[Button[V]]], Button[V]]:
     """A decorator that attaches a button to a component.
 
     The function being decorated should have three parameters, ``self`` representing
@@ -347,4 +347,4 @@ def decorator(func: ItemCallbackType) -> ItemCallbackType:
         }
         return func
 
-    return decorator
+    return decorator  # type: ignore # lie to the type checkers, because after a View is instated, the button callback is converted into a Button instance