componentsv2 0.3.1__tar.gz → 0.3.2__tar.gz

{componentsv2-0.3.1 → componentsv2-0.3.2}/PKG-INFO

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

componentsv2-0.3.2/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-0.3.2/componentsv2/component_holder.py

@@ -0,0 +1,213 @@
+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, title: str, custom_id: str = None):
+        
+        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)
+
+    def on_submit_decorator(self, func):
+        self.on_form_submit = func
+
+    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-0.3.2/componentsv2/components/action_row.py

@@ -0,0 +1,51 @@
+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, components: list[ComponentV2] = [], id: Optional[int] = None):
+        super().__init__(1, id)
+
+        self.component_type: Optional[int] = None
+        self.components: list[ComponentV2] = components
+
+        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)
+        return self
+    
+    def append_components(self, *args: ComponentV2):
+        components = list(args)
+
+        for component in components:
+            self.append_component(component)

componentsv2-0.3.2/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.3.2/componentsv2/components/button.py

@@ -0,0 +1,82 @@
+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
+
+        self.__has_holder = None
+
+    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 on_callback(self, func):
+        if self.registered == True:
+            raise ValueError("Buttons cannot be registered to multiple callbacks!")
+        
+        self.callback = func
+        self.registered = True
+
+        self.__has_holder = False
+
+        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!")
+        
+        if self.__has_holder != False:
+            await self.callback(self.parent_holder, self, interaction)
+        else:
+            await self.callback(interaction)

componentsv2-0.3.2/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.3.2/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.3.2/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.3.2/componentsv2/components/holders/container.py

@@ -0,0 +1,81 @@
+from .nestable import Nestable
+from ..base import ComponentV2
+
+from ..action_row import ActionRow
+from ..text_display import TextDisplay
+
+from typing import Optional
+
+class Container(Nestable):
+    def __init__(self, components: list[ComponentV2] = None, accent_color: int = None, spoiler: bool = None, id: Optional[int] = None):
+        if components is None:
+            components = []
+
+        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
+
+        self.footer = None
+        
+    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:
+                raise IndexError("Action rows must be created sequentially!")
+
+        self.components.append(component)
+
+        if self.footer is not None:
+            self.components.remove(self.footer)
+            self.components.append(self.footer)
+
+        return self
+    
+    def add_field(self, title: str, content: str):
+        return self.append_component(
+            TextDisplay(
+                f"**{title}**\n{content}"
+            )
+        )
+
+    def set_footer(self, footer: str):
+        if self.footer is not None:
+            self.components.remove(self.footer)
+
+        self.footer = TextDisplay(f"-# {footer}")
+        self.components.append(
+            self.footer
+        )
+
+    def serialize(self):
+        base_dict = super().serialize()
+
+        base_dict["accent_color"] = self.accent_color
+        base_dict["spoiler"] = self.spoiler
+
+        return base_dict

componentsv2-0.3.2/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.3.2/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.3.2/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