refactor: Add ComponentGearMixin and ModalGearMixin for interaction management

Paillat-dev · Paillat-dev · commit fae977cb4bd9 · 2025-12-02T20:57:22.000+01:00
diff --git a/discord/bot.py b/discord/bot.py
@@ -820,7 +820,7 @@ async def process_application_commands(self, interaction: Interaction, auto_sync
                         await self.sync_commands()
                     else:
                         await self.sync_commands(check_guilds=[guild_id])
-                return self._bot.dispatch("unknown_application_command", interaction)
+        #                return self._bot.dispatch("unknown_application_command", interaction)
 
         if interaction.type is InteractionType.auto_complete:
             return self._bot.dispatch("application_command_auto_complete", interaction, command)
@@ -1160,7 +1160,7 @@ def __init__(self, description=None, *args, **options):
         self._before_invoke = None
         self._after_invoke = None
 
-        self._bot.add_listener(self.on_interaction, event=InteractionCreate)
+        # self._bot.add_listener(self.on_interaction, event=InteractionCreate)
 
     async def on_connect(self):
         if self.auto_sync_commands:
diff --git a/discord/client.py b/discord/client.py
@@ -648,7 +648,7 @@ async def connect(self, *, reconnect: bool = True) -> None:
                 aiohttp.ClientError,
                 asyncio.TimeoutError,
             ) as exc:
-                self.dispatch("disconnect")
+                # self.dispatch("disconnect") # TODO: dispatch event
                 if not reconnect:
                     await self.close()
                     if isinstance(exc, ConnectionClosed) and exc.code == 1000:
diff --git a/discord/events/gateway.py b/discord/events/gateway.py
@@ -54,7 +54,7 @@ class Resumed(Event):
     __event_name__: str = "RESUMED"
 
     @classmethod
-    async def __load__(cls, _data: Any, _state: ConnectionState) -> Self | None:
+    async def __load__(cls, data: Any, state: ConnectionState) -> Self | None:
         return cls()
 
 
diff --git a/discord/events/interaction.py b/discord/events/interaction.py
@@ -43,20 +43,20 @@
 
 def _interaction_factory(payload: InteractionPayload) -> type[Interaction]:
     type: int = payload["type"]
-    if type == InteractionType.application_command:
+    if type == InteractionType.application_command.value:
         return ApplicationCommandInteraction
-    if type == InteractionType.auto_complete:
+    if type == InteractionType.auto_complete.value:
         return AutocompleteInteraction
-    if type == InteractionType.component:
+    if type == InteractionType.component.value:
         return ComponentInteraction
-    if type == InteractionType.modal_submit:
+    if type == InteractionType.modal_submit.value:
         return ModalInteraction
     return Interaction
 
 
 @lru_cache(maxsize=128)
-def _create_event_interaction_class(event_cls: type[Event], interaction_cls: type[Interaction]) -> type[Interaction]:
-    class EventInteraction(interaction_cls, event_cls):  # type: ignore
+def _create_event_interaction_class(interaction_cls: type[Interaction]) -> type[Interaction]:
+    class EventInteraction(interaction_cls, Event):  # type: ignore
         __slots__ = ()
 
         @override
@@ -66,7 +66,12 @@ def __init__(self) -> None:
         @override
         @classmethod
         def event_type(self) -> type[Event]:
-            return event_cls
+            return InteractionCreate
+
+        @classmethod
+        @override
+        async def __load__(cls, data: InteractionPayload, state: ConnectionState) -> None:
+            return None
 
     return EventInteraction  # type: ignore
 
@@ -94,7 +99,7 @@ def __init__(self) -> None:
     async def __load__(cls, data: Any, state: ConnectionState) -> Self | None:
         factory = _interaction_factory(data)
         interaction = await factory._from_data(payload=data, state=state)
-        interaction_event_cls = _create_event_interaction_class(Event, factory)
+        interaction_event_cls = _create_event_interaction_class(factory)
         self = interaction_event_cls()
         self._populate_from_slots(interaction)
         return self
diff --git a/discord/gears/components.py b/discord/gears/components.py
@@ -0,0 +1,279 @@
+"""
+The MIT License (MIT)
+
+Copyright (c) 2021-present Pycord Development
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+"""
+
+from abc import ABC
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Coroutine, ParamSpec, Protocol, TypeAlias, TypeVar, Unpack
+
+from ..events import InteractionCreate
+from ..interactions import ComponentInteraction, ModalInteraction
+from ..utils import MISSING, Undefined
+from ..utils.private import hybridmethod, maybe_awaitable
+from .base import GearBase
+
+ComponentPredicate: TypeAlias = Callable[[str], bool | Awaitable[bool]]
+
+
+class ComponentListener(Protocol):
+    async def __call__(self, interaction: ComponentInteraction[Any]) -> Any: ...
+
+
+CL_t = TypeVar("CL_t", bound=ComponentListener)
+
+
+class ModalListener(Protocol):
+    async def __call__(self, interaction: ModalInteraction[Unpack[tuple[Any, ...]]]) -> Any: ...
+
+
+ML_t = TypeVar("ML_t", bound=ModalListener)
+
+T = TypeVar("T", bound="ComponentListener | ModalListener")
+MG_t = TypeVar("MG_t", bound="ModalGearMixin")
+
+
+def _unwrap_predicate(
+    maybe_predicate: Callable[[str], bool | Awaitable[bool]] | str,
+) -> Callable[[str], bool | Awaitable[bool]]:
+    return lambda x: x == maybe_predicate if isinstance(maybe_predicate, str) else maybe_predicate
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def _listener_factory(
+    listener: Callable[P, Awaitable[R]],
+    interaction_type: type[ModalInteraction | ComponentInteraction],
+    predicate: ComponentPredicate,
+) -> Callable[P, Coroutine[Any, Any, R | None]]:
+    @wraps(listener)
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R | None:
+        # Assume last positional arg is the interaction
+        if args:
+            interaction: Any = args[-1]
+            if isinstance(interaction, interaction_type) and await maybe_awaitable(predicate, interaction.custom_id):
+                return await listener(*args, **kwargs)
+        return None
+
+    return wrapper
+
+
+CG_t = TypeVar("CG_t", bound="ComponentGearMixin")
+
+
+class ComponentGearMixin(GearBase, ABC):
+    """A mixin that provides component handling for a :class:`discord.Gear`.
+
+    This mixin is used to handle components such as buttons, select menus, and other interactive elements.
+    """
+
+    def add_component_listener(
+        self, predicate: Callable[[str], bool | Awaitable[bool]] | str, listener: ComponentListener
+    ) -> Callable[[InteractionCreate], Awaitable[None]]:
+        """Registers a component interaction listener.
+
+        This method can be used to register a function that will be called
+        when a component interaction occurs that matches the provided predicate.
+
+        .. versionadded:: 3.0
+
+        Parameters
+        ----------
+        predicate:
+            A (potentially async) function that takes a string (the component's custom ID) and returns a boolean indicating whether the
+            function should be called for that component. Alternatively, a string can be provided, which will match
+            the component's custom ID exactly.
+
+        listener:
+            The interaction callback to call when a component interaction occurs that matches the predicate.
+
+        Returns
+        -------
+        Callable[[InteractionCreate], Awaitable[None]]
+            The registered listener. Use this to unregister the listener.
+        """
+        actual_predicate: Callable[[str], bool | Awaitable[bool]] = _unwrap_predicate(predicate)
+        actual_listener = _listener_factory(listener, ComponentInteraction, actual_predicate)
+        self.add_listener(actual_listener, event=InteractionCreate)
+        return actual_listener
+
+    if TYPE_CHECKING:
+
+        @classmethod
+        def listen_component(
+            cls: type[CG_t],
+            predicate: Callable[[str], bool | Awaitable[bool]] | str,
+        ) -> Callable[
+            [Callable[[ComponentListener], Awaitable[None]] | Callable[[Any, ComponentListener], Awaitable[None]]],
+            Callable[[InteractionCreate], Awaitable[None]],
+        ]:
+            """A shortcut decorator that registers a component interaction listener.
+
+            This decorator can be used to register a function that will be called
+            when a component interaction occurs that matches the provided predicate.
+
+            .. versionadded:: 3.0
+
+            Parameters
+            ----------
+            predicate:
+                A (potentially async) function that takes a string (the component's custom ID) and returns a boolean indicating whether the
+                function should be called for that component. Alternatively, a string can be provided, which will match
+                the component's custom ID exactly.
+            """
+            ...
+    else:
+        # Instance function listeners (but not bound to an instance)
+        @hybridmethod
+        def listen_component(
+            cls: type[CG_t],  # noqa: N805
+            predicate: Callable[[str], bool | Awaitable[bool]] | str,
+        ) -> Callable[
+            [Callable[[Any, ComponentInteraction[Any]], Awaitable[None]]],
+            Callable[[Any, ComponentInteraction[Any]], Awaitable[None]],
+        ]:
+            def decorator(
+                func: Callable[[Any, ComponentInteraction[Any]], Awaitable[None]],
+            ) -> Callable[[Any, ComponentInteraction[Any]], Awaitable[None]]:
+                actual_predicate: Callable[[str], bool | Awaitable[bool]] = _unwrap_predicate(predicate)
+
+                actual_listener = _listener_factory(func, ComponentInteraction, actual_predicate)
+
+                # Use parent's listen to register for InteractionCreate
+                return cls.listen(InteractionCreate)(actual_listener)
+
+            return decorator
+
+        # Bare listeners (everything else)
+        @listen_component.instancemethod
+        def listen_component(
+            self,
+            predicate: Callable[[str], bool | Awaitable[bool]] | str,
+        ) -> Callable[[ComponentListener], Callable[[InteractionCreate], Awaitable[None]]]:
+            def decorator(
+                func: ComponentListener,
+            ) -> Callable[[InteractionCreate], Awaitable[None]]:
+                return self.add_component_listener(predicate, func)
+
+            return decorator
+
+
+MG_t = TypeVar("MG_t", bound="ModalGearMixin")
+
+
+class ModalGearMixin(GearBase, ABC):
+    """A mixin that provides modal handling for a :class:`discord.Gear`.
+
+    This mixin is used to handle modals interactions.
+    """
+
+    def add_modal_listener(
+        self, predicate: Callable[[str], bool | Awaitable[bool]] | str, listener: ModalListener
+    ) -> Callable[[InteractionCreate], Awaitable[None]]:
+        """Registers a modal interaction listener.
+
+        This method can be used to register a function that will be called
+        when a modal interaction occurs that matches the provided predicate.
+
+        .. versionadded:: 3.0
+
+        Parameters
+        ----------
+        predicate:
+            A (potentially async) function that takes a string (the modal's custom ID) and returns a boolean indicating whether the
+            function should be called for that modal. Alternatively, a string can be provided, which will match
+            the modal's custom ID exactly.
+
+        listener:
+            The interaction callback to call when a modal interaction occurs that matches the predicate.
+
+        Returns
+        -------
+        Callable[[InteractionCreate], Awaitable[None]]
+            The registered listener. Use this to unregister the listener.
+        """
+        actual_predicate: Callable[[str], bool | Awaitable[bool]] = _unwrap_predicate(predicate)
+        actual_listener = _listener_factory(listener, ModalInteraction, actual_predicate)
+        self.add_listener(actual_listener, event=InteractionCreate)
+        return actual_listener
+
+    if TYPE_CHECKING:
+
+        @classmethod
+        def listen_modal(
+            cls: type[MG_t],
+            predicate: Callable[[str], bool | Awaitable[bool]] | str,
+        ) -> Callable[
+            [Callable[[ModalListener], Awaitable[None]] | Callable[[Any, ModalListener], Awaitable[None]]],
+            Callable[[InteractionCreate], Awaitable[None]],
+        ]:
+            """A shortcut decorator that registers a modal interaction listener.
+
+            This decorator can be used to register a function that will be called
+            when a modal interaction occurs that matches the provided predicate.
+
+            .. versionadded:: 3.0
+
+            Parameters
+            ----------
+            predicate:
+                A (potentially async) function that takes a string (the modal's custom ID) and returns a boolean indicating whether the
+                function should be called for that modal. Alternatively, a string can be provided, which will match
+                the modal's custom ID exactly.
+            """
+            ...
+    else:
+        # Instance function listeners (but not bound to an instance)
+        @hybridmethod
+        def listen_modal(
+            cls: type[MG_t],  # noqa: N805
+            predicate: Callable[[str], bool | Awaitable[bool]] | str,
+        ) -> Callable[
+            [Callable[[Any, ModalInteraction[Unpack[tuple[Any, ...]]]], Awaitable[None]]],
+            Callable[[Any, ModalInteraction[Unpack[tuple[Any, ...]]]], Awaitable[None]],
+        ]:
+            def decorator(
+                func: Callable[[Any, ModalInteraction[Unpack[tuple[Any, ...]]]], Awaitable[None]],
+            ) -> Callable[[Any, ModalInteraction[Unpack[tuple[Any, ...]]]], Awaitable[None]]:
+                actual_predicate: Callable[[str], bool | Awaitable[bool]] = _unwrap_predicate(predicate)
+
+                actual_listener = _listener_factory(func, ModalInteraction, actual_predicate)
+
+                # Use parent's listen to register for InteractionCreate
+                return cls.listen(InteractionCreate)(actual_listener)
+
+            return decorator
+
+        # Bare listeners (everything else)
+        @listen_modal.instancemethod
+        def listen_modal(
+            self,
+            predicate: Callable[[str], bool | Awaitable[bool]] | str,
+        ) -> Callable[[ModalListener], Callable[[InteractionCreate], Awaitable[None]]]:
+            def decorator(
+                func: ModalListener,
+            ) -> Callable[[InteractionCreate], Awaitable[None]]:
+                return self.add_modal_listener(predicate, func)
+
+            return decorator
diff --git a/discord/gears/gear.py b/discord/gears/gear.py
@@ -40,6 +40,7 @@
 from ..utils.annotations import get_annotations
 from ..utils.private import hybridmethod
 from .base import GearBase
+from .components import ComponentGearMixin, ModalGearMixin
 
 _T = TypeVar("_T", bound="Gear")
 E = TypeVar("E", bound="Event", covariant=True)
@@ -60,7 +61,7 @@ class StaticAttributedEventCallback(AttributedEventCallback, Protocol):
 EventCallback: TypeAlias = Callable[[E], Awaitable[None]]
 
 
-class Gear(GearBase):
+class Gear(ModalGearMixin, GearBase):
     """A gear is a modular component that can listen to and handle events.
 
     You can subclass this class to create your own gears and attach them to your bot or other gears.
@@ -109,6 +110,8 @@ def __init__(self) -> None:
             self.add_listener(cast("EventCallback[Event]", callback), event=event, once=once)
             setattr(self, name, callback)
 
+        super().__init__()
+
     def _handle_event(self, event: Event) -> Collection[Awaitable[Any]]:
         tasks: list[Awaitable[None]] = []
 
diff --git a/discord/guild.py b/discord/guild.py
diff --git a/discord/interactions.py b/discord/interactions.py
