Merge branch 'master' into master

Author: Lulalaby

.github/workflows/bypass-review.yml

@@ -15,3 +15,5 @@ docs/crowdin.py
 *.flac
 *.mo
 .idea/
+.vs/slnx.sqlite
+env/

.gitignore

@@ -45,7 +45,7 @@
 
 from .client import Client
 from .shard import AutoShardedClient
-from .utils import MISSING, get, async_all
+from .utils import MISSING, get, find, async_all
 from .commands import (
     SlashCommand,
     SlashCommandGroup,
@@ -59,6 +59,7 @@
 
 from .errors import Forbidden, DiscordException
 from .interactions import Interaction
+from .enums import InteractionType
 
 CoroFunc = Callable[..., Coroutine[Any, Any, Any]]
 CFT = TypeVar('CFT', bound=CoroFunc)
@@ -86,7 +87,7 @@ def pending_application_commands(self):
         return self._pending_application_commands
 
     @property
-    def commands(self) -> List[Union[ApplicationCommand, ...]]:
+    def commands(self) -> List[Union[ApplicationCommand, Any]]:
         commands = list(self.application_commands.values())
         if self._supports_prefixed_commands:
             commands += self.prefixed_commands
@@ -188,7 +189,7 @@ async def register_commands(self) -> None:
             cmd = get(
                 self.pending_application_commands,
                 name=i["name"],
-                description=i["description"],
+                guild_ids=None,
                 type=i["type"],
             )
             self.application_commands[i["id"]] = cmd
@@ -224,12 +225,7 @@ async def register_commands(self) -> None:
                 raise
             else:
                 for i in cmds:
-                    cmd = get(
-                        self.pending_application_commands,
-                        name=i["name"],
-                        description=i["description"],
-                        type=i["type"],
-                    )
+                    cmd = find(lambda cmd: cmd.name == i["name"] and cmd.type == i["type"] and int(i["guild_id"]) in cmd.guild_ids, self.pending_application_commands)
                     self.application_commands[i["id"]] = cmd
 
                     # Permissions
@@ -364,14 +360,20 @@ async def process_application_commands(self, interaction: Interaction) -> None:
         interaction: :class:`discord.Interaction`
             The interaction to process
         """
-        if not interaction.is_command():
+        if interaction.type not in (
+            InteractionType.application_command, 
+            InteractionType.auto_complete
+        ):
             return
 
         try:
             command = self.application_commands[interaction.data["id"]]
         except KeyError:
             self.dispatch("unknown_command", interaction)
         else:
+            if interaction.type is InteractionType.auto_complete:
+                return await command.invoke_autocomplete_callback(interaction)
+            
             ctx = await self.get_application_context(interaction)
             ctx.command = command
             self.dispatch("application_command", ctx)
@@ -456,7 +458,7 @@ def command(self, **kwargs):
 
         .. note::
 
-            This decorator is overridden by :class:`commands.Bot`.
+            This decorator is overridden by :class:`discord.ext.commands.Bot`.
 
         .. versionadded:: 2.0
 
@@ -569,18 +571,16 @@ async def on_application_command_error(
 
         This only fires if you do not specify any listeners for command error.
         """
-        # TODO
-        # if self.extra_events.get('on_application_command_error', None):
-        #     return
+        if self.extra_events.get('on_application_command_error', None):
+            return
 
         command = context.command
         if command and command.has_error_handler():
             return
 
-        # TODO
-        # cog = context.cog
-        # if cog and cog.has_error_handler():
-        #     return
+        cog = context.cog
+        if cog and cog.has_error_handler():
+            return
 
         print(f"Ignoring exception in command {context.command}:", file=sys.stderr)
         traceback.print_exception(

discord/bot.py

@@ -30,7 +30,7 @@
 import functools
 import inspect
 from collections import OrderedDict
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
 
 from ..enums import SlashCommandOptionType, ChannelType
 from ..member import Member
@@ -60,6 +60,9 @@
     "MessageCommand",
 )
 
+if TYPE_CHECKING: 
+    from ..interactions import Interaction
+
 def wrap_callback(coro):
     @functools.wraps(coro)
     async def wrapped(*args, **kwargs):
@@ -351,7 +354,7 @@ def __init__(self, func: Callable, *args, **kwargs) -> None:
         self.cog = None
 
         params = self._get_signature_parameters()
-        self.options = self._parse_options(params)
+        self.options: List[Option] = self._parse_options(params)
 
         try:
             checks = func.__commands_checks__
@@ -418,6 +421,7 @@ def _parse_options(self, params) -> List[Option]:
 
             if option.name is None:
                 option.name = p_name
+            option._parameter_name = p_name
 
             final_options.append(option)
 
@@ -476,17 +480,28 @@ async def _invoke(self, ctx: ApplicationContext) -> None:
             elif op.input_type == SlashCommandOptionType.string and op._converter is not None:
                 arg = await op._converter.convert(ctx, arg)
 
-            kwargs[op.name] = arg
+            kwargs[op._parameter_name] = arg
 
         for o in self.options:
-            if o.name not in kwargs:
-                kwargs[o.name] = o.default
+            if o._parameter_name not in kwargs:
+                kwargs[o._parameter_name] = o.default
 
         if self.cog is not None:
             await self.callback(self.cog, ctx, **kwargs)
         else:
             await self.callback(ctx, **kwargs)
 
+    async def invoke_autocomplete_callback(self, interaction: 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(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)
+
     def qualified_name(self):
         return self.name
 
@@ -581,13 +596,21 @@ def __init__(
         if not (isinstance(self.max_value, minmax_types) or self.min_value is None):
             raise TypeError(f"Expected {minmax_typehint} for max_value, got \"{type(self.max_value).__name__}\"")
 
+        self.autocomplete = kwargs.pop("autocomplete", None)
+        if (
+            self.autocomplete and 
+            not asyncio.iscoroutinefunction(self.autocomplete)
+        ):
+            raise TypeError("Autocomplete callback must be a coroutine.")
+
     def to_dict(self) -> Dict:
         as_dict = {
             "name": self.name,
             "description": self.description,
             "type": self.input_type.value,
             "required": self.required,
             "choices": [c.to_dict() for c in self.choices],
+            "autocomplete": bool(self.autocomplete)
         }
         if self.channel_types:
             as_dict["channel_types"] = [t.value for t in self.channel_types]
@@ -722,6 +745,13 @@ async def _invoke(self, ctx: ApplicationContext) -> None:
         ctx.interaction.data = option
         await command.invoke(ctx)
 
+    async def invoke_autocomplete_callback(self, interaction: Interaction) -> None:
+        option = interaction.data["options"][0]
+        command = find(lambda x: x.name == option["name"], self.subcommands)
+        interaction.data = option
+        await command.invoke_autocomplete_callback(interaction)
+
+
 class ContextMenuCommand(ApplicationCommand):
     r"""A class that implements the protocol for context menu commands.
 

discord/commands/commands.py

@@ -22,6 +22,7 @@
 FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 """
+from __future__ import annotations
 
 from typing import TYPE_CHECKING, Optional, Union
 
@@ -31,6 +32,9 @@
     import discord
     from discord.state import ConnectionState
 
+    from .commands import ApplicationCommand
+    from ..cog import Cog
+
 from ..guild import Guild
 from ..interactions import Interaction, InteractionResponse
 from ..member import Member
@@ -63,7 +67,7 @@ class ApplicationContext(discord.abc.Messageable):
     def __init__(self, bot: "discord.Bot", interaction: Interaction):
         self.bot = bot
         self.interaction = interaction
-        self.command = None
+        self.command: ApplicationCommand = None  # type: ignore
         self._state: ConnectionState = self.interaction._state
 
     async def _get_channel(self) -> discord.abc.Messageable:
@@ -130,3 +134,11 @@ async def delete(self):
     @property
     def edit(self):
         return self.interaction.edit_original_message
+
+    @property
+    def cog(self) -> Optional[Cog]:
+        """Optional[:class:`.Cog`]: Returns the cog associated with this context's command. None if it does not exist."""
+        if self.command is None:
+            return None
+       
+        return self.command.cog

discord/commands/context.py

@@ -596,6 +596,13 @@ def __int__(self):
         return self.value
 
 
+class ApplicationType(Enum):
+    game = 1
+    music = 2
+    ticketed_events = 3
+    guild_role_subscriptions = 4
+
+
 class StagePrivacyLevel(Enum):
     public = 1
     closed = 2
@@ -642,7 +649,7 @@ def from_datatype(cls, datatype):
         if issubclass(datatype, float):
             return cls.number
 
-        if datatype.__name__ == "Member":
+        if datatype.__name__ in ["Member", "User"]:
             return cls.user
         if datatype.__name__ in [
             "GuildChannel", "TextChannel",
@@ -660,22 +667,40 @@ def from_datatype(cls, datatype):
 
 
 class EmbeddedActivity(Enum):
+    awkword = 879863881349087252
     betrayal = 773336526917861400
-    chess    = 832012586023256104
-    chess_dev = 832012774040141894
+    cg2_qa = 832012815819604009
+    cg2_staging = 832012730599735326
+    cg3_dev = 832012682520428625
+    cg3_prod = 832013003968348200
+    cg3_qa = 832012894068801636
+    cg3_staging = 832012938398400562
+    cg4_dev = 832013108234289153
+    cg4_prod = 832025144389533716
+    cg4_qa = 832025114077298718
+    cg4_staging = 832025061657280566
+    chess_in_the_park_dev = 832012586023256104
+    chess_in_the_park = 832012774040141894
+    decoders_dev = 891001866073296967
     doodle_crew = 878067389634314250
-    fishing  = 814288819477020702
+    doodle_crew_dev = 878067427668275241
+    fishington = 814288819477020702
     letter_tile = 879863686565621790
-    poker    = 755827207812677713
+    pn_staging = 763116274876022855
+    poker_night = 755827207812677713
+    poker_qa = 801133024841957428
+    putts = 832012854282158180
+    sketchy_artist = 879864070101172255
+    sketchy_artist_dev = 879864104980979792
     spell_cast = 852509694341283871
     watch_together = 880218394199220334
     watch_together_dev = 880218832743055411
-    word_snack = 879863976006127627
-    youtube  = 755600276941176913
+    word_snacks = 879863976006127627
+    word_snacks_dev = 879864010126786570
+    youtube_together = 755600276941176913 
 
 T = TypeVar('T')
 
-
 def create_unknown_value(cls: Type[T], val: Any) -> T:
     value_cls = cls._enum_value_cls_  # type: ignore
     name = f'unknown_{val}'

discord/enums.py

@@ -559,7 +559,9 @@ async def filter_commands(self, commands, *, sort=False, key=None):
         if sort and key is None:
             key = lambda c: c.name
 
-        iterator = commands if self.show_hidden else filter(lambda c: not c.hidden, commands)
+        # Ignore Application Commands cause they dont have hidden/docs
+        prefix_commands = [command for command in commands if not isinstance(command, discord.commands.ApplicationCommand)]
+        iterator = prefix_commands if self.show_hidden else filter(lambda c: not c.hidden, prefix_commands)
 
         if self.verify_checks is False:
             # if we do not need to verify the checks then we can just