Merge branch 'master' into master

Author: Apocryphon-X

.github/CONTRIBUTING.md

@@ -34,6 +34,11 @@ If the bug report is missing this information then it'll take us longer to fix t
 
 Submitting a pull request is fairly simple, just make sure it focuses on a single aspect and doesn't manage to have scope creep and it's probably good to go. It would be incredibly lovely if the style is consistent to that found in the project. This project follows PEP-8 guidelines (mostly) with a column limit of 125.
 
+## Use of "type: ignore" comments
+In some cases, it might be necessary to ignore type checker warnings for one reason or another.
+If that is that case, it is **required** that a comment is left explaining why you are
+deciding to ignore type checking warnings.
+
 ### Licensing
 
 By submitting a pull request, you agree that; 1) You hold the copyright on all submitted code inside said pull request; 2) You agree to transfer all rights to the owner of this repository, and; 3) If you are found to be in fault with any of the above, we shall not be held responsible in any way after the pull request has been merged.

.github/PULL_REQUEST_TEMPLATE.md

@@ -8,6 +8,7 @@
 
 - [ ] If code changes were made then they have been tested.
     - [ ] I have updated the documentation to reflect the changes.
+- [ ] If `type: ignore` comments were used, a comment is also left explaining why
 - [ ] This PR fixes an issue.
 - [ ] This PR adds something new (e.g. new method or parameters).
 - [ ] This PR is a breaking change (e.g. methods or parameters removed/renamed)

.github/workflows/bandit.yml

@@ -0,0 +1,10 @@
+name: bandit
+on: [pull_request, push]
+jobs:
+  bandit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+      - run: pip install bandit
+      - run: bandit --recursive  --skip B101,B104,B105,B110,B307,B311,B404,B603,B607 .

.github/workflows/mypy.yml

@@ -0,0 +1,12 @@
+name: mypy
+on: [pull_request, push]
+jobs:
+  mypy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+      - run: pip install mypy
+      - run: pip install -r requirements.txt
+      - run: mkdir --parents --verbose .mypy_cache
+      - run: mypy --ignore-missing-imports --install-types --non-interactive . || true

.pylintrc

@@ -0,0 +1,12 @@
+[MESSAGES CONTROL]
+
+disable=protected-access
+
+enable=bad-indentation,line-too-long
+
+
+[FORMAT]
+
+indent-string='    '
+
+max-line-length=120

discord/bot.py

@@ -37,6 +37,7 @@
     Coroutine,
     List,
     Optional,
+    Type,
     TypeVar,
     Union,
 )
@@ -53,6 +54,7 @@
     UserCommand,
     ApplicationCommand,
     ApplicationContext,
+    AutocompleteContext,
     command,
 )
 from .cog import CogMixin
@@ -86,19 +88,23 @@ class ApplicationCommandMixin:
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self._pending_application_commands = []
-        self.application_commands = {}
+        self._application_commands = {}
 
     @property
     def pending_application_commands(self):
         return self._pending_application_commands
 
     @property
     def commands(self) -> List[Union[ApplicationCommand, Any]]:
-        commands = list(self.application_commands.values())
+        commands = self.application_commands
         if self._supports_prefixed_commands:
             commands += self.prefixed_commands
         return commands
 
+    @property
+    def application_commands(self) -> List[ApplicationCommand]:
+        return list(self._application_commands.values())
+
     def add_application_command(self, command: ApplicationCommand) -> None:
         """Adds a :class:`.ApplicationCommand` into the internal list of commands.
 
@@ -112,7 +118,6 @@ def add_application_command(self, command: ApplicationCommand) -> None:
         command: :class:`.ApplicationCommand`
             The command to add.
         """
-
         if self.debug_guilds and command.guild_ids is None:
             command.guild_ids = self.debug_guilds
         self._pending_application_commands.append(command)
@@ -136,7 +141,54 @@ def remove_application_command(
             The command that was removed. If the name is not valid then
             ``None`` is returned instead.
         """
-        return self.application_commands.pop(command.id)
+        return self._application_commands.pop(command.id)
+
+    @property
+    def get_command(self):
+        """Shortcut for :meth:`.get_application_command`.
+        
+        .. note::
+            Overridden in :class:`ext.commands.Bot`.
+        
+        .. versionadded:: 2.0
+        """
+        # TODO: Do something like we did in self.commands for this
+        return self.get_application_command
+
+    def get_application_command(
+        self,
+        name: str,
+        guild_ids: Optional[List[int]] = None,
+        type: Type[ApplicationCommand] = SlashCommand,
+    ) -> Optional[ApplicationCommand]:
+        """Get a :class:`.ApplicationCommand` from the internal list
+        of commands.
+
+        .. versionadded:: 2.0
+
+        Parameters
+        -----------
+        name: :class:`str`
+            The name of the command to get.
+        guild_ids: List[:class:`int`]
+            The guild ids associated to the command to get.
+        type: Type[:class:`.ApplicationCommand`]
+            The type of the command to get. Defaults to :class:`.SlashCommand`.
+
+        Returns
+        --------
+        Optional[:class:`.ApplicationCommand`]
+            The command that was requested. If not found, returns ``None``.
+        """
+
+        for command in self._application_commands.values():
+            if (
+                command.name == name
+                and isinstance(command, type)
+            ):
+                if guild_ids is not None and command.guild_ids != guild_ids:
+                    return
+                return command
 
     async def sync_commands(self) -> None:
         """|coro|
@@ -199,7 +251,7 @@ async def register_commands(self) -> None:
                 type=i["type"],
             )
             cmd.id = i["id"]
-            self.application_commands[cmd.id] = cmd
+            self._application_commands[cmd.id] = cmd
 
             # Permissions (Roles will be converted to IDs just before Upsert for Global Commands)
             global_permissions.append({"id": i["id"], "permissions": cmd.permissions})
@@ -234,7 +286,7 @@ async def register_commands(self) -> None:
                 for i in cmds:
                     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)
                     cmd.id = i["id"]
-                    self.application_commands[cmd.id] = cmd
+                    self._application_commands[cmd.id] = cmd
 
                     # Permissions
                     permissions = [
@@ -325,7 +377,7 @@ async def register_commands(self) -> None:
                     if len(new_cmd_perm["permissions"]) > 10:
                         print(
                             "Command '{name}' has more than 10 permission overrides in guild ({guild_id}).\nwill only use the first 10 permission overrides.".format(
-                                name=self.application_commands[new_cmd_perm["id"]].name,
+                                name=self._application_commands[new_cmd_perm["id"]].name,
                                 guild_id=guild_id,
                             )
                         )
@@ -375,12 +427,14 @@ async def process_application_commands(self, interaction: Interaction) -> None:
             return
 
         try:
-            command = self.application_commands[interaction.data["id"]]
+            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_autocomplete_context(interaction)
+                ctx.command = command
+                return await command.invoke_autocomplete_callback(ctx)
 
             ctx = await self.get_application_context(interaction)
             ctx.command = command
@@ -516,6 +570,37 @@ class be provided, it must be similar enough to
             cls = ApplicationContext
         return cls(self, interaction)
 
+    async def get_autocomplete_context(
+        self, interaction: Interaction, cls=None
+    ) -> AutocompleteContext:
+        r"""|coro|
+
+        Returns the autocomplete context from the interaction.
+
+        This is a more low-level counter-part for :meth:`.process_application_commands`
+        to allow users more fine grained control over the processing.
+
+        Parameters
+        -----------
+        interaction: :class:`discord.Interaction`
+            The interaction to get the invocation context from.
+        cls
+            The factory class that will be used to create the context.
+            By default, this is :class:`.AutocompleteContext`. Should a custom
+            class be provided, it must be similar enough to
+            :class:`.AutocompleteContext`\'s interface.
+
+        Returns
+        --------
+        :class:`.AutocompleteContext`
+            The autocomplete context. The type of this can change via the
+            ``cls`` parameter.
+        """
+        if cls is None:
+            cls = AutocompleteContext
+        return cls(self, interaction)
+
+
 
 class BotBase(ApplicationCommandMixin, CogMixin):
     _supports_prefixed_commands = False

discord/client.py

@@ -1196,7 +1196,7 @@ async def fetch_template(self, code: Union[Template, str]) -> Template:
         data = await self.http.get_template(code)
         return Template(data=data, state=self._connection) # type: ignore
 
-    async def fetch_guild(self, guild_id: int, /) -> Guild:
+    async def fetch_guild(self, guild_id: int, /, *, with_counts=True) -> Guild:
         """|coro|
 
         Retrieves a :class:`.Guild` from an ID.
@@ -1215,6 +1215,12 @@ async def fetch_guild(self, guild_id: int, /) -> Guild:
         guild_id: :class:`int`
             The guild's ID to fetch from.
 
+        with_counts: :class:`bool`
+            Whether to include count information in the guild. This fills the
+            :attr:`.Guild.approximate_member_count` and :attr:`.Guild.approximate_presence_count`
+            fields.
+
+            .. versionadded:: 2.0
         Raises
         ------
         :exc:`.Forbidden`
@@ -1227,7 +1233,7 @@ async def fetch_guild(self, guild_id: int, /) -> Guild:
         :class:`.Guild`
             The guild from the ID.
         """
-        data = await self.http.get_guild(guild_id)
+        data = await self.http.get_guild(guild_id, with_counts = with_counts)
         return Guild(data=data, state=self._connection)
 
     async def create_guild(

discord/colour.py

@@ -333,6 +333,31 @@ def nitro_pink(cls: Type[CT]) -> CT:
         .. versionadded:: 2.0
         """
         return cls(0xf47fff)
+    
+    @classmethod
+    def embed_background(cls: Type[CT], theme: str = "dark") -> CT:
+        """A factory method that returns a :class:`Color` corresponding to the embed colors on discord clients, with a value of 
+        ``0x2F3136`` (dark)
+        ``0xf2f3f5`` (light)
+        ``0x000000`` (amoled).
+        
+        .. versionadded:: 2.0
+        
+        Parameters
+        -----------
+        theme: :class:`str`
+            The theme color to apply, must be one of "dark", "light", or "amoled".
+        """
+        themes_cls = {
+            "dark": 0x2F3136,
+            "light": 0xf2f3f5,
+            "amoled": 0x000000,
+        }
+        
+        if theme not in themes_cls:
+            raise TypeError("Theme must be \"dark\", \"light\", or \"amoled\".")
+        
+        return cls(themes_cls[theme])
 
 
 Color = Colour

discord/commands/commands.py

@@ -450,7 +450,7 @@ def _parse_options(self, params) -> List[Option]:
                 if p_obj.default != inspect.Parameter.empty:
                     option.required = False
 
-            option.default = option.default or p_obj.default
+            option.default = option.default if option.default is not None else p_obj.default
 
             if option.default == inspect.Parameter.empty:
                 option.default = None
@@ -532,7 +532,7 @@ async def _invoke(self, ctx: ApplicationContext) -> None:
         else:
             await self.callback(ctx, **kwargs)
 
-    async def invoke_autocomplete_callback(self, interaction: Interaction):
+    async def invoke_autocomplete_callback(self, ctx: AutocompleteContext):
         values = { i.name: i.default for i in self.options }
 
         for op in interaction.data.get("options", []):
@@ -542,17 +542,25 @@ async def invoke_autocomplete_callback(self, interaction: Interaction):
                     i["name"]:i["value"]
                     for i in interaction.data["options"]
                 })
-                ctx = AutocompleteContext(interaction, command=self, focused=option, value=op.get("value"), options=values)
-                if asyncio.iscoroutinefunction(option.autocomplete):
-                    result = await option.autocomplete(ctx)
+                ctx.command = self
+                ctx.focused = option
+                ctx.value = op.get("value")
+                ctx.options = values
+
+                if len(inspect.signature(option.autocomplete).parameters) == 2:
+                    instance = getattr(option.autocomplete, "__self__", ctx.cog)
+                    result = option.autocomplete(instance, ctx)
                 else:
                     result = option.autocomplete(ctx)
 
+                if asyncio.iscoroutinefunction(option.autocomplete):
+                    result = await result
+                    
                 choices = [
                     o if isinstance(o, OptionChoice) else OptionChoice(o)
                     for o in result
                 ][:25]
-                return await interaction.response.send_autocomplete_result(choices=choices)
+                return await ctx.interaction.response.send_autocomplete_result(choices=choices)
 
 
     def copy(self):
@@ -630,10 +638,11 @@ def __init__(
             for o in kwargs.pop("choices", list())
         ]
         self.default = kwargs.pop("default", None)
+
         if self.input_type == SlashCommandOptionType.integer:
-            minmax_types = (int,)
+            minmax_types = (int, type(None))
         elif self.input_type == SlashCommandOptionType.number:
-            minmax_types = (int, float)
+            minmax_types = (int, float, type(None))
         else:
             minmax_types = (type(None),)
         minmax_typehint = Optional[Union[minmax_types]] # type: ignore
@@ -790,11 +799,11 @@ 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]
+    async def invoke_autocomplete_callback(self, ctx: AutocompleteContext) -> None:
+        option = ctx.interaction.data["options"][0]
         command = find(lambda x: x.name == option["name"], self.subcommands)
-        interaction.data = option
-        await command.invoke_autocomplete_callback(interaction)
+        ctx.interaction.data = option
+        await command.invoke_autocomplete_callback(ctx)
 
 
 class ContextMenuCommand(ApplicationCommand):
@@ -936,7 +945,7 @@ async def _invoke(self, ctx: ApplicationContext) -> None:
 
         if self.cog is not None:
             await self.callback(self.cog, ctx, target)
-        else:
+        else:   
             await self.callback(ctx, target)
 
     def copy(self):