scurrypy 0.1.0__py3-none-any.whl

discord/models/guild.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from typing import Optional
+from ..model import DataModel
+from .emoji import EmojiModel
+
+@dataclass
+class ReadyGuildModel(DataModel):
+    """Guild info from Ready event."""
+    id: int
+    """ID of the associated guild."""
+
+    unavailable: bool
+    """If the guild is offline."""
+
+@dataclass
+class GuildModel(DataModel):
+    """Represents a Discord guild."""
+
+    id: int
+    """ID of the guild."""
+
+    name: str
+    """Name of the guild."""
+
+    icon: Optional[str] = None
+    """Icon hash of the guild."""
+
+    emojis: list[EmojiModel] = None
+    """List of emojis reigstered in the guild."""
+
+    approximate_member_count: Optional[int] = None
+    """Approximate member count."""
+
+    description: str = None
+    """Description of the guild."""

discord/models/integration.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Optional
+from ..model import DataModel
+from .application import ApplicationModel
+
+@dataclass
+class IntegrationModel(DataModel):
+    """Represents a guild integration."""
+
+    id: int
+    """ID of the integration."""
+
+    name: str
+    """Name of the integration."""
+
+    type: str
+    """Type of integration (e.g., twitch, youtube, discord, or guild_subscription)."""
+
+    enabled: bool
+    """If the integration is enabled."""
+
+    application: Optional[ApplicationModel] = None
+    """The bot aaplication for Discord integrations."""

discord/models/member.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from ..model import DataModel
+from ..models.user import UserModel
+
+@dataclass
+class MemberModel(DataModel):
+    """Represents a guild member."""
+
+    roles: list[int]
+    """List of roles registered to the guild member."""
+
+    user: UserModel
+    """User data associated with the guild member."""
+
+    nick: str
+    """Server nickname of the guild member."""
+
+    avatar: str
+    """Server avatar hash of the guild mmeber."""
+
+    joined_at: str
+    """ISO8601 timestamp of when the guild member joined server."""
+    deaf: bool
+    """If the member is deaf in a VC (input)."""
+
+    mute: bool
+    """If the member is muted in VC (output)."""

discord/models/role.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass
+from typing import Optional
+from ..model import DataModel
+
+@dataclass
+class RoleColors(DataModel):
+    """Role color data."""
+
+    primary_color: int
+    """Primary color of the role."""
+
+    secondary_color: int
+    """Secondary color of the role. Creates a gradient."""
+
+    tertiary_color: int
+    """Tertiary color of the role. Creates a holographic style."""
+
+@dataclass
+class RoleModel(DataModel):
+    """Represents a Discord role."""
+
+    id: int
+    """ID of the role."""
+
+    name: str
+    """Name of the role."""
+
+    colors: RoleColors
+    """Colors of the role."""
+
+    hoist: bool
+    """If the role is pinned in user listing."""
+
+    position: int
+    """Position of the role."""
+
+    permissions: str
+    """Permission bit set."""
+
+    managed: bool
+    """If the role is managed by an integration."""
+
+    mentionable: bool
+    """If the role is mentionable."""
+
+    flags: int
+    """Role flags combined as a bitfield."""
+
+    icon: Optional[str] = None
+    """Icon hash of the role."""
+
+    unicode_emoji: Optional[str] = None
+    """Unicode emoji of the role."""

discord/models/user.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+from ..model import DataModel
+
+@dataclass
+class UserModel(DataModel):
+    """Describes the User object."""
+    id: int
+    """ID of the user."""
+
+    username: str
+    """Username of the user."""
+
+    avatar: str
+    """Avatar hash of the user."""

discord/parts/__init__.py

@@ -0,0 +1,28 @@
+# discord/parts
+
+from .channel import GuildChannel
+from .role import Role
+from .message import MessageBuilder
+from .modal import ModalBuilder
+from .embed import EmbedBuilder
+from .action_row import (
+    ActionRow, 
+    StringSelect,
+    UserSelect,
+    RoleSelect,
+    ChannelSelect,
+    MentionableSelect
+)
+
+from .command import (
+    SlashCommand, 
+    MessageCommand, 
+    UserCommand
+)
+
+from .components_v2 import (
+    Container,
+    Section,
+    MediaGalleryItem,
+    Label
+)

discord/parts/action_row.py

@@ -0,0 +1,258 @@
+from dataclasses import dataclass, field
+from typing import Literal, Optional
+from ..model import DataModel
+
+from .component_types import *
+
+from ..models.emoji import EmojiModel
+
+class _ButtonStyles:
+    """Represents button styles for a Button component."""
+    PRIMARY = 1
+    SECONDARY = 2
+    SUCCESS = 3
+    DANGER = 4
+    LINK = 5
+
+@dataclass
+class _Button(DataModel, ActionRowChild, SectionAccessory):
+    """Represents the Button component."""
+    style: int
+    custom_id: str
+    label: Optional[str] = None
+    emoji: EmojiModel = None
+    url: Optional[str] = None
+    disabled: Optional[bool] = False
+    type: Literal[2] = field(init=False, default=2)
+
+@dataclass
+class _SelectOption(DataModel):
+    """Represents the Select Option component"""
+
+    label: str
+    value: str
+    description: Optional[str] = None # appears below the label
+    emoji: Optional[EmojiModel] = None
+    default: Optional[bool] = False
+
+@dataclass
+class StringSelect(DataModel, ActionRowChild, LabelChild):
+    """Represents the String Select component."""
+    custom_id: str
+    options: list[_SelectOption] = field(default_factory=list)
+    placeholder: Optional[str] = None
+    min_values: Optional[int] = 0
+    max_values: Optional[int] = 1
+    required: Optional[bool] = False
+    disabled: Optional[bool] = False # does not work on Modals!
+    type: Literal[3] = field(init=False, default=3)
+
+    def add_option(self,
+        *,
+        label: str,
+        value: str,
+        description: str = None,
+        emoji: str | EmojiModel = None,
+        default: bool = False
+    ):
+        """Add an option to this string select component.
+
+        Args:
+            label (str): option text
+            value (str): analogous to button's custom ID
+            description (str, optional): option subtext
+            emoji (str | EmojiModel, optional): string if unicode emoji, EmojiModel if custom
+            default (bool, optional): if this option should be the default option. Defaults to False.
+
+        Returns:
+            (StringSelect): self
+        """
+        if isinstance(emoji, str):
+            emoji = EmojiModel(name=emoji)
+
+        self.options.append(
+            _SelectOption(
+                label=label,
+                value=value,
+                description=description,
+                emoji=emoji,
+                default=default
+            )
+        )
+        return self
+
+@dataclass
+class _DefaultValue(DataModel):
+    """Represents the Default Value for Select components."""
+
+    id: int   # ID of role, user, or channel
+    type: Literal["role", "user", "channel"]
+
+@dataclass
+class UserSelect(DataModel, ActionRowChild):
+    """Represents the User Select component."""
+    custom_id: str
+    placeholder: Optional[str] = None
+    default_values: list[_DefaultValue] = field(default_factory=list)
+    min_values: Optional[int] = 0
+    max_values: Optional[int] = 1
+    disabled: Optional[bool] = False
+    type: Literal[5] = field(init=False, default=5)
+
+    def add_default_value(self, user_id: int):
+        self.default_values.append(_DefaultValue(user_id, 'user'))
+        return self
+
+@dataclass
+class RoleSelect(DataModel, ActionRowChild):
+    """Represents the Role Select component."""
+    custom_id: str
+    placeholder: Optional[str] = None
+    default_values: list[_DefaultValue] = field(default_factory=list)
+    min_values: Optional[int] = 0
+    max_values: Optional[int] = 1
+    disabled: Optional[bool] = False
+    type: Literal[6] = field(init=False, default=6)
+
+    def add_default_value(self, role_id: int):
+        self.default_values.append(_DefaultValue(role_id, 'role'))
+        return self
+
+@dataclass
+class MentionableSelect(DataModel, ActionRowChild):
+    """Represents the Mentionable Select component."""
+    custom_id: str
+    placeholder: Optional[str] = None
+    default_values: list[_DefaultValue] = field(default_factory=list)
+    min_values: Optional[int] = 0
+    max_values: Optional[int] = 1
+    disabled: Optional[bool] = False
+    type: Literal[7] = field(init=False, default=7)
+
+    def add_default_value(self, role_or_user_id: int, role_or_user: Literal['user', 'role']):
+        self.default_values.append(_DefaultValue(role_or_user_id, role_or_user))
+        return self
+
+@dataclass
+class ChannelSelect(DataModel, ActionRowChild):
+    """Represents the Channel Select component."""
+    custom_id: str
+    placeholder: Optional[str] = None
+    default_values: list[_DefaultValue] = field(default_factory=list)
+    min_values: Optional[int] = 0
+    max_values: Optional[int] = 1
+    disabled: Optional[bool] = False
+    type: Literal[8] = field(init=False, default=8)
+
+    def add_default_value(self, channel_id: int):
+        self.default_values.append(_DefaultValue(channel_id, 'channel'))
+        return self
+
+@dataclass
+class ActionRow(DataModel, ContainerChild):
+    """Represents a container of interactable components."""
+    type: Literal[1] = field(init=False, default=1)
+    components: list[ActionRowChild] = field(default_factory=list)
+
+    def add_button(self, 
+        *,
+        style: Literal['Primary', 'Secondary', 'Success', 'Danger', 'Link'],
+        label: str, 
+        custom_id: str,
+        emoji: str | EmojiModel = None,
+        disable: bool = False
+    ):
+        """Add a button to this action row. (5 per row)
+        
+        Args:
+            style (Literal['Primary', 'Secondary', 'Success', 'Danger', 'Link']): 
+                button style as a string
+            label (str): button text
+            custom_id (str): developer-defined button ID
+            emoji (str | EmojiModel, Optional): str if unicode emoji, EmojiModal if custom
+            disable (bool, Optional): if this button should be pressable. Defaults to False.
+
+        Returns:
+            (ActionRow): self
+        """
+        _styles = {
+            'PRIMARY': _ButtonStyles.PRIMARY,
+            'SECONDARY': _ButtonStyles.SECONDARY,
+            'SUCCESS': _ButtonStyles.SUCCESS,
+            'DANGER': _ButtonStyles.DANGER,
+            'LINK': _ButtonStyles.LINK
+        }
+
+        if isinstance(emoji, str):
+            emoji = EmojiModel(name=emoji)
+
+        self.components.append(
+            _Button(
+                style=_styles.get(style.upper()),
+                label=label,
+                custom_id=custom_id,
+                emoji=emoji,
+                disabled=disable
+            )
+        )
+        return self
+
+    def string_select(self, select: StringSelect):
+        """Add a string select to this action row. (1 per row)
+
+        Args:
+            select (StringSelect): the StringSelect option object
+
+        Returns:
+            (ActionRow): self
+        """
+        self.components.append(select)
+        return self
+    
+    def user_select(self, select: UserSelect):
+        """Add a user select to this action row. (1 per row)
+
+        Args:
+            select (UserSelect): the UserSelect option object
+
+        Returns:
+            (ActionRow): self
+        """
+        self.components.append(select)
+        return self
+    
+    def role_select(self, select: RoleSelect):
+        """Add a role select to this action row. (1 per row)
+
+        Args:
+            select (RoleSelect): the RoleSelect option object
+
+        Returns:
+            (ActionRow): self
+        """
+        self.components.append(select)
+        return self
+    
+    def channel_select(self, select: ChannelSelect):
+        """Add a channel select to this action row. (1 per row)
+
+        Args:
+            select (ChannelSelect): the ChannelSelect option object
+
+        Returns:
+            (ActionRow): self
+        """
+        self.components.append(select)
+        return self
+    
+    def mentionable_select(self, select: MentionableSelect):
+        """Add a mentionable select to this action row. (1 per row)
+
+        Args:
+            select (MentionableSelect): the MentionableSelect option object
+
+        Returns:
+            (ActionRow): self
+        """
+        self.components.append(select)
+        return self

discord/parts/attachment.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+
+from ..model import DataModel
+
+@dataclass
+class _Attachment(DataModel):
+    """Represents an attachment."""
+    id: int
+    path: str
+    filename: str
+    description: str
+
+    def _to_dict(self):
+        return {
+            'id': self.id,
+            'filename': self.filename,
+            'description': self.description
+        }

discord/parts/channel.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from typing import Optional
+from ..model import DataModel
+
+# NOTE: Supported Channel Types listed here
+class ChannelTypes:
+    """Constants for channel types."""
+    GUILD_TEXT = 0
+    GUILD_CATEGORY = 4
+    GUILD_ANNOUNCEMENT = 5
+
+@dataclass
+class GuildChannel(DataModel):
+    """Parameters for creating/editing a guild channel."""
+    name: Optional[str] = None
+    type: Optional[int] = None
+    topic: Optional[str] = None
+    position: Optional[int] = None
+    parent_id: Optional[int] = None
+    nsfw: Optional[bool] = None

discord/parts/command.py

@@ -0,0 +1,102 @@
+from dataclasses import dataclass, field
+from typing import Literal
+
+from ..model import DataModel
+
+class CommandOptionTypes:
+    """Slash command option input types."""
+
+    STRING = 3
+    """string (text)"""
+
+    INTEGER = 4
+    """integer (whole)"""
+
+    BOOLEAN = 5
+    """boolean (true/false)"""
+
+    USER = 6
+    """user pangination"""
+
+    CHANNEL = 7
+    """channel pangination"""
+
+    ROLE = 8
+    """role pangination"""
+
+    MENTIONABLE = 9
+    """any pangination (role, channel, user)"""
+
+    NUMBER = 10
+    """number (float, integer)"""
+
+    ATTACHMENT = 11
+    """file upload"""
+
+@dataclass
+class MessageCommand(DataModel):
+    """Represents the message command object."""
+    type: Literal[3] = field(init=False, default=3) # MESSAGE
+    name: str
+
+@dataclass
+class UserCommand(DataModel):
+    """Represents the user command object"""
+    type: Literal[2] = field(init=False, default=2) # USER
+    name: str
+
+@dataclass
+class _CommandOption(DataModel):
+    """Option for a slash command."""
+    type: int   # refer to CommandOptionTypes
+    name: str
+    description: str
+    required: bool = True
+
+@dataclass
+class SlashCommand(DataModel):
+    type: Literal[1] = field(init=False, default=1) # CHAT_INPUT
+    name: str
+    description: str
+    options: list[_CommandOption] = field(default_factory=list)
+
+    def add_option(
+        self,
+        command_type: Literal['String', 'Integer', 'Boolean', 'User', 'Channel', 'Role', 'Mentionable', 'Number', 'Attachment'],
+        name: str,
+        description: str,
+        required: bool = False
+    ):
+        """Add an option to this slash command.
+
+        Args:
+            command_type (Literal['String', 'Integer', 'Boolean', 'User', 'Channel', 'Role', 'Mentionable', 'Number', 'Attachment']): 
+                input type for the option
+            name (str): name of the option
+            description (str): description for the option
+            required (bool, optional): if the option is required. Defaults to False.
+
+        Returns:
+            (SlashCommand): self
+        """
+        _command_types = {
+            'STRING': CommandOptionTypes.STRING,
+            'INTEGER': CommandOptionTypes.INTEGER,
+            'BOOLEAN': CommandOptionTypes.BOOLEAN,
+            'USER': CommandOptionTypes.BOOLEAN,
+            'CHANNEL': CommandOptionTypes.CHANNEL,
+            'ROLE': CommandOptionTypes.ROLE,
+            'MENTIONABLE': CommandOptionTypes.MENTIONABLE,
+            'NUMBER': CommandOptionTypes.NUMBER,
+            'ATTACHMENT': CommandOptionTypes.ATTACHMENT
+        }
+
+        self.options.append(
+            _CommandOption(
+                type=_command_types.get(command_type.upper()), 
+                name=name, 
+                description=description, 
+                required=required
+            )
+        )
+        return self

discord/parts/component_types.py

@@ -0,0 +1,5 @@
+class ActionRowChild: ...
+class SectionChild: ...
+class SectionAccessory: ...
+class ContainerChild: ...
+class LabelChild: ...