base merge

Author: i0bs

interactions/api/gateway.py

@@ -32,7 +32,6 @@
 class Heartbeat(Thread):
     """
     A class representing a consistent heartbeat connection with the gateway.
-
     :ivar WebSocket ws: The WebSocket class to infer on.
     :ivar Union[int, float] interval: The heartbeat interval determined by the gateway.
     :ivar Event event: The multi-threading event.
@@ -79,7 +78,6 @@ def stop(self) -> None:
 class WebSocket:
     """
     A class representing a websocket connection with the gateway.
-
     :ivar Intents intents: An instance of :class:`interactions.api.models.Intents`.
     :ivar AbstractEventLoop loop: The coroutine event loop established on.
     :ivar Request req: An instance of :class:`interactions.api.http.Request`.
@@ -151,7 +149,6 @@ async def connect(
     ) -> None:
         """
         Establishes a connection to the gateway.
-
         :param token: The token to use for identifying.
         :type token: str
         :param shard?: The shard ID to identify under.
@@ -181,7 +178,6 @@ async def handle_connection(
     ) -> None:
         """
         Handles the connection to the gateway.
-
         :param stream: The data stream from the gateway.
         :type stream: dict
         :param shard?: The shard ID to identify under.
@@ -243,7 +239,6 @@ async def handle_connection(
     def handle_dispatch(self, event: str, data: dict) -> None:
         """
         Handles the dispatched event data from a gateway event.
-
         :param event: The name of the event.
         :type event: str
         :param data: The data of the event.
@@ -277,37 +272,25 @@ def handle_dispatch(self, event: str, data: dict) -> None:
                     context = self.contextualize(data)
                     _name: str
                     _args: list = [context]
+                    _kwargs: dict = dict()
                     if data["type"] == InteractionType.APPLICATION_COMMAND:
                         _name = context.data.name
                         if hasattr(context.data, "options"):
                             if context.data.options:
                                 for option in context.data.options:
-                                    if option["type"] in (
-                                        OptionType.SUB_COMMAND,
-                                        OptionType.SUB_COMMAND_GROUP,
-                                    ):
-                                        if option.get("options"):
-                                            for sub_option in option["options"]:
-                                                _args.append(sub_option)
-                                        else:
-                                            pass
-                                    else:
-                                        _args.append(option["value"])
+                                    _kwargs.update(self.check_sub_command(option))
                     elif data["type"] == InteractionType.MESSAGE_COMPONENT:
                         _name = context.data.custom_id
                     elif data["type"] == InteractionType.APPLICATION_COMMAND_AUTOCOMPLETE:
                         _name = "autocomplete_"
                         if hasattr(context.data, "options"):
                             if context.data.options:
                                 for option in context.data.options:
-                                    if option["type"] in (
-                                        OptionType.SUB_COMMAND,
-                                        OptionType.SUB_COMMAND_GROUP,
-                                    ):
-                                        if option.get("options"):
-                                            for sub_option in option["options"]:
-                                                if sub_option.get("focused"):
-                                                    _name += sub_option["name"]
+                                    add_name, add_args = self.check_sub_auto(option)
+                                    if add_name:
+                                        _name += add_name
+                                    if add_args:
+                                        _args.append(add_args)
                     elif data["type"] == InteractionType.MODAL_SUBMIT:
                         _name = f"modal_{context.data.custom_id}"
                         if hasattr(context.data, "components"):
@@ -316,15 +299,48 @@ def handle_dispatch(self, event: str, data: dict) -> None:
                                     for _value in component.components:
                                         _args.append(_value["value"])
 
-                    self.dispatch.dispatch(_name, *_args)
+                    self.dispatch.dispatch(_name, *_args, **_kwargs)
 
             self.dispatch.dispatch("raw_socket_create", data)
 
+    def check_sub_command(self, option) -> dict:
+        _kwargs = dict()
+        if "options" in option:
+            if option["type"] == OptionType.SUB_COMMAND_GROUP:
+                _kwargs["sub_command_group"] = option["name"]
+                for group_option in option["options"]:
+                    _kwargs["sub_command"] = group_option["name"]
+                    if "options" in group_option:
+                        for sub_option in group_option["options"]:
+                            _kwargs[sub_option["name"]] = sub_option["value"]
+            elif option["type"] == OptionType.SUB_COMMAND:
+                _kwargs["sub_command"] = option["name"]
+                for sub_option in option["options"]:
+                    _kwargs[sub_option["name"]] = sub_option["value"]
+        else:
+            _kwargs[option["name"]] = option["value"]
+
+        return _kwargs
+
+    def check_sub_auto(self, option) -> tuple:
+        if "options" in option:
+            if option["type"] == OptionType.SUB_COMMAND_GROUP:
+                for group_option in option["options"]:
+                    if "options" in group_option:
+                        for sub_option in option["options"]:
+                            if sub_option.get("focused"):
+                                return sub_option["name"], sub_option["value"]
+            elif option["type"] == OptionType.SUB_COMMAND:
+                for sub_option in option["options"]:
+                    if sub_option.get("focused"):
+                        return sub_option["name"], sub_option["value"]
+        elif option.get("focused"):
+            return option["name"], option["value"]
+
     def contextualize(self, data: dict) -> object:
         """
         Takes raw data given back from the gateway
         and gives "context" based off of what it is.
-
         :param data: The data from the gateway.
         :type data: dict
         :return: The context object.
@@ -358,7 +374,6 @@ async def identify(
     ) -> None:
         """
         Sends an ``IDENTIFY`` packet to the gateway.
-
         :param shard?: The shard ID to identify under.
         :type shard: Optional[int]
         :param presence?: The presence to change the bot to on identify.

interactions/api/gateway.pyi

@@ -47,3 +47,5 @@ class WebSocket:
     ) -> None: ...
     async def resume(self) -> None: ...
     async def heartbeat(self) -> None: ...
+    def check_sub_auto(self, option) -> tuple: ...
+    def check_sub_command(self, option) -> dict: ...

interactions/client.py

@@ -396,8 +396,10 @@ async def button_response(ctx):
         """
 
         def decorator(coro: Coroutine) -> Any:
-            payload: Component = _component(component)
-            return self.event(coro, name=payload.custom_id)
+            payload: str = (
+                _component(component).custom_id if isinstance(component, Component) else component
+            )
+            return self.event(coro, name=payload)
 
         return decorator
 

interactions/context.py

@@ -8,7 +8,7 @@
 from .api.models.misc import DictSerializerMixin, Snowflake
 from .api.models.user import User
 from .base import CustomFormatter, Data
-from .enums import ComponentType, InteractionCallbackType, InteractionType
+from .enums import InteractionCallbackType, InteractionType
 from .models.command import Choice
 from .models.component import ActionRow, Button, Component, Modal, SelectMenu
 from .models.misc import InteractionData
@@ -134,7 +134,7 @@ async def defer(self, ephemeral: Optional[bool] = False) -> None:
         :type ephemeral: Optional[bool]
         """
         self.deferred = True
-        _ephemeral: int = (1 << 6) if bool(ephemeral) else 0
+        _ephemeral: int = (1 << 6) if ephemeral else 0
         # ephemeral doesn't change callback typings. just data json
         if self.type == InteractionType.MESSAGE_COMPONENT:
             self.callback = InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
@@ -191,20 +191,26 @@ async def send(
 
         if isinstance(components, ActionRow):
             _components[0]["components"] = [component._json for component in components.components]
-        elif isinstance(components, (Button, SelectMenu)):
+        elif isinstance(components, Button):
+            _components[0]["components"] = [] if components is None else [components._json]
+        elif isinstance(components, SelectMenu):
+            components._json["options"] = [option._json for option in components.options]
             _components[0]["components"] = [] if components is None else [components._json]
         else:
             _components = [] if components is None else [components]
 
-        _ephemeral: int = (1 << 6) if bool(ephemeral) else 0
+        _ephemeral: int = (1 << 6) if ephemeral else 0
 
-        if not self.deferred:
+        if not self.deferred and self.type != InteractionType.MESSAGE_COMPONENT:
             self.callback = (
                 InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
                 if self.type == InteractionType.APPLICATION_COMMAND
                 else InteractionCallbackType.UPDATE_MESSAGE
             )
 
+        if not self.deferred and self.type == InteractionType.MESSAGE_COMPONENT:
+            self.callback = InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
+
         # TODO: post-v4: Add attachments into Message obj.
         payload: Message = Message(
             content=_content,
@@ -220,8 +226,18 @@ async def send(
         _payload: dict = {"type": self.callback.value, "data": payload._json}
 
         async def func():
-            if self.responded or self.deferred:
-                if self.type == InteractionType.APPLICATION_COMMAND and self.deferred:
+            if (
+                self.responded
+                or self.deferred
+                or self.type == InteractionType.MESSAGE_COMPONENT
+                and self.callback == InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
+            ):
+                if (
+                    self.type == InteractionType.APPLICATION_COMMAND
+                    and self.deferred
+                    or self.type == InteractionType.MESSAGE_COMPONENT
+                    and self.deferred
+                ):
                     res = await self.client.edit_interaction_response(
                         data=payload._json,
                         token=self.token,
@@ -280,8 +296,12 @@ async def edit(
 
         if isinstance(components, ActionRow):
             _components[0]["components"] = [component._json for component in components.components]
-        elif isinstance(components, (Button, SelectMenu)):
+        elif isinstance(components, Button):
+            _components[0]["components"] = [] if components is None else [components._json]
+        elif isinstance(components, SelectMenu):
+            components._json["options"] = [option._json for option in components.options]
             _components[0]["components"] = [] if components is None else [components._json]
+
         else:
             _components = []
 
@@ -297,14 +317,28 @@ async def edit(
 
         async def func():
             if self.deferred:
-                if self.type == InteractionType.MESSAGE_COMPONENT:
+                if (
+                    self.type == InteractionType.MESSAGE_COMPONENT
+                    and self.callback != InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
+                ):
                     await self.client._post_followup(
                         data=payload._json,
                         token=self.token,
                         application_id=str(self.application_id),
                     )
                 else:
-                    if hasattr(self.message, "id") and self.message.id is not None:
+                    if (
+                        self.callback == InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
+                        and self.type == InteractionType.MESSAGE_COMPONENT
+                    ):
+                        res = await self.client.edit_interaction_response(
+                            data=payload._json,
+                            token=self.token,
+                            application_id=str(self.application_id),
+                        )
+                        self.responded = True
+                        self.message = Message(**res)
+                    elif hasattr(self.message, "id") and self.message.id is not None:
                         res = await self.client.edit_message(
                             int(self.channel_id), int(self.message.id), payload=payload._json
                         )
@@ -325,6 +359,11 @@ async def func():
                             )
                             self.message = Message(**res)
             else:
+                self.callback = (
+                    InteractionCallbackType.UPDATE_MESSAGE
+                    if self.type == InteractionType.MESSAGE_COMPONENT
+                    else self.callback
+                )
                 res = await self.client.edit_interaction_response(
                     token=self.token,
                     application_id=str(self.application_id),
@@ -459,5 +498,32 @@ class ComponentContext(CommandContext):
 
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
-        self.type = ComponentType(self.type)
+        self.type = InteractionType(self.type)
         self.responded = False  # remind components that it was not responded to.
+        self.deferred = False  # remind components they not have been deferred
+
+    async def defer(
+        self, ephemeral: Optional[bool] = False, edit_origin: Optional[bool] = False
+    ) -> None:
+        """
+        This "defers" an component response, allowing up
+        to a 15-minute delay between invocation and responding.
+
+        :param ephemeral?: Whether the deferred state is hidden or not.
+        :type ephemeral: Optional[bool]
+        :param edit_origin?: Whether you want to edit the original message or send a followup message
+        :type edit_origin: Optional[bool]
+        """
+        self.deferred = True
+        _ephemeral: int = (1 << 6) if bool(ephemeral) else 0
+        # ephemeral doesn't change callback typings. just data json
+        if self.type == InteractionType.MESSAGE_COMPONENT and edit_origin:
+            self.callback = InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
+        elif self.type == InteractionType.MESSAGE_COMPONENT and not edit_origin:
+            self.callback = InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
+
+        await self.client.create_interaction_response(
+            token=self.token,
+            application_id=int(self.id),
+            data={"type": self.callback.value, "data": {"flags": _ephemeral}},
+        )

interactions/context.pyi

@@ -66,5 +66,6 @@ class CommandContext(Context):
     async def populate(self, choices: Union[Choice, List[Choice]]) -> List[Choice]: ...
 
 class ComponentContext(CommandContext):
-    type: ComponentType
+    type: InteractionType
     def __init__(self, **kwargs) -> None: ...
+    def defer(self, ephemeral: Optional[bool] = False, edit_origin: Optional[bool] = False) -> None: ...

interactions/models/command.py

@@ -110,7 +110,10 @@ def __init__(self, **kwargs) -> None:
         if self._json.get("options"):
             self._json["options"] = [option._json for option in self.options]
         if self._json.get("choices"):
-            self._json["choices"] = [choice._json for choice in self.choices]
+            if isinstance(self._json.get("choices"), dict):
+                self._json["choices"] = [choice for choice in self.choices]
+            else:
+                self._json["choices"] = [choice._json for choice in self.choices]
 
 
 class Permission(DictSerializerMixin):

interactions/models/component.py

@@ -70,6 +70,8 @@ class SelectMenu(DictSerializerMixin):
         "min_values",
         "max_values",
         "disabled",
+        "label",
+        "value",
     )
     type: ComponentType
     custom_id: str
@@ -83,7 +85,7 @@ def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self.type = ComponentType.SELECT
         self.options = (
-            [SelectOption(**option) for option in self.options]
+            [SelectOption(**option._json) for option in self.options]
             if self._json.get("options")
             else None
         )
@@ -323,6 +325,9 @@ class ActionRow(DictSerializerMixin):
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self.type = ComponentType.ACTION_ROW
+        for component in self.components:
+            if isinstance(component, SelectMenu):
+                component._json["options"] = [option._json for option in component.options]
         self.components = (
             [Component(**component._json) for component in self.components]
             if self._json.get("components")