loopbot-discord-sdk 1.0.0__py3-none-any.whl

loopbot/context/__init__.py

@@ -0,0 +1,17 @@
+"""
+Context classes for handling interactions
+"""
+
+from .base import BaseContext
+from .command import CommandContext
+from .button import ButtonContext
+from .modal import ModalContext
+from .select import SelectContext
+
+__all__ = [
+    "BaseContext",
+    "CommandContext",
+    "ButtonContext",
+    "ModalContext",
+    "SelectContext",
+]

loopbot/context/base.py

@@ -0,0 +1,263 @@
+"""
+Base Context for all interaction types
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+from ..types import Interaction, InteractionResponseType, DiscordUser, DiscordMember
+from ..builders.embed import EmbedBuilder
+from ..builders.action_row import ActionRowBuilder
+from ..builders.modal import ModalBuilder
+
+
+class BaseContext:
+    """Base context for handling Discord interactions"""
+
+    def __init__(
+        self,
+        interaction: Dict[str, Any],
+        client: Any,
+        application_id: str,
+    ):
+        self._interaction = interaction
+        self._client = client
+        self._application_id = application_id
+        self._response: Optional[Dict[str, Any]] = None
+        self._deferred = False
+
+    @property
+    def interaction_id(self) -> str:
+        return self._interaction.get("id", "")
+
+    @property
+    def token(self) -> str:
+        return self._interaction.get("token", "")
+
+    @property
+    def guild_id(self) -> Optional[str]:
+        return self._interaction.get("guild_id")
+
+    @property
+    def channel_id(self) -> Optional[str]:
+        return self._interaction.get("channel_id")
+
+    @property
+    def user(self) -> Optional[Dict[str, Any]]:
+        """Get the user who triggered the interaction"""
+        member = self._interaction.get("member")
+        if member:
+            return member.get("user")
+        return self._interaction.get("user")
+
+    @property
+    def user_id(self) -> Optional[str]:
+        user = self.user
+        return user.get("id") if user else None
+
+    @property
+    def username(self) -> Optional[str]:
+        user = self.user
+        return user.get("username") if user else None
+
+    @property
+    def member(self) -> Optional[Dict[str, Any]]:
+        return self._interaction.get("member")
+
+    @property
+    def locale(self) -> Optional[str]:
+        return self._interaction.get("locale")
+
+    @property
+    def response(self) -> Optional[Dict[str, Any]]:
+        return self._response
+
+    @property
+    def is_deferred(self) -> bool:
+        return self._deferred
+
+    def reply(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Union[Dict[str, Any], EmbedBuilder]]] = None,
+        components: Optional[List[Union[Dict[str, Any], ActionRowBuilder]]] = None,
+        ephemeral: bool = False,
+    ) -> None:
+        """Reply to the interaction"""
+        data: Dict[str, Any] = {}
+        
+        if content:
+            data["content"] = content
+        
+        if embeds:
+            data["embeds"] = [
+                e.to_dict() if isinstance(e, EmbedBuilder) else e
+                for e in embeds
+            ]
+        
+        if components:
+            data["components"] = [
+                c.to_dict() if isinstance(c, ActionRowBuilder) else c
+                for c in components
+            ]
+        
+        if ephemeral:
+            data["flags"] = 64
+
+        self._response = {
+            "type": InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
+            "data": data,
+        }
+
+    def reply_text(self, content: str, ephemeral: bool = False) -> None:
+        """Reply with simple text"""
+        self.reply(content=content, ephemeral=ephemeral)
+
+    def reply_with_components(
+        self,
+        components: List[Any],
+        ephemeral: bool = False,
+    ) -> None:
+        """Reply with Components V2 (Container, MediaGallery, etc.)"""
+        data: Dict[str, Any] = {
+            "components": [
+                c.to_dict() if hasattr(c, "to_dict") else c
+                for c in components
+            ],
+            "flags": 32768,  # IS_COMPONENTS_V2
+        }
+        
+        if ephemeral:
+            data["flags"] |= 64
+
+        self._response = {
+            "type": InteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
+            "data": data,
+        }
+
+    def update(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Union[Dict[str, Any], EmbedBuilder]]] = None,
+        components: Optional[List[Union[Dict[str, Any], ActionRowBuilder]]] = None,
+    ) -> None:
+        """Update the original message"""
+        data: Dict[str, Any] = {}
+        
+        if content is not None:
+            data["content"] = content
+        
+        if embeds:
+            data["embeds"] = [
+                e.to_dict() if isinstance(e, EmbedBuilder) else e
+                for e in embeds
+            ]
+        
+        if components:
+            data["components"] = [
+                c.to_dict() if isinstance(c, ActionRowBuilder) else c
+                for c in components
+            ]
+
+        self._response = {
+            "type": InteractionResponseType.UPDATE_MESSAGE,
+            "data": data,
+        }
+
+    def update_with_components(self, components: List[Any]) -> None:
+        """Update the original message with Components V2"""
+        self._response = {
+            "type": InteractionResponseType.UPDATE_MESSAGE,
+            "data": {
+                "components": [
+                    c.to_dict() if hasattr(c, "to_dict") else c
+                    for c in components
+                ],
+                "flags": 32768,  # IS_COMPONENTS_V2
+            },
+        }
+
+    def defer(self, ephemeral: bool = False) -> None:
+        """Defer the response (show 'thinking...')"""
+        self._deferred = True
+        self._response = {
+            "type": InteractionResponseType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE,
+            "data": {"flags": 64 if ephemeral else 0},
+        }
+
+    def defer_update(self) -> None:
+        """Defer the update (acknowledge without visible loading)"""
+        self._deferred = True
+        self._response = {
+            "type": InteractionResponseType.DEFERRED_UPDATE_MESSAGE,
+        }
+
+    def show_modal(self, modal: ModalBuilder) -> None:
+        """Show a modal to the user"""
+        self._response = {
+            "type": InteractionResponseType.MODAL,
+            "data": modal.to_dict(),
+        }
+
+    async def follow_up(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Union[Dict[str, Any], EmbedBuilder]]] = None,
+        components: Optional[List[Union[Dict[str, Any], ActionRowBuilder]]] = None,
+        ephemeral: bool = False,
+    ) -> Dict[str, Any]:
+        """Send a follow-up message"""
+        data: Dict[str, Any] = {}
+        
+        if content:
+            data["content"] = content
+        
+        if embeds:
+            data["embeds"] = [
+                e.to_dict() if isinstance(e, EmbedBuilder) else e
+                for e in embeds
+            ]
+        
+        if components:
+            data["components"] = [
+                c.to_dict() if isinstance(c, ActionRowBuilder) else c
+                for c in components
+            ]
+        
+        if ephemeral:
+            data["flags"] = 64
+
+        return await self._client.follow_up(
+            self._application_id,
+            self.token,
+            data,
+        )
+
+    async def edit_reply(
+        self,
+        content: Optional[str] = None,
+        embeds: Optional[List[Union[Dict[str, Any], EmbedBuilder]]] = None,
+        components: Optional[List[Union[Dict[str, Any], ActionRowBuilder]]] = None,
+    ) -> None:
+        """Edit the original response"""
+        data: Dict[str, Any] = {}
+        
+        if content is not None:
+            data["content"] = content
+        
+        if embeds:
+            data["embeds"] = [
+                e.to_dict() if isinstance(e, EmbedBuilder) else e
+                for e in embeds
+            ]
+        
+        if components:
+            data["components"] = [
+                c.to_dict() if isinstance(c, ActionRowBuilder) else c
+                for c in components
+            ]
+
+        await self._client.edit_original(
+            self._application_id,
+            self.token,
+            data,
+        )

loopbot/context/button.py

@@ -0,0 +1,28 @@
+"""
+Button Context for button interactions
+"""
+
+from typing import Any, Dict, Optional
+
+from .base import BaseContext
+
+
+class ButtonContext(BaseContext):
+    """Context for handling button interactions"""
+
+    @property
+    def custom_id(self) -> str:
+        """Get the button custom ID"""
+        data = self._interaction.get("data", {})
+        return data.get("custom_id", "")
+
+    @property
+    def message(self) -> Optional[Dict[str, Any]]:
+        """Get the message the button was attached to"""
+        return self._interaction.get("message")
+
+    @property
+    def message_id(self) -> Optional[str]:
+        """Get the message ID"""
+        message = self.message
+        return message.get("id") if message else None

loopbot/context/command.py

@@ -0,0 +1,93 @@
+"""
+Command Context for slash commands
+"""
+
+from typing import Any, Dict, List, Optional
+
+from .base import BaseContext
+
+
+class CommandContext(BaseContext):
+    """Context for handling slash command interactions"""
+
+    @property
+    def command_name(self) -> str:
+        """Get the command name"""
+        data = self._interaction.get("data", {})
+        return data.get("name", "")
+
+    @property
+    def options(self) -> Dict[str, Any]:
+        """Get command options as a dict"""
+        data = self._interaction.get("data", {})
+        options = data.get("options", [])
+        return self._parse_options(options)
+
+    def _parse_options(self, options: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Parse options list into dict"""
+        result: Dict[str, Any] = {}
+        for opt in options:
+            name = opt.get("name", "")
+            value = opt.get("value")
+            
+            # Handle subcommands/groups
+            if opt.get("options"):
+                result[name] = self._parse_options(opt["options"])
+            else:
+                result[name] = value
+        
+        return result
+
+    def get_option(
+        self,
+        name: str,
+        default: Any = None,
+    ) -> Any:
+        """Get a specific option value"""
+        return self.options.get(name, default)
+
+    def get_string(self, name: str, default: str = "") -> str:
+        """Get a string option"""
+        return str(self.get_option(name, default))
+
+    def get_int(self, name: str, default: int = 0) -> int:
+        """Get an integer option"""
+        value = self.get_option(name, default)
+        return int(value) if value is not None else default
+
+    def get_bool(self, name: str, default: bool = False) -> bool:
+        """Get a boolean option"""
+        return bool(self.get_option(name, default))
+
+    def get_user(self, name: str) -> Optional[Dict[str, Any]]:
+        """Get a user option from resolved data"""
+        user_id = self.get_option(name)
+        if not user_id:
+            return None
+        
+        data = self._interaction.get("data", {})
+        resolved = data.get("resolved", {})
+        users = resolved.get("users", {})
+        return users.get(user_id)
+
+    def get_channel(self, name: str) -> Optional[Dict[str, Any]]:
+        """Get a channel option from resolved data"""
+        channel_id = self.get_option(name)
+        if not channel_id:
+            return None
+        
+        data = self._interaction.get("data", {})
+        resolved = data.get("resolved", {})
+        channels = resolved.get("channels", {})
+        return channels.get(channel_id)
+
+    def get_role(self, name: str) -> Optional[Dict[str, Any]]:
+        """Get a role option from resolved data"""
+        role_id = self.get_option(name)
+        if not role_id:
+            return None
+        
+        data = self._interaction.get("data", {})
+        resolved = data.get("resolved", {})
+        roles = resolved.get("roles", {})
+        return roles.get(role_id)

loopbot/context/modal.py

@@ -0,0 +1,46 @@
+"""
+Modal Context for modal submit interactions
+"""
+
+from typing import Any, Dict, List, Optional
+
+from .base import BaseContext
+
+
+class ModalContext(BaseContext):
+    """Context for handling modal submit interactions"""
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self._fields: Dict[str, str] = self._parse_fields()
+
+    def _parse_fields(self) -> Dict[str, str]:
+        """Parse modal fields from interaction data"""
+        fields: Dict[str, str] = {}
+        data = self._interaction.get("data", {})
+        components = data.get("components", [])
+        
+        for row in components:
+            row_components = row.get("components", [])
+            for component in row_components:
+                custom_id = component.get("custom_id", "")
+                value = component.get("value", "")
+                if custom_id:
+                    fields[custom_id] = value
+        
+        return fields
+
+    @property
+    def custom_id(self) -> str:
+        """Get the modal custom ID"""
+        data = self._interaction.get("data", {})
+        return data.get("custom_id", "")
+
+    @property
+    def fields(self) -> Dict[str, str]:
+        """Get all modal fields as dict"""
+        return self._fields
+
+    def get_field(self, custom_id: str, default: str = "") -> str:
+        """Get a specific field value"""
+        return self._fields.get(custom_id, default)

loopbot/context/select.py

@@ -0,0 +1,34 @@
+"""
+Select Context for select menu interactions
+"""
+
+from typing import Any, Dict, List, Optional
+
+from .base import BaseContext
+
+
+class SelectContext(BaseContext):
+    """Context for handling select menu interactions"""
+
+    @property
+    def custom_id(self) -> str:
+        """Get the select menu custom ID"""
+        data = self._interaction.get("data", {})
+        return data.get("custom_id", "")
+
+    @property
+    def values(self) -> List[str]:
+        """Get selected values"""
+        data = self._interaction.get("data", {})
+        return data.get("values", [])
+
+    @property
+    def message(self) -> Optional[Dict[str, Any]]:
+        """Get the message the select was attached to"""
+        return self._interaction.get("message")
+
+    @property
+    def message_id(self) -> Optional[str]:
+        """Get the message ID"""
+        message = self.message
+        return message.get("id") if message else None

loopbot/types.py

@@ -0,0 +1,76 @@
+"""
+Types and enums for the Loop Discord SDK
+"""
+
+from enum import IntEnum
+from typing import Any, Dict, List, Optional, TypedDict
+
+
+class InteractionType(IntEnum):
+    PING = 1
+    APPLICATION_COMMAND = 2
+    MESSAGE_COMPONENT = 3
+    APPLICATION_COMMAND_AUTOCOMPLETE = 4
+    MODAL_SUBMIT = 5
+
+
+class InteractionResponseType(IntEnum):
+    PONG = 1
+    CHANNEL_MESSAGE_WITH_SOURCE = 4
+    DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE = 5
+    DEFERRED_UPDATE_MESSAGE = 6
+    UPDATE_MESSAGE = 7
+    APPLICATION_COMMAND_AUTOCOMPLETE_RESULT = 8
+    MODAL = 9
+
+
+class DiscordUser(TypedDict, total=False):
+    id: str
+    username: str
+    discriminator: str
+    avatar: Optional[str]
+    bot: bool
+    global_name: Optional[str]
+
+
+class DiscordMember(TypedDict, total=False):
+    user: DiscordUser
+    nick: Optional[str]
+    roles: List[str]
+    joined_at: str
+    permissions: str
+
+
+class DiscordMessage(TypedDict, total=False):
+    id: str
+    channel_id: str
+    content: str
+    author: DiscordUser
+    embeds: List[Dict[str, Any]]
+    components: List[Dict[str, Any]]
+
+
+class InteractionData(TypedDict, total=False):
+    id: str
+    name: str
+    type: int
+    options: List[Dict[str, Any]]
+    custom_id: str
+    component_type: int
+    values: List[str]
+    components: List[Dict[str, Any]]
+
+
+class Interaction(TypedDict, total=False):
+    id: str
+    application_id: str
+    type: int
+    data: InteractionData
+    guild_id: str
+    channel_id: str
+    member: DiscordMember
+    user: DiscordUser
+    token: str
+    version: int
+    message: DiscordMessage
+    locale: str