componentsv2 0.2.2__py3-none-any.whl

componentsv2/__init__.py

@@ -0,0 +1,11 @@
+from .components.action_row import ActionRow
+from .components.base import ComponentV2 
+from .components.button import ButtonV2
+
+from .components.select import (
+    StringSelect,
+    UserSelect,
+    RoleSelect,
+
+    DefaultValue,
+)

componentsv2/component_holder.py

@@ -0,0 +1,212 @@
+from .components.base import ComponentV2
+from .components.button import ButtonV2
+from .components.action_row import ActionRow
+from .components.select import SelectObject
+
+import copy
+
+class ComponentHolder():
+    def __init_subclass__(cls):
+        children: list[ComponentV2] = []
+
+        for base in reversed(cls.__mro__):
+            children.extend(
+                member
+                for member in base.__dict__.values()
+                if hasattr(member, "__discord_ui_model_type__")
+            )
+
+        if len(children) > 25:
+            raise TypeError("Component Holders can only contain 25 components!")
+
+        cls.children = children
+
+    def __init__(self):
+        self.children = copy.deepcopy(self.children)
+        rows: list[ActionRow] = []
+
+        for child in self.children:
+            if hasattr(child, "parent_holder") == False:
+                child.parent_holder = self
+
+            if isinstance(child, ActionRow):
+                rows.append(child)
+
+        self.rows = rows
+
+        for child in self.children:
+            if isinstance(child, ButtonV2) or isinstance(child, SelectObject): # switch StringSelect to general Select object
+                self.append_to_row(child.row, child)
+
+    def __rec_add_components(self, component: ComponentV2, initial: bool):
+        if hasattr(component, "row"):
+            self.append_to_row(component.row, component)
+
+        if hasattr(component, "parent_holder") == False:
+            component.parent_holder = self
+        elif isinstance(component.parent_holder, ComponentHolder):
+            raise TypeError("Cannot re-assign components!")
+
+        if hasattr(component, "accessory") == True:
+            component.accessory.__row_child__ = True
+            self.children.append(component.accessory)
+
+        if initial == False:
+            component.__row_child__ = True
+
+        self.children.append(component)
+
+        if hasattr(component, "components") == True:
+            for child in component.components:
+                self.__rec_add_components(child, False)
+
+    def add_component(self, component: ComponentV2):
+        self.__rec_add_components(component, True)
+        return self
+
+    def add_components(self, *args: ComponentV2):
+        components = list(args)
+
+        for component in components:
+            self.__rec_add_components(component, True)
+
+    def append_to_row(self, row: int, component: ComponentV2):
+        if row < len(self.rows):
+            action_row = self.rows[row]
+        elif row == len(self.rows):
+            action_row = ActionRow()
+            self.rows.append(action_row)
+            self.children.append(action_row)
+        else:
+            raise IndexError("New rows must be created sequentially (cannot skip rows).")
+
+        component.__row_child__ = True
+        action_row.append_component(component)
+
+    def serialize(self):
+        components = []
+
+        for child in self.children:
+            if hasattr(child, "__row_child__") == True:
+                continue
+
+            components.append(child.serialize())
+        
+        return components
+    
+    def get_component(self, custom_id: str):
+        for child in self.children:
+            if getattr(child, "custom_id", None) == custom_id:
+                return child
+            
+class ModalV2():
+    def __init__(self, custom_id: str, title: str):
+        if custom_id == None:
+            raise ValueError("With this wrapper, custom_ids for modals are required!")
+        
+        self.custom_id = custom_id
+        self.title = title
+
+        self.children = []
+
+    async def __handle_component_submitted(self, sc: dict[str]):
+        if custom_id := sc.get("custom_id"):
+            component = self.get_component(custom_id)
+
+            if component is not None:
+                if values := sc.get("values"):
+                    component.values = values
+                else:
+                    values = None
+
+                if (value := sc.get("value")) is not None:
+                    component.value = value
+                elif values:
+                    component.value = values[0]
+
+        if component := sc.get("component"):
+            await self.__handle_component_submitted(component)
+
+        if components := sc.get("components"):
+            for child in components:
+                await self.__handle_component_submitted(child)
+
+    async def submitted(self, interaction, ser_components: list[dict[str]], initial: bool = True):
+        for sc in ser_components:
+            await self.__handle_component_submitted(sc)
+        
+        if initial == True:
+            await self.on_form_submit(interaction)
+
+    async def on_form_submit(self, interaction):
+        pass
+
+    def __rec_add_components(self, component: ComponentV2, initial: bool):
+        if hasattr(component, "parent_holder") == False:
+            component.parent_holder = self
+        elif isinstance(component.parent_holder, ModalV2):
+            raise TypeError("Cannot re-assign components!")
+
+        if hasattr(component, "accessory") == True:
+            component.accessory.__row_child__ = True
+            self.children.append(component.accessory)
+
+        if initial == False:
+            component.__row_child__ = True
+
+        self.children.append(component)
+
+        if hasattr(component, "components") == True:
+            for child in component.components:
+                self.__rec_add_components(child, False)
+
+        if hasattr(component, "component") == True:
+            self.__rec_add_components(component.component, False)
+
+    def add_component(self, component: ComponentV2):
+        self.__rec_add_components(component, True)
+        return self
+
+    def add_components(self, *args: ComponentV2):
+        components = list(args)
+
+        for component in components:
+            self.__rec_add_components(component, True)
+
+    def serialize(self):
+        components = []
+
+        for child in self.children:
+            if hasattr(child, "__row_child__") == True:
+                continue
+
+            components.append(child.serialize())
+        
+        return {
+            "type": 9,
+            "data": {
+                "custom_id": self.custom_id,
+                "title": self.title,
+                "components": components
+            }
+        }
+    
+    def get_component(self, custom_id: str):
+        if custom_id == None:
+            return
+
+        for child in self.children:
+            if getattr(child, "custom_id", None) == custom_id:
+                return child
+            
+    def get_components(self) -> list[ComponentV2]:
+        components = []
+
+        for child in self.children:
+            if hasattr(child, "__row_child__") == True:
+                continue
+
+            components.append(child)
+
+        return components
+    

componentsv2/components/action_row.py

@@ -0,0 +1,44 @@
+from .base import ComponentV2
+from typing import Optional
+
+class ActionRow(ComponentV2):
+    types_to_max = {
+        2: 5,
+
+        3: 1,
+        5: 1,
+        6: 1,
+        7: 1,
+        8: 1,
+    }
+
+    def __init__(self, id: Optional[int] = None):
+        super().__init__(1, id)
+
+        self.component_type: Optional[int] = None
+        self.components: list[ComponentV2] = []
+
+        self.__container_compatible__ = True
+    
+    def serialize(self) -> dict:
+        base_dict: dict = super(ActionRow, self).serialize()
+        component_array = []
+
+        for component in self.components:
+            component_array.append(component.serialize())
+
+        base_dict["components"] = component_array
+        return base_dict
+    
+    def append_component(self, component: ComponentV2):
+        if self.component_type != None and component.type != self.component_type:
+            raise TypeError("Cannot assign multiple different types to one action row.")
+        
+        max = self.types_to_max[component.type]
+        if max == None:
+            raise TypeError(f"Component type {component.type} not accepted in an action row!")
+
+        if len(self.components) >= max:
+            raise ValueError(f"Cannot add more components to this action row! Max: {max}")
+        
+        self.components.append(component)

componentsv2/components/base.py

@@ -0,0 +1,19 @@
+from typing import Optional
+
+class ComponentV2():
+    def __init__(self, type: int, id: Optional[int] = None):
+        self.type = type
+        self.id = id
+
+        self.value = None
+        self.values = None
+
+    @property
+    def __discord_ui_model_type__(self):
+        return True
+
+    def serialize(self) -> dict:
+        return {
+            "type": self.type,
+            "id": self.id,
+        }

componentsv2/components/button.py

@@ -0,0 +1,79 @@
+import nextcord
+
+from typing import Optional
+from .base import ComponentV2
+
+from ..utils.serialize import serialize_emoji
+
+class ButtonV2(ComponentV2):
+    def __init__(self, style: nextcord.ButtonStyle, label: Optional[str] = None, custom_id: Optional[str] = None, url: Optional[str] = None, disabled: Optional[bool] = False, emoji: Optional[nextcord.PartialEmoji] = None, row: Optional[int] = 1, id: Optional[int] = None):
+        if style != nextcord.ButtonStyle.link and custom_id == None:
+            raise TypeError("Non-link buttons must have a custom_id attribute!")
+        
+        if style == nextcord.ButtonStyle.link and (custom_id != None or url == None):
+            raise TypeError("Link buttons cannot have a custom_id and must have a url attribute!")
+        
+        super().__init__(2, id)
+
+        self.row = row
+
+        self.label = label
+        self.emoji = emoji
+
+        self.custom_id = custom_id
+        self.url = url
+
+        self.style = style.value
+
+        self.disabled = disabled
+
+        self.callback = None
+        self.registered = False
+
+    def __call__(self, func):
+        if self.registered == True:
+            raise ValueError("Buttons cannot be registered to multiple callbacks!")
+        
+        self.callback = func
+        self.registered = True
+
+        return self
+
+    def serialize(self):
+        base_dict: dict = super(ButtonV2, self).serialize()
+
+        base_dict["label"] = self.label
+
+        base_dict["custom_id"] = self.custom_id
+        base_dict["url"] = self.url
+
+        base_dict["style"] = self.style
+
+        base_dict["disabled"] = self.disabled
+
+        if self.emoji != None:
+            base_dict["emoji"] = serialize_emoji(self.emoji)
+
+        return base_dict
+    
+    async def activated(self, interaction):
+        if self.disabled == True:
+            return
+        
+        if self.registered == False:
+            raise ValueError("Attempted to activate button, but it is not registered to a callback!")
+        
+        await self.callback(self.parent_holder, self, interaction)
+
+class UIButtonV2(ButtonV2):
+    def __init__(self, style, label = None, custom_id = None, url = None, disabled = False, emoji = None, row = 1, id = None):
+        super().__init__(style, label, custom_id, url, disabled, emoji, row, id)
+
+    async def activated(self, interaction):
+        if self.disabled == True:
+            return
+        
+        await self.ui_callback(interaction)
+
+    async def ui_callback(self, interaction):
+        pass

componentsv2/components/checkbox.py

@@ -0,0 +1,62 @@
+from .base import ComponentV2
+
+class Checkbox(ComponentV2):
+    def __init__(self, custom_id: str, default: bool = None, id = None):
+        super().__init__(23, id)
+
+        self.custom_id = custom_id
+        self.default = default
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        base_dict["custom_id"] = self.custom_id
+        base_dict["default"] = self.default
+
+        return base_dict
+    
+class CheckboxGroup(ComponentV2):
+    class Option():
+        def __init__(self, value: str, label: str, description: str = None, default: bool = None):
+            self.value = value
+            self.label = label
+
+            self.description = description
+            self.default = default
+
+        def serialize(self):
+            return {
+                "value": self.value,
+                "label": self.label,
+
+                "description": self.description,
+                "default": self.default,
+            }
+
+    def __init__(self, custom_id: str, options: list[Option], min_values: int = None, max_values: int = None, required: bool = None, id = None):
+        super().__init__(22, id)
+
+        if required == True and min_values and min_values < 1:
+            raise ValueError("min_values must be ommited or >= 1 when required is omitted or True!")
+        
+        self.custom_id = custom_id
+        self.options = options
+        self.min_values = min_values
+        self.max_values = max_values
+        self.required = required
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        checkbox_options = []
+
+        for option in self.options:
+            checkbox_options.append(option.serialize())
+
+        base_dict["custom_id"] = self.custom_id
+        base_dict["options"] = checkbox_options
+        base_dict["min_values"] = self.min_values
+        base_dict["max_values"] = self.max_values
+        base_dict["required"] = self.required
+
+        return base_dict

componentsv2/components/file_upload.py

@@ -0,0 +1,59 @@
+import nextcord
+from nextcord import Interaction
+
+from .base import ComponentV2
+from .gallery import MediaGallery as Gallery
+from .media import MediaItem
+
+def get_files(self, interaction, files: list[str]) -> list[MediaItem]: ## works for all files
+    resolved = interaction.data.get("resolved")
+    attachments: dict[str] = resolved.get("attachments")
+
+    links = []
+    for id in files:
+        data = attachments.get(id)
+        if data:
+            links.append(data.get("url"))
+
+    media = []
+
+    for link in links:
+        item = MediaItem(
+            nextcord.UnfurledMedia(link)
+        )
+            
+        media.append(item)
+
+    return media
+
+def get_gallery(self, interaction: Interaction, files: list[str]) -> Gallery: ## this only works for images
+    media = get_files(self, interaction, files)
+    return Gallery(media)
+
+class FileUpload(ComponentV2):
+    def __init__(self, custom_id: str, min_values: int = None, max_values: int = None, required: bool = True, id = None):
+        if min_values and (min_values < 0 or min_values > 10):
+            raise ValueError("min_values must be between 0-10.")
+        
+        if max_values and (max_values < 1 or max_values > 10):
+            raise ValueError("max_values must be between 1-10.")
+
+        if required == True and min_values and min_values < 1:
+            raise ValueError("min_values must be ommited or >= 1 when required is omitted or True!")
+
+        super().__init__(19, id)
+
+        self.custom_id = custom_id
+        self.min_values = min_values
+        self.max_values = max_values
+        self.required = required
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        base_dict["min_values"] = self.min_values
+        base_dict["max_values"] = self.max_values
+        base_dict["custom_id"] = self.custom_id
+        base_dict["required"] = self.required
+
+        return base_dict

componentsv2/components/gallery.py

@@ -0,0 +1,24 @@
+from nextcord import UnfurledMedia
+from .base import ComponentV2
+from.media import MediaItem
+
+class MediaGallery(ComponentV2):
+    def __init__(self, items: list[MediaItem], id = None):
+        if len(items) < 1 or len(items) > 10:
+            raise ValueError("List of Media Items must be within the range 1-10.")
+
+        super().__init__(12, id)
+        self.items = items
+
+        self.__container_compatible__ = True
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        items = []
+        for media in self.items:
+            items.append(media.serialize())
+        
+        base_dict["items"] = items
+
+        return base_dict

componentsv2/components/holders/container.py

@@ -0,0 +1,55 @@
+from .nestable import Nestable
+from ..base import ComponentV2
+
+from ..action_row import ActionRow
+
+from typing import Optional
+
+class Container(Nestable):
+    def __init__(self, components: list[ComponentV2] = [], accent_color: int = None, spoiler: bool = None, id: Optional[int] = None):
+        for component in components:
+            if hasattr(component, "__container_compatible__") == False:
+                raise TypeError(f"Component {component.__class__.__name__} not accepted in Containers!")
+        
+        super().__init__(17, id, components)
+        
+        self.accent_color = accent_color
+        self.spoiler = spoiler
+        
+    def get_row(self, row: int) -> tuple[int, ActionRow]:
+        total_rows = -1
+
+        for component in self.components:
+            if isinstance(component, ActionRow) and total_rows == row:
+                return total_rows, component
+            elif isinstance(component, ActionRow):
+                total_rows += 1
+
+        return total_rows, None 
+
+    def append_component(self, component: ComponentV2): # chained
+        if hasattr(component, "row"):
+            row, action_row = self.get_row(component.row)
+
+            if action_row != None:
+                action_row.append_component(component)
+                return self
+            elif row + 1 == component.row:
+                action_row = ActionRow()
+                action_row.append_component(component)
+
+                return self.append_component(action_row)
+            else:
+                IndexError("Action rows must be created sequentially!")
+
+        self.components.append(component)
+
+        return self
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        base_dict["accent_color"] = self.accent_color
+        base_dict["spoiler"] = self.spoiler
+
+        return base_dict

componentsv2/components/holders/label.py

@@ -0,0 +1,19 @@
+from ..base import ComponentV2
+
+class Label(ComponentV2):
+    def __init__(self, label: str, component: ComponentV2, description: str = None, id: int = None):
+        super().__init__(18, id)
+
+        self.label = label
+
+        self.component = component
+        self.description = description
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        base_dict["label"] = self.label
+        base_dict["component"] = self.component.serialize()
+        base_dict["description"] = self.description
+
+        return base_dict

componentsv2/components/holders/nestable.py

@@ -0,0 +1,22 @@
+from ..base import ComponentV2
+from typing import Optional
+
+class Nestable(ComponentV2): ## a 'Nestable' base class is able to nest other components inside of itself. Action rows are intentionally left out of this class, as it exclusive for ComponentsV2.
+    def __init__(self, type: int, id: Optional[int] = None, components: list[ComponentV2] = []):
+        super().__init__(type, id)
+
+        self.components = components
+
+    def to_component_list(self):
+        components = []
+
+        for component in self.components:
+            components.append(component.serialize())
+
+        return components
+    
+    def serialize(self):
+        base_dict = super().serialize()
+        base_dict["components"] = self.to_component_list()
+        
+        return base_dict

componentsv2/components/holders/section.py

@@ -0,0 +1,20 @@
+from .nestable import Nestable
+from ..base import ComponentV2
+
+from typing import Optional
+
+class Section(Nestable):
+    def __init__(self, components: list[ComponentV2], accessory: ComponentV2, id: Optional[int] = None):
+        if len(components) < 1 or len(components) > 3:
+            raise ValueError("Section can only take 1-3 components and cannot have an empty components table!")
+        
+        super().__init__(9, id, components)
+        self.accessory = accessory
+
+        self.__container_compatible__ = True
+
+    def serialize(self):
+        base_dict = super().serialize()
+        base_dict["accessory"] = self.accessory.serialize()
+
+        return base_dict

componentsv2/components/media.py

@@ -0,0 +1,44 @@
+from nextcord import UnfurledMedia
+
+from .base import ComponentV2
+
+class MediaItem():
+    def __init__(self, media: UnfurledMedia, description: str = None, spoiler: bool = None):
+        self.media = media
+        self.description = description
+        self.spoiler = spoiler
+
+    def serialize(self):
+        return {
+            "media": self.media.to_dict(),
+            "description": self.description,
+            "spoiler": self.spoiler,
+        }
+
+class Thumbnail(ComponentV2, MediaItem):
+    def __init__(self, media: UnfurledMedia, description: str = None, spoiler: bool = None, id: int = None):
+        ComponentV2.__init__(self, 11, id)
+        MediaItem.__init__(self, media, description, spoiler)
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        base_dict["media"] = self.media.to_dict()
+        base_dict["description"] = self.description
+        base_dict["spoiler"] = self.spoiler
+
+        return base_dict
+    
+class File(ComponentV2, MediaItem):
+    def __init__(self, file: UnfurledMedia, id = None):
+        ComponentV2.__init__(13, id)
+        MediaItem.__init__(self, file)
+
+        self.__container_compatible__ = True
+
+    def serialize(self):
+        return {
+            "file": self.media.to_dict(),
+            "description": self.description,
+            "spoiler": self.spoiler,
+        }

componentsv2/components/radio_group.py

@@ -0,0 +1,35 @@
+from .base import ComponentV2
+
+class RadioGroup(ComponentV2):
+    class Option():
+        def __init__(self, value: str, label: str):
+            self.value = value
+            self.label = label
+
+        def serialize(self):
+            return {
+                "value": self.value,
+                "label": self.label
+            }
+    
+    def __init__(self, custom_id: str, options: list[Option], required: bool = None, id: int = None):
+        super().__init__(21, id)
+
+        self.custom_id = custom_id
+        self.options = options
+
+        self.required = required
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        radio_options = []
+
+        for option in self.options:
+            radio_options.append(option.serialize())
+        
+        base_dict["custom_id"] = self.custom_id
+        base_dict["options"] = radio_options
+        base_dict["required"] = self.required
+
+        return base_dict

componentsv2/components/select.py

@@ -0,0 +1,302 @@
+import nextcord
+from nextcord import Interaction
+
+from .base import ComponentV2
+from ..utils.serialize import serialize_emoji
+
+class DefaultValue():
+    def __init__(self, id: str, type: str):
+        self.id = id
+        self.type = type
+
+    def serialize(self):
+        return {
+            "id": self.id,
+            "type": self.type
+        }
+
+class SelectObject(ComponentV2):
+    def __init__(self, type: int, custom_id: str, placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False, row: int = 0):
+        if min_values != None and required == True and min_values < 1:
+            raise ValueError("Required cannot be true if min_values is less than 1!")
+        
+        super().__init__(type)
+        
+        self.custom_id = custom_id
+        self.placeholder = placeholder
+        self.min_values = min_values
+        self.max_values = max_values
+        self.required = required
+        self.disabled = disabled
+        self.row = row
+
+        self.callback = None
+        self.registered = False
+
+    def serialize(self):   
+        return {
+            "type": self.type,
+            "id": self.id,
+            "custom_id": self.custom_id,
+            "placeholder": self.placeholder,
+            "min_values": self.min_values,
+            "max_values": self.max_values,
+            "required": self.required,
+            "disabled": self.disabled
+        }
+    
+    def __call__(self, func):
+        if self.registered == True:
+            raise ValueError("Cannot register a Select component to multiple callbacks!")
+        
+        self.registered = True
+        self.callback = func
+
+        return self
+
+class StringSelect(SelectObject):
+    class SelectOption():
+        def __init__(self, label: str, value: str, description: str = None, emoji: nextcord.PartialEmoji = None, default: bool = False):
+            self.label = label
+            self.value = value
+            self.description = description
+            self.emoji = emoji
+            self.default = default
+
+        def serialize(self):
+            emoji = None if self.emoji == None else serialize_emoji(self.emoji)
+            return {
+                "label": self.label,
+                "value": self.value,
+                "description": self.description,
+                "default": self.default,
+                "emoji": emoji,
+            }
+
+
+    def __init__(self, custom_id: str, options: list[SelectOption], placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False, row: int = 0):
+        super().__init__(3, custom_id, placeholder, min_values, max_values, required, disabled, row)
+        
+        self.options = options
+        self.placeholder = placeholder
+
+    def serialize(self):   
+        str_options: list[dict[str]] = []
+        for option in self.options:
+            str_options.append(option.serialize())
+        
+        base_dict = super().serialize()
+        base_dict["options"] = str_options
+
+        return base_dict
+
+    async def activated(self, interaction: Interaction):
+        if self.disabled == True:
+            return
+        
+        if self.registered == False:
+            raise ValueError("Attempted to activate Select component, but it is not registered to a callback!")
+        
+        values = interaction.data.get("values")
+        
+        await self.callback(self.parent_holder, self, interaction, values)
+
+## DEFAULT VALUE OBJECTS (might create ANOTHER subclass to handle these fellas)
+class UserSelect(SelectObject):
+    def __init__(self, custom_id: str, default_values: list[DefaultValue] = None, placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False, row: int = 0):
+        if default_values != None:
+            values = len(default_values)
+
+            min = min_values or 1
+            max = max_values or 1
+
+            if min > values or max < values:
+                raise ValueError("The length of 'default_values' MUST be within the range of min_values and max_values (default 1-1).")
+        
+        super().__init__(5, custom_id, placeholder, min_values, max_values, required, disabled, row)
+        
+        self.default_values = default_values
+        self.placeholder = placeholder
+
+    def serialize(self):   
+        if self.default_values != None:
+            str_values: list[dict[str]] = []
+            for value in self.default_values:
+                str_values.append(value.serialize())
+        else:
+            str_values = None
+            
+        base_dict = super().serialize()
+        base_dict["default_values"] = str_values
+
+        return base_dict
+
+    async def activated(self, interaction: Interaction):
+        if self.disabled == True:
+            return
+        
+        if self.registered == False:
+            raise ValueError("Attempted to activate Select component, but it is not registered to a callback!")
+        
+        values = interaction.data.get("values")
+        await self.callback(self.parent_holder, self, interaction, values) ## due to a nextcord limitation, i am only able to send the list of ids, not user objects.
+
+class RoleSelect(SelectObject):
+    def __init__(self, custom_id: str, default_values: list[DefaultValue] = None, placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False, row: int = 0):
+        if default_values != None:
+            values = len(default_values)
+
+            min = min_values or 1
+            max = max_values or 1
+
+            if min > values or max < values:
+                raise ValueError("The length of 'default_values' MUST be within the range of min_values and max_values (default 1-1).")
+        
+        super().__init__(6, custom_id, placeholder, min_values, max_values, required, disabled, row)
+        
+        self.default_values = default_values
+        self.placeholder = placeholder
+
+    def serialize(self):   
+        if self.default_values != None:
+            str_values: list[dict[str]] = []
+            for value in self.default_values:
+                str_values.append(value.serialize())
+        else:
+            str_values = None
+            
+        base_dict = super().serialize()
+        base_dict["default_values"] = str_values
+
+        return base_dict
+
+    async def activated(self, interaction: Interaction):
+        if self.disabled == True:
+            return
+        
+        if self.registered == False:
+            raise ValueError("Attempted to activate Select component, but it is not registered to a callback!")
+        
+        values = interaction.data.get("values")
+        await self.callback(self.parent_holder, self, interaction, values) ## due to a nextcord limitation, i am only able to send the list of values, not user objects.
+
+class MentionableSelect(SelectObject):
+    def __init__(self, custom_id: str, default_values: list[DefaultValue] = None, placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False, row: int = 0):
+        if default_values != None:
+            values = len(default_values)
+
+            min = min_values or 1
+            max = max_values or 1
+
+            if min > values or max < values:
+                raise ValueError("The length of 'default_values' MUST be within the range of min_values and max_values (default 1-1).")
+        
+        super().__init__(7, custom_id, placeholder, min_values, max_values, required, disabled, row)
+        
+        self.default_values = default_values
+        self.placeholder = placeholder
+
+    def serialize(self):   
+        if self.default_values != None:
+            str_values: list[dict[str]] = []
+            for value in self.default_values:
+                str_values.append(value.serialize())
+        else:
+            str_values = None
+            
+        base_dict = super().serialize()
+        base_dict["default_values"] = str_values
+
+        return base_dict
+
+    async def activated(self, interaction: Interaction):
+        if self.disabled == True:
+            return
+        
+        if self.registered == False:
+            raise ValueError("Attempted to activate Select component, but it is not registered to a callback!")
+        
+        values = interaction.data.get("values")
+        await self.callback(self.parent_holder, self, interaction, values) ## due to a nextcord limitation, i am only able to send the list of values, not user objects.
+
+class ChannelSelect(SelectObject):
+    def __init__(self, custom_id: str, default_values: list[DefaultValue] = None, channel_types: list[nextcord.ChannelType] = None, placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False, row: int = 0):
+        if default_values != None:
+            values = len(default_values)
+
+            min = min_values or 1
+            max = max_values or 1
+
+            if min > values or max < values:
+                raise ValueError("The length of 'default_values' MUST be within the range of min_values and max_values (default 1-1).")
+            
+        if channel_types != None:
+            channel_values = []
+            for type in channel_types:
+                channel_values.append(type.value)
+        else:
+            channel_values = None
+
+        self.channel_types = channel_values
+        super().__init__(8, custom_id, placeholder, min_values, max_values, required, disabled, row)
+        
+        self.default_values = default_values
+        self.placeholder = placeholder
+
+    def serialize(self):   
+        if self.default_values != None:
+            str_values: list[dict[str]] = []
+            for value in self.default_values:
+                str_values.append(value.serialize())
+        else:
+            str_values = None
+            
+        base_dict = super().serialize()
+        base_dict["default_values"] = str_values
+        base_dict["channel_types"] = self.channel_types
+
+        return base_dict
+
+    async def activated(self, interaction: Interaction):
+        if self.disabled == True:
+            return
+        
+        if self.registered == False:
+            raise ValueError("Attempted to activate Select component, but it is not registered to a callback!")
+        
+        values = interaction.data.get("values")
+        await self.callback(self.parent_holder, self, interaction, values) ## due to a nextcord limitation, i am only able to send the list of values, not user objects.
+
+## UI SELECTS
+class UISelectObject(SelectObject):
+    def __init__(self, type: int, custom_id: str, placeholder: str = None, min_values: int = None, max_values: int = None, required: int = True, disabled: int = False):
+        super().__init__(type, custom_id, placeholder, min_values, max_values, required, disabled)
+
+    async def activated(self, interaction):
+        if self.disabled == True:
+            return
+        
+        await self.ui_callback(interaction)
+
+    async def ui_callback(self, interaction: Interaction):
+        pass
+
+class UIStringSelect(UISelectObject, StringSelect):
+    def __init__(self, custom_id: str, options: list[StringSelect.SelectOption], placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False):
+        StringSelect.__init__(self, custom_id, options, placeholder, min_values, max_values, required, disabled)
+
+class UIUserSelect(UISelectObject, UserSelect):
+    def __init__(self, custom_id: str, default_values: list[DefaultValue] = None, placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False):
+        UserSelect.__init__(self, custom_id, default_values, placeholder, min_values, max_values, required, disabled)
+
+class UIRoleSelect(UISelectObject, RoleSelect):
+    def __init__(self, custom_id: str, default_values: list[DefaultValue] = None, placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False):
+        RoleSelect.__init__(self, custom_id, default_values, placeholder, min_values, max_values, required, disabled)
+
+class UIChannelSelect(UISelectObject, ChannelSelect):
+    def __init__(self, custom_id: str, default_values: list[DefaultValue] = None, placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False):
+        ChannelSelect.__init__(self, custom_id, default_values, placeholder, min_values, max_values, required, disabled)
+
+class UIMentionableSelect(UISelectObject, MentionableSelect):
+    def __init__(self, custom_id: str, default_values: list[DefaultValue] = None, placeholder: str = None, min_values: int = None, max_values: int = None, required: bool = True, disabled: bool = False):
+        MentionableSelect.__init__(self, custom_id, default_values, placeholder, min_values, max_values, required, disabled)

componentsv2/components/separator.py

@@ -0,0 +1,21 @@
+from .base import ComponentV2
+
+class Separator(ComponentV2):
+    def __init__(self, divider: bool = None, spacing: int = None, id = None):
+        if spacing != None and (spacing > 2 or spacing < 1):
+            raise ValueError("Spacing can only be 1-2! 1: small padding, 2: large padding.")
+        
+        super().__init__(14, id)
+
+        self.divider = divider
+        self.spacing = spacing
+
+        self.__container_compatible__ = True
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        base_dict["divider"] = self.divider
+        base_dict["spacing"] = self.spacing
+
+        return base_dict

componentsv2/components/text_display.py

@@ -0,0 +1,16 @@
+from .base import ComponentV2
+from typing import Optional
+
+class TextDisplay(ComponentV2):
+    def __init__(self, content: str, id: Optional[int] = None):
+        super().__init__(10, id)
+
+        self.content = content
+        
+        self.__container_compatible__ = True
+
+    def serialize(self):
+        base_dict = super().serialize()
+        base_dict["content"] = self.content
+
+        return base_dict

componentsv2/components/text_input.py

@@ -0,0 +1,31 @@
+import nextcord
+from .base import ComponentV2
+
+class TextInput(ComponentV2):
+    def __init__(self, custom_id: str, style: nextcord.TextInputStyle, min_length: int = None, max_length: int = None, required: bool = None, set_value: str = None, placeholder: str = None, id: int = None):
+        super().__init__(4, id)
+
+        self.custom_id = custom_id
+        self.style = style
+        self.min_length = min_length
+        self.max_length = max_length
+
+        self.required = required
+        self.set_value = set_value
+        self.placeholder = placeholder
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        base_dict["custom_id"] = self.custom_id
+        base_dict["style"] = self.style.value
+
+        base_dict["min_length"] = self.min_length
+        base_dict["max_length"] = self.max_length
+
+        base_dict["required"] = self.required
+        base_dict["value"] = self.value
+
+        base_dict["placeholder"] = self.placeholder
+
+        return base_dict

componentsv2/components.py

@@ -0,0 +1,20 @@
+from .components import (
+    action_row,
+    base,
+    button,
+    checkbox,
+    file_upload,
+    gallery,
+    media,
+    radio_group,
+    select,
+    separator,
+    text_display,
+    text_input,
+)
+
+from.components.holders import (
+    container,
+    label,
+    section
+)

componentsv2/utils/serialize.py

@@ -0,0 +1,8 @@
+import nextcord
+
+def serialize_emoji(emoji: nextcord.PartialEmoji):
+    return {
+        "name": emoji.name,
+        "id": emoji.id,
+        "animated": getattr(emoji, "animated", False)
+    }

componentsv2/wrapper.py

@@ -0,0 +1,103 @@
+import nextcord
+import json
+import copy
+
+from nextcord.ext import commands
+from nextcord import Interaction
+from typing import Optional
+
+from nextcord import MessageFlags
+
+## CLASSES
+from .components.base import ComponentV2
+from .components.action_row import ActionRow
+from .components.button import ButtonV2
+
+from .components.select import (
+    StringSelect,
+)
+
+from .component_holder import (
+    ComponentHolder,
+    ModalV2,
+)
+
+from .components.holders.label import Label
+
+class NextcordAPIWrapperV2():
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+        self.active_holders = {}
+        self.active_modals = {}
+
+        bot.add_listener(self.on_interaction, "on_interaction")
+
+    async def on_interaction(self, interaction: Interaction):
+        if interaction.type == nextcord.InteractionType.component:
+            holder: ComponentHolder = self.active_holders.get(str(interaction.message.id))
+            if holder != None:
+                component = holder.get_component(interaction.data.get("custom_id"))
+                if component != None:
+                    await component.activated(interaction)
+        elif interaction.type == nextcord.InteractionType.modal_submit:
+            modal: ModalV2 = self.active_modals.get(interaction.user.id)
+            if modal != None:
+                await modal.submitted(interaction, interaction.data.get("components"))
+    
+    def __message_interaction_payload(self, components: list[ComponentV2], content: str = None, flags: int = None) -> dict[str]:
+        return {
+            "type": 4, # update your FUCKING docs discord
+            "data": {
+                "flags": flags,
+                "content": content,
+                "components": components
+            }
+        }
+
+    def __edit_interaction_payload(self, components: list[ComponentV2], content: str = None) -> dict[str]:
+        return {
+            "type": 7, # update your FUCKING docs discord
+            "data": {
+                "content": content,
+                "components": components
+            }
+        }
+    
+    async def send_modal(self, interaction: Interaction, modal: ModalV2):
+        self.active_modals[interaction.user.id] = modal
+
+        await self.bot.http.request(
+            nextcord.http.Route("POST", f"/interactions/{interaction.id}/{interaction.token}/callback"),
+            json = modal.serialize()
+        )
+
+    async def send_message(self, interaction: Interaction, component_holder: ComponentHolder, content: str = None, *, ephemeral: bool = False, is_components_v2: bool = False):
+        if is_components_v2 == True and content != None:
+            raise TypeError("ComponentsV2 messages cannot contain content!")
+        
+        flags = MessageFlags(ephemeral=ephemeral, is_components_v2=is_components_v2).value
+        response = await self.bot.http.request(
+            nextcord.http.Route("POST", f"/interactions/{interaction.id}/{interaction.token}/callback?with_response=true"),
+            json=self.__message_interaction_payload(components=component_holder.serialize(), content=content, flags=flags)
+        )
+
+        self.active_holders[response["interaction"]["response_message_id"]] = component_holder
+
+    async def send_followup(self, interaction: Interaction, component_holder: ComponentHolder, content: str = None, *, ephemeral: bool = False, is_components_v2: bool = False):
+        if is_components_v2 == True and content != None:
+            raise TypeError("ComponentsV2 messages cannot contain content!")
+
+        flags = MessageFlags(ephemeral=ephemeral, is_components_v2=is_components_v2).value
+        response = await self.bot.http.request(
+            nextcord.http.Route("POST", f"/webhooks/{interaction.application_id}/{interaction.token}"),
+            json={"components": component_holder.serialize(), "content": content, "flags": flags}
+        )
+
+        self.active_holders[response["id"]] = component_holder
+
+    async def edit_message(self, interaction: Interaction, component_holder: ComponentHolder, content: str = None):
+        await self.bot.http.request(
+            nextcord.http.Route("POST", f"/interactions/{interaction.id}/{interaction.token}/callback"),
+            json=self.__edit_interaction_payload(components=component_holder.serialize(), content=content)
+        )

componentsv2-0.2.2.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: componentsv2
+Version: 0.2.2
+License-File: LICENSE.txt
+Requires-Dist: nextcord
+Dynamic: license-file

componentsv2-0.2.2.dist-info/RECORD

@@ -0,0 +1,29 @@
+componentsv2/__init__.py,sha256=yXlmXdZMb0JLI7Z8A3Qo_mNt8h0gVtGKM9s8tAxtUgg,241
+componentsv2/component_holder.py,sha256=x7O5EH3lHefwXeeAVnchDzH6fisaBw6eku-0Ulrok8U,7003
+componentsv2/components.py,sha256=DlyZaQ3E3L_YMiyz6tB5Pe33mc_K4-g3q_meCr8hFpg,291
+componentsv2/wrapper.py,sha256=U-3yyfrpoxF2Unri8hBg-FsabHwG6SQQaz4V3l8RNYY,4412
+componentsv2/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+componentsv2/components/action_row.py,sha256=bhErre3kMk_l9kshdynazFqWZkTnRjPk0KzWF6WScs4,1367
+componentsv2/components/base.py,sha256=Oq6QZynkMoQaM8tPzj9IR373puhlrmKxV4u_gTDUxk0,423
+componentsv2/components/button.py,sha256=_a8snX-qX1N_vv8NX2tSe3c8EGSxKO1KuX5MJvmyYBQ,2589
+componentsv2/components/checkbox.py,sha256=1RRSwqTLTSIv4pxG-LsEORzF6QicFBugvu56khteScw,1992
+componentsv2/components/file_upload.py,sha256=bh-RA-pb5AJAuLMDXiW3hy8mArIHgJQfLsMrIui9VU4,1948
+componentsv2/components/gallery.py,sha256=HIcMLwgjJk00AEjGKgC0-zXkgZYBr7KRJlzUCBE7suk,677
+componentsv2/components/media.py,sha256=gElgj_R4nojhJMqkf8Bh6MI7eRq6B2_vkvCtWQTkfCE,1387
+componentsv2/components/radio_group.py,sha256=-tcP4THx5e5iuaNfK8Gxl8CyjUibaqFcVRO_QMgVoKQ,966
+componentsv2/components/select.py,sha256=vNhEDDXPBifTk8tVPBFQ3zbQjpbsYgDFTRXpEBCgtp4,13274
+componentsv2/components/separator.py,sha256=I-MvlXXrkL2Bsf9EmoMgLjdHqE7ZuDZXj1MM6VGm48U,644
+componentsv2/components/text_display.py,sha256=HRPrvdOMGHcmL5dEkB4p4vqcRVj6hixbt38_LrwDsCc,424
+componentsv2/components/text_input.py,sha256=QijHphwNt58c3C6RfdXnb2yCQAXlPGS73PGLxRgOKdo,1018
+componentsv2/components/holders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+componentsv2/components/holders/container.py,sha256=dpbObx1I7IGgbdrBM0ljISeNTkI5JmwjPClL8V14hhw,1882
+componentsv2/components/holders/label.py,sha256=Ji-98ZNxnEf5zNffU7qNN_MSLT3-4QJvSfgrwRTTpkc,557
+componentsv2/components/holders/nestable.py,sha256=b-NHokuXTgsN_raUNcBliBVlT_OfznHlCfvMtd_rMZc,789
+componentsv2/components/holders/section.py,sha256=WsbiDO2Sqz1uw1csXvwMOnnkguVtXLZCyFz2U_JJrRE,693
+componentsv2/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+componentsv2/utils/serialize.py,sha256=KQIGiUfU58jbrHe_A8MoB6n2wO6wttLk0F_Mcd5hIRk,199
+componentsv2-0.2.2.dist-info/licenses/LICENSE.txt,sha256=OXcweB55IB6gyLzI3-m9fezKOmbjn1-_0Rbmh3glT2A,1084
+componentsv2-0.2.2.dist-info/METADATA,sha256=vqlaDjCD2ytwHm3tuXb0uc_Hyc2wAszefnufyLol0Vw,134
+componentsv2-0.2.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+componentsv2-0.2.2.dist-info/top_level.txt,sha256=ip99yM9pVbDNhDGl9lW60dQlAQDZ_XOmOjqN8HJAFG4,13
+componentsv2-0.2.2.dist-info/RECORD,,

componentsv2-0.2.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

componentsv2-0.2.2.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 finnagen
+
+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.

componentsv2-0.2.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+componentsv2