Add support for autocomplete

discord/app/commands.py

@@ -80,7 +80,7 @@ def __init__(self, func: Callable, *args, **kwargs) -> None:
         self.is_subcommand: bool = False
 
         params = OrderedDict(inspect.signature(self.callback).parameters)
-        self.options = self.parse_options(params)
+        self.options: List[Option] = self.parse_options(params)
 
     def parse_options(self, params: OrderedDict) -> List[Option]:
         final_options = []
@@ -167,6 +167,16 @@ async def invoke(self, ctx: InteractionContext) -> None:
                 kwargs[o.name] = o.default
         await self.callback(ctx, **kwargs)
 
+    async def invoke_autocomplete_callback(self, interaction):
+        for op in interaction.data.get("options", []):
+            if op.get("focused", False):
+                option = find(lambda o: o.name == op["name"], self.options)
+                result = await option.autocomplete_callback(interaction, op.get("value", None))
+                choices = [
+                    o if isinstance(o, OptionChoice) else OptionChoice(o)
+                    for o in result
+                ]
+                await interaction.response.send_autocomplete_result(choices = choices)
 
 class Option:
     def __init__(
@@ -183,6 +193,11 @@ def __init__(
             for o in kwargs.pop("choices", list())
         ]
         self.default = kwargs.pop("default", None)
+        self.autocomplete_callback = kwargs.pop("autocomplete", None)
+        if self.autocomplete_callback:
+            if not asyncio.iscoroutinefunction(self.autocomplete_callback):
+                raise TypeError("Autocomplete callback must be a coroutine.")
+
 
     def to_dict(self) -> Dict:
         return {
@@ -191,6 +206,7 @@ def to_dict(self) -> Dict:
             "type": self.input_type.value,
             "required": self.required,
             "choices": [c.to_dict() for c in self.choices],
+            "autocomplete": bool(self.autocomplete_callback)
         }
 
     def __repr__(self):

discord/bot.py

@@ -42,7 +42,7 @@
 )
 from .errors import Forbidden
 from .interactions import Interaction
-
+from .enums import InteractionType
 
 def command(cls=SlashCommand, **attrs):
     """A decorator that transforms a function into an :class:`.ApplicationCommand`. More specifically,
@@ -240,13 +240,19 @@ async def handle_interaction(self, interaction: Interaction) -> None:
         interaction: :class:`discord.Interaction`
             The interaction to process
         """
+        if interaction.type not in (InteractionType.application_command, InteractionType.auto_complete):
+            return
+
         try:
             command = self.app_commands[interaction.data["id"]]
         except KeyError:
             self.dispatch("unknown_command", interaction)
         else:
-            context = await self.get_application_context(interaction)
-            await command.invoke(context)
+            if interaction.type == InteractionType.application_command:
+                context = await self.get_application_context(interaction)
+                await command.invoke(context)
+            else:
+                await command.invoke_autocomplete_callback(interaction)
 
     def slash_command(self, **kwargs):
         """A shortcut decorator that invokes :func:`.ApplicationCommandMixin.command` and adds it to

discord/interactions.py

@@ -61,6 +61,7 @@
     from .ui.view import View
     from .channel import VoiceChannel, StageChannel, TextChannel, CategoryChannel, StoreChannel, PartialMessageable
     from .threads import Thread
+    from .app import OptionChoice
 
     InteractionChannel = Union[
         VoiceChannel, StageChannel, TextChannel, CategoryChannel, StoreChannel, Thread, PartialMessageable
@@ -677,6 +678,49 @@ async def edit_message(
 
         self._responded = True
 
+    async def send_autocomplete_result(
+        self,
+        *,
+        choices: List[OptionChoice],
+    ) -> None:
+        """|coro|
+
+        Responds to this interaction by sending the autocomplete choices.
+
+        Parameters
+        -----------
+        choices: List[:class:`OptionChoice`]
+            A list of choices.  
+
+        Raises
+        -------
+        HTTPException
+            Sending the result failed.
+        InteractionResponded
+            This interaction has already been responded to before.
+        """
+        if self._responded:
+            raise InteractionResponded(self._parent)
+
+        parent = self._parent
+
+        if parent.type is not InteractionType.auto_complete:
+            return
+
+        payload = {
+            "choices": [c.to_dict() for c in choices]
+        }
+
+        adapter = async_context.get()
+        await adapter.create_interaction_response(
+            parent.id,
+            parent.token,
+            session=parent._session,
+            type=InteractionResponseType.auto_complete_result.value,
+            data=payload,
+        )
+
+        self._responded = True
 
 class _InteractionMessageState:
     __slots__ = ('_parent', '_interaction')