componentsv2 0.2.0__tar.gz → 0.2.1__tar.gz

{componentsv2-0.2.0 → componentsv2-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: componentsv2
-Version: 0.2.0
+Version: 0.2.1
 License: MIT
 License-File: LICENSE.txt
 Requires-Dist: nextcord

componentsv2-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.1/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-0.2.0 → componentsv2-0.2.1}/componentsv2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: componentsv2
-Version: 0.2.0
+Version: 0.2.1
 License: MIT
 License-File: LICENSE.txt
 Requires-Dist: nextcord

componentsv2-0.2.1/componentsv2.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+LICENSE.txt
+README.md
+setup.cfg
+setup.py
+componentsv2/__init__.py
+componentsv2/component_holder.py
+componentsv2/components.py
+componentsv2/wrapper.py
+componentsv2.egg-info/PKG-INFO
+componentsv2.egg-info/SOURCES.txt
+componentsv2.egg-info/dependency_links.txt
+componentsv2.egg-info/requires.txt
+componentsv2.egg-info/top_level.txt
+componentsv2/components/__init__.py
+componentsv2/components/action_row.py
+componentsv2/components/base.py
+componentsv2/components/button.py
+componentsv2/components/checkbox.py
+componentsv2/components/file_upload.py
+componentsv2/components/gallery.py
+componentsv2/components/media.py
+componentsv2/components/radio_group.py
+componentsv2/components/select.py
+componentsv2/components/separator.py
+componentsv2/components/text_display.py
+componentsv2/components/text_input.py
+componentsv2/components/holders/__init__.py
+componentsv2/components/holders/container.py
+componentsv2/components/holders/label.py
+componentsv2/components/holders/nestable.py
+componentsv2/components/holders/section.py
+componentsv2/utils/__init__.py
+componentsv2/utils/serialize.py

{componentsv2-0.2.0 → componentsv2-0.2.1}/setup.py

@@ -1,8 +1,8 @@
-from setuptools import setup
+from setuptools import setup, find_packages
 setup(
   name = 'componentsv2',         # How you named your package folder (MyLib)
-  packages = ['componentsv2'],   # Chose the same as "name"
-  version = '0.2.0',      # Start with a small number and increase it with every change you make
+  packages = find_packages(),   # Chose the same as "name"
+  version = '0.2.1',      # Start with a small number and increase it with every change you make
   license='MIT',
   install_requires=[
       "nextcord",

componentsv2-0.2.0/componentsv2.egg-info/SOURCES.txt

@@ -1,13 +0,0 @@
-LICENSE.txt
-README.md
-setup.cfg
-setup.py
-componentsv2/__init__.py
-componentsv2/component_holder.py
-componentsv2/components.py
-componentsv2/wrapper.py
-componentsv2.egg-info/PKG-INFO
-componentsv2.egg-info/SOURCES.txt
-componentsv2.egg-info/dependency_links.txt
-componentsv2.egg-info/requires.txt
-componentsv2.egg-info/top_level.txt