feat: untested prototype impl of v2 components

AstreaTSS · AstreaTSS · commit 439d54b6d18c · 2025-03-01T17:26:21.000-05:00
Likely not to work. Very unpolished and pretty much takes directly from the docs. It's here, though!
diff --git a/interactions/models/discord/components.py b/interactions/models/discord/components.py
@@ -12,7 +12,13 @@
 from interactions.client.mixins.serialization import DictSerializationMixin
 from interactions.models.discord.base import DiscordObject
 from interactions.models.discord.emoji import PartialEmoji, process_emoji
-from interactions.models.discord.enums import ButtonStyle, ChannelType, ComponentType
+from interactions.models.discord.enums import (
+    ButtonStyle,
+    ChannelType,
+    ComponentType,
+    UnfurledMediaItemLoadingState,
+    SeparatorSpacingSize,
+)
 
 if TYPE_CHECKING:
     import interactions.models.discord
@@ -38,6 +44,38 @@
 )
 
 
+class UnfurledMediaItem(DictSerializationMixin):
+    """A basic object for making media items."""
+
+    url: str
+    proxy_url: Optional[str] = None
+    height: Optional[int] = None
+    width: Optional[int] = None
+    content_type: Optional[str] = None
+    loading_state: Optional[UnfurledMediaItemLoadingState] = None
+
+    def __init__(self, url: str):
+        self.url = url
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "UnfurledMediaItem":
+        item = cls(data["url"])
+        item.proxy_url = data.get("proxy_url")
+        item.height = data.get("height")
+        item.width = data.get("width")
+        item.content_type = data.get("content_type")
+        item.loading_state = (
+            UnfurledMediaItemLoadingState(data.get("loading_state")) if data.get("loading_state") else None
+        )
+        return item
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} url={self.url}>"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"url": self.url}
+
+
 class BaseComponent(DictSerializationMixin):
     """
     A base component class.
@@ -48,6 +86,7 @@ class BaseComponent(DictSerializationMixin):
     """
 
     type: ComponentType
+    id: Optional[int] = None
 
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__} type={self.type}>"
@@ -763,6 +802,227 @@ def to_dict(self) -> discord_typings.SelectMenuComponentData:
         }
 
 
+class SectionComponent(BaseComponent):
+    components: "list[TextDisplayComponent]"
+    accessory: "Button | ThumbnailComponent"
+
+    def __init__(
+        self, *, components: "list[TextDisplayComponent] | None" = None, accessory: "Button | ThumbnailComponent"
+    ):
+        self.components = components or []
+        self.accessory = accessory
+        self.type = ComponentType.SECTION
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "SectionComponent":
+        return cls(
+            components=TextDisplayComponent.from_list(data["components"]), accessory=Button.from_dict(data["accessory"])
+        )
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} type={self.type} components={self.components} accessory={self.accessory}>"
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type.value,
+            "components": [c.to_dict() for c in self.components],
+            "accessory": self.accessory.to_dict(),
+        }
+
+
+class TextDisplayComponent(BaseComponent):
+    content: str
+
+    def __init__(self, content: str):
+        self.content = content
+        self.type = ComponentType.TEXT_DISPLAY
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "TextDisplayComponent":
+        return cls(data["content"])
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} type={self.type} style={self.content}>"
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type.value,
+            "content": self.content,
+        }
+
+
+class ThumbnailComponent(BaseComponent):
+    media: UnfurledMediaItem
+    description: Optional[str] = None
+    spoiler: bool = False
+
+    def __init__(self, media: UnfurledMediaItem, *, description: Optional[str] = None, spoiler: bool = False):
+        self.media = media
+        self.description = description
+        self.spoiler = spoiler
+        self.type = ComponentType.THUMBNAIL
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ThumbnailComponent":
+        return cls(
+            media=UnfurledMediaItem.from_dict(data["media"]),
+            description=data.get("description"),
+            spoiler=data.get("spoiler", False),
+        )
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} type={self.type} media={self.media} description={self.description} spoiler={self.spoiler}>"
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type.value,
+            "media": self.media.to_dict(),
+            "description": self.description,
+            "spoiler": self.spoiler,
+        }
+
+
+class MediaGalleryItem(DictSerializationMixin):
+    media: UnfurledMediaItem
+    description: Optional[str] = None
+    spoiler: bool = False
+
+    def __init__(self, media: UnfurledMediaItem, *, description: Optional[str] = None, spoiler: bool = False):
+        self.media = media
+        self.description = description
+        self.spoiler = spoiler
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "MediaGalleryItem":
+        return cls(
+            media=UnfurledMediaItem.from_dict(data["media"]),
+            description=data.get("description"),
+            spoiler=data.get("spoiler", False),
+        )
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} media={self.media} description={self.description} spoiler={self.spoiler}>"
+
+    def to_dict(self) -> dict:
+        return {
+            "media": self.media.to_dict(),
+            "description": self.description,
+            "spoiler": self.spoiler,
+        }
+
+
+class MediaGalleryComponent(BaseComponent):
+    items: list[MediaGalleryItem]
+
+    def __init__(self, items: list[MediaGalleryItem] | None = None):
+        self.items = items or []
+        self.type = ComponentType.MEDIA_GALLERY
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "MediaGalleryComponent":
+        return cls([MediaGalleryItem.from_dict(item) for item in data["items"]])
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} type={self.type} items={self.items}>"
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type.value,
+            "items": [item.to_dict() for item in self.items],
+        }
+
+
+class FileComponent(BaseComponent):
+    file: UnfurledMediaItem
+    spoiler: bool = False
+
+    def __init__(self, file: UnfurledMediaItem, *, spoiler: bool = False):
+        self.file = file
+        self.spoiler = spoiler
+        self.type = ComponentType.FILE
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "FileComponent":
+        return cls(file=UnfurledMediaItem.from_dict(data["file"]), spoiler=data.get("spoiler", False))
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} type={self.type} file={self.file} spoiler={self.spoiler}>"
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type.value,
+            "file": self.file.to_dict(),
+            "spoiler": self.spoiler,
+        }
+
+
+class SeparatorComponent(BaseComponent):
+    divider: bool = False
+    spacing: SeparatorSpacingSize = SeparatorSpacingSize.SMALL
+
+    def __init__(self, *, divider: bool = False, spacing: SeparatorSpacingSize | int = SeparatorSpacingSize.SMALL):
+        self.divider = divider
+        self.spacing = SeparatorSpacingSize(spacing)
+        self.type = ComponentType.SEPARATOR
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "SeparatorComponent":
+        return cls(divider=data.get("divider", False), spacing=data.get("spacing", SeparatorSpacingSize.SMALL))
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} type={self.type} divider={self.divider} spacing={self.spacing}>"
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type.value,
+            "divider": self.divider,
+            "spacing": self.spacing,
+        }
+
+
+class ContainerComponent(BaseComponent):
+    components: list[
+        ActionRow | SectionComponent | TextDisplayComponent | MediaGalleryComponent | FileComponent | SeparatorComponent
+    ]
+    accent_color: Optional[int] = None
+    spoiler: bool = False
+
+    def __init__(
+        self,
+        *components: ActionRow
+        | SectionComponent
+        | TextDisplayComponent
+        | MediaGalleryComponent
+        | FileComponent
+        | SeparatorComponent,
+        accent_color: Optional[int] = None,
+        spoiler: bool = False,
+    ):
+        self.components = list(components)
+        self.accent_color = accent_color
+        self.spoiler = spoiler
+        self.type = ComponentType.CONTAINER
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ContainerComponent":
+        return cls(
+            *[BaseComponent.from_dict_factory(component) for component in data["components"]],
+            accent_color=data.get("accent_color"),
+            spoiler=data.get("spoiler", False),
+        )
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} type={self.type} components={self.components} accent_color={self.accent_color} spoiler={self.spoiler}>"
+
+    def to_dict(self) -> dict:
+        return {
+            "type": self.type.value,
+            "components": [component.to_dict() for component in self.components],
+            "accent_color": self.accent_color,
+            "spoiler": self.spoiler,
+        }
+
+
 def process_components(
     components: Optional[
         Union[
@@ -806,6 +1066,7 @@ def process_components(
 
         if all(isinstance(c, list) for c in components):
             # list of lists... actionRow-less sending
+            # note: we're assuming if someone passes a list of lists, they mean to use v1 components
             return [ActionRow(*row).to_dict() for row in components]
 
         if all(issubclass(type(c), InteractiveComponent) for c in components):
@@ -816,6 +1077,9 @@ def process_components(
             # we have a list of action rows
             return [action_row.to_dict() for action_row in components]
 
+        # assume just a list of components
+        return [c if isinstance(c, dict) else c.to_dict() for c in components]
+
     raise ValueError(f"Invalid components: {components}")
 
 
@@ -880,4 +1144,11 @@ def get_components_ids(component: Union[str, dict, list, InteractiveComponent])
     ComponentType.CHANNEL_SELECT: ChannelSelectMenu,
     ComponentType.ROLE_SELECT: RoleSelectMenu,
     ComponentType.MENTIONABLE_SELECT: MentionableSelectMenu,
+    ComponentType.SECTION: SectionComponent,
+    ComponentType.TEXT_DISPLAY: TextDisplayComponent,
+    ComponentType.THUMBNAIL: ThumbnailComponent,
+    ComponentType.MEDIA_GALLERY: MediaGalleryComponent,
+    ComponentType.FILE: FileComponent,
+    ComponentType.SEPARATOR: SeparatorComponent,
+    ComponentType.CONTAINER: ContainerComponent,
 }
diff --git a/interactions/models/discord/enums.py b/interactions/models/discord/enums.py
@@ -493,6 +493,8 @@ class MessageFlags(DiscordIntFlag):  # type: ignore
     """This message should not trigger push or desktop notifications"""
     VOICE_MESSAGE = 1 << 13
     """This message is a voice message"""
+    IS_COMPONENTS_V2 = 1 << 15
+    """This message contains uses v2 components"""
 
     SUPPRESS_NOTIFICATIONS = SILENT
     """Alias for :attr:`SILENT`"""
@@ -683,6 +685,38 @@ class ComponentType(CursedIntEnum):
     """Select menu for picking from mentionable objects"""
     CHANNEL_SELECT = 8
     """Select menu for picking from channels"""
+    SECTION = 9
+    """Section component for grouping together text and thumbnails/buttons"""
+    TEXT_DISPLAY = 10
+    """Text component for displaying text"""
+    THUMBNAIL = 11
+    """Thumbnail component for displaying a thumbnail for an image"""
+    MEDIA_GALLERY = 12
+    """Media gallery component for displaying multiple images"""
+    FILE = 13
+    """File component for uploading files"""
+    SEPARATOR = 14
+    """Separator component for visual separation"""
+    CONTAINER = 17
+    """Container component for grouping together other components"""
+
+    # TODO: this is hacky, is there a better way to do this?
+    @staticmethod
+    def v2_component_types() -> set["ComponentType"]:
+        return {
+            ComponentType.SECTION,
+            ComponentType.TEXT_DISPLAY,
+            ComponentType.THUMBNAIL,
+            ComponentType.MEDIA_GALLERY,
+            ComponentType.FILE,
+            ComponentType.SEPARATOR,
+            ComponentType.CONTAINER,
+        }
+
+    @property
+    def v2_component(self) -> bool:
+        """Whether this component is a v2 component."""
+        return self.value in self.v2_component_types()
 
 
 class IntegrationType(CursedIntEnum):
diff --git a/interactions/models/discord/message.py b/interactions/models/discord/message.py
@@ -42,6 +42,7 @@
     MessageFlags,
     MessageType,
     IntegrationType,
+    ComponentType,
 )
 from .snowflake import (
     Snowflake,
@@ -1066,6 +1067,13 @@ def process_message_payload(
         embeds = embeds if all(e is not None for e in embeds) else None
 
     components = models.process_components(components)
+    if components:
+        # TODO: should we check for content/embeds? should this be moved elsewhere?
+        if any(c["type"] in ComponentType.v2_component_types() for c in components):
+            if not flags:
+                flags = 0
+            flags |= MessageFlags.IS_COMPONENTS_V2
+
     if stickers:
         stickers = [to_snowflake(sticker) for sticker in stickers]
     allowed_mentions = process_allowed_mentions(allowed_mentions)
