feat: option to defer without raising errors (#1661)

* feat: add ctx.defer() kwarg suppress_error

* fix: docstring oops

* docs: remove note on specific use case

* docs: refactor defer usage note for clarity

* docs: use orig "followup" than "new one" on modal

* feat: suppress hybrid cmd trigger typing errors

Author: mifuyutsuki

interactions/ext/hybrid_commands/context.py

@@ -24,7 +24,9 @@
     process_message_payload,
 )
 from interactions.client.mixins.send import SendMixin
+from interactions.client.errors import HTTPException
 from interactions.ext import prefixed_commands as prefixed
+import contextlib
 
 if TYPE_CHECKING:
     from .hybrid_slash import HybridSlashCommand
@@ -175,16 +177,26 @@ def typing(self) -> Typing | DeferTyping:
             return DeferTyping(self._slash_ctx, self.ephemeral)
         return self.channel.typing
 
-    async def defer(self, ephemeral: bool = False) -> None:
+    async def defer(self, ephemeral: bool = False, suppress_error: bool = False) -> None:
         """
         Either defers the response (if used in an interaction) or triggers a typing indicator for 10 seconds (if used for messages).
 
+        ???+ note "Interaction Note"
+            This method's ephemeral settings override the ephemeral settings of `send()`.
+
+            For example, deferring with `ephemeral=True` will make the interaction response ephemeral even with
+            `send(ephemeral=False)`.
+
         Args:
             ephemeral: Should the response be ephemeral? Only applies to responses for interactions.
+            suppress_error: Should errors on deferring be suppressed than raised.
 
         """
         if self._slash_ctx:
-            await self._slash_ctx.defer(ephemeral=ephemeral)
+            await self._slash_ctx.defer(ephemeral=ephemeral, suppress_error=suppress_error)
+        elif suppress_error:
+            with contextlib.suppress(HTTPException):
+                await self.channel.trigger_typing()
         else:
             await self.channel.trigger_typing()
 

interactions/models/internal/context.py

@@ -1,6 +1,7 @@
 import abc
 import datetime
 import re
+import contextlib
 import typing
 from typing_extensions import Self
 
@@ -405,14 +406,28 @@ def gather_options(_options: list[dict[str, typing.Any]]) -> dict[str, typing.An
 
 
 class InteractionContext(BaseInteractionContext, SendMixin):
-    async def defer(self, *, ephemeral: bool = False) -> None:
+    async def defer(self, *, ephemeral: bool = False, suppress_error: bool = False) -> None:
         """
         Defer the interaction.
 
+        Note:
+            This method's ephemeral settings override the ephemeral settings of `send()`.
+
+            For example, deferring with `ephemeral=True` will make the response ephemeral even with
+            `send(ephemeral=False)`.
+
         Args:
             ephemeral: Whether the interaction response should be ephemeral.
+            suppress_error: Should errors on deferring be suppressed than raised.
 
         """
+        if suppress_error:
+            with contextlib.suppress(AlreadyDeferred, AlreadyResponded, HTTPException):
+                await self._defer(ephemeral=ephemeral)
+        else:
+            await self._defer(ephemeral=ephemeral)
+
+    async def _defer(self, *, ephemeral: bool = False) -> None:
         if self.deferred:
             raise AlreadyDeferred("Interaction has already been responded to.")
         if self.responded:
@@ -651,15 +666,29 @@ def from_dict(cls, client: "interactions.Client", payload: dict) -> Self:
         instance.target_type = CommandType(payload["data"]["type"])
         return instance
 
-    async def defer(self, *, ephemeral: bool = False, edit_origin: bool = False) -> None:
+    async def defer(self, *, ephemeral: bool = False, edit_origin: bool = False, suppress_error: bool = False) -> None:
         """
         Defer the interaction.
 
+        Note:
+            This method's ephemeral settings override the ephemeral settings of `send()`.
+
+            For example, deferring with `ephemeral=True` will make the response ephemeral even with
+            `send(ephemeral=False)`.
+
         Args:
             ephemeral: Whether the interaction response should be ephemeral.
             edit_origin: Whether to edit the original message instead of sending a new one.
+            suppress_error: Should errors on deferring be suppressed than raised.
 
         """
+        if suppress_error:
+            with contextlib.suppress(AlreadyDeferred, AlreadyResponded, HTTPException):
+                await self._defer(ephemeral=ephemeral, edit_origin=edit_origin)
+        else:
+            await self._defer(ephemeral=ephemeral, edit_origin=edit_origin)
+
+    async def _defer(self, *, ephemeral: bool = False, edit_origin: bool = False) -> None:
         if self.deferred:
             raise AlreadyDeferred("Interaction has already been responded to.")
         if self.responded:
@@ -745,15 +774,29 @@ def from_dict(cls, client: "interactions.Client", payload: dict) -> Self:
                         instance.values[i] = channel
         return instance
 
-    async def defer(self, *, ephemeral: bool = False, edit_origin: bool = False) -> None:
+    async def defer(self, *, ephemeral: bool = False, edit_origin: bool = False, suppress_error: bool = False) -> None:
         """
         Defer the interaction.
 
+        Note:
+            This method's ephemeral settings override the ephemeral settings of `send()`.
+
+            For example, deferring with `ephemeral=True` will make the response ephemeral even with
+            `send(ephemeral=False)`.
+
         Args:
             ephemeral: Whether the interaction response should be ephemeral.
             edit_origin: Whether to edit the original message instead of sending a new one.
+            suppress_error: Should errors on deferring be suppressed than raised.
 
         """
+        if suppress_error:
+            with contextlib.suppress(AlreadyDeferred, AlreadyResponded, HTTPException):
+                await self._defer(ephemeral=ephemeral, edit_origin=edit_origin)
+        else:
+            await self._defer(ephemeral=ephemeral, edit_origin=edit_origin)
+
+    async def _defer(self, *, ephemeral: bool = False, edit_origin: bool = False) -> None:
         if self.deferred:
             raise AlreadyDeferred("Interaction has already been responded to.")
         if self.responded:
@@ -883,15 +926,29 @@ async def edit(self, message: "Snowflake_Type", **kwargs) -> "interactions.Messa
             await self.defer(edit_origin=True)
         return await super().edit(message, **kwargs)
 
-    async def defer(self, *, ephemeral: bool = False, edit_origin: bool = False) -> None:
+    async def defer(self, *, ephemeral: bool = False, edit_origin: bool = False, suppress_error: bool = False) -> None:
         """
         Defer the interaction.
 
+        Note:
+            This method's ephemeral settings override the ephemeral settings of `send()`.
+
+            For example, deferring with `ephemeral=True` will make the response ephemeral even with
+            `send(ephemeral=False)`.
+
         Args:
             ephemeral: Whether the interaction response should be ephemeral.
             edit_origin: Whether to edit the original message instead of sending a followup.
+            suppress_error: Should errors on deferring be suppressed than raised.
 
         """
+        if suppress_error:
+            with contextlib.suppress(AlreadyDeferred, AlreadyResponded, HTTPException):
+                await self._defer(ephemeral=ephemeral, edit_origin=edit_origin)
+        else:
+            await self._defer(ephemeral=ephemeral, edit_origin=edit_origin)
+
+    async def _defer(self, *, ephemeral: bool = False, edit_origin: bool = False) -> None:
         if self.deferred:
             raise AlreadyDeferred("Interaction has already been responded to.")
         if self.responded: