Run black and isort on codebase

Author: LilSpazJoekp

discord_slash/__init__.py

@@ -9,10 +9,10 @@
 """
 
 from .client import SlashCommand  # noqa: F401
-from .model import SlashCommandOptionType  # noqa: F401
-from .context import SlashContext  # noqa: F401
+from .const import __version__  # noqa: F401
 from .context import ComponentContext  # noqa: F401
+from .context import SlashContext  # noqa: F401
 from .dpy_overrides import ComponentMessage  # noqa: F401
+from .model import SlashCommandOptionType  # noqa: F401
 from .utils import manage_commands  # noqa: F401
 from .utils import manage_components  # noqa: F401
-from .const import __version__  # noqa: F401

discord_slash/client.py

@@ -1,17 +1,20 @@
-import typing
 import inspect
+import typing
+
 from .model import CogBaseCommandObject, CogSubcommandObject
 from .utils import manage_commands
 
 
-def cog_slash(*,
-              name: str = None,
-              description: str = None,
-              guild_ids: typing.List[int] = None,
-              options: typing.List[dict] = None,
-              default_permission: bool = True,
-              permissions: typing.Dict[int, list] = None,
-              connector: dict = None):
+def cog_slash(
+    *,
+    name: str = None,
+    description: str = None,
+    guild_ids: typing.List[int] = None,
+    options: typing.List[dict] = None,
+    default_permission: bool = True,
+    permissions: typing.Dict[int, list] = None,
+    connector: dict = None
+):
     """
     Decorator for Cog to add slash command.\n
     Almost same as :func:`.client.SlashCommand.slash`.
@@ -43,6 +46,7 @@ async def ping(self, ctx: SlashContext):
     :param connector: Kwargs connector for the command. Default ``None``.
     :type connector: dict
     """
+
     def wrapper(cmd):
         desc = description or inspect.getdoc(cmd)
         if options is None:
@@ -58,26 +62,29 @@ def wrapper(cmd):
             "default_permission": default_permission,
             "api_permissions": permissions,
             "connector": connector,
-            "has_subcommands": False
+            "has_subcommands": False,
         }
         return CogBaseCommandObject(name or cmd.__name__, _cmd)
+
     return wrapper
 
 
-def cog_subcommand(*,
-                   base,
-                   subcommand_group=None,
-                   name=None,
-                   description: str = None,
-                   base_description: str = None,
-                   base_desc: str = None,
-                   base_default_permission: bool = True,
-                   base_permissions: typing.Dict[int, list] = None,
-                   subcommand_group_description: str = None,
-                   sub_group_desc: str = None,
-                   guild_ids: typing.List[int] = None,
-                   options: typing.List[dict] = None,
-                   connector: dict = None):
+def cog_subcommand(
+    *,
+    base,
+    subcommand_group=None,
+    name=None,
+    description: str = None,
+    base_description: str = None,
+    base_desc: str = None,
+    base_default_permission: bool = True,
+    base_permissions: typing.Dict[int, list] = None,
+    subcommand_group_description: str = None,
+    sub_group_desc: str = None,
+    guild_ids: typing.List[int] = None,
+    options: typing.List[dict] = None,
+    connector: dict = None
+):
     """
     Decorator for Cog to add subcommand.\n
     Almost same as :func:`.client.SlashCommand.subcommand`.
@@ -138,7 +145,7 @@ def wrapper(cmd):
             "default_permission": base_default_permission,
             "api_permissions": base_permissions,
             "connector": {},
-            "has_subcommands": True
+            "has_subcommands": True,
         }
 
         _sub = {
@@ -149,7 +156,8 @@ def wrapper(cmd):
             "sub_group_desc": subcommand_group_description,
             "guild_ids": guild_ids,
             "api_options": opts,
-            "connector": connector
+            "connector": connector,
         }
         return CogSubcommandObject(base, _cmd, subcommand_group, name or cmd.__name__, _sub)
+
     return wrapper

discord_slash/cog_ext.py

@@ -6,10 +6,8 @@
 from discord.ext import commands
 from discord.utils import snowflake_time
 
-from . import http
-from . import error
-from . import model
-from . dpy_overrides import ComponentMessage
+from . import error, http, model
+from .dpy_overrides import ComponentMessage
 
 
 class InteractionContext:
@@ -34,11 +32,13 @@ class InteractionContext:
     :ivar author: User or Member instance of the command invoke.
     """
 
-    def __init__(self,
-                 _http: http.SlashCommandRequest,
-                 _json: dict,
-                 _discord: typing.Union[discord.Client, commands.Bot],
-                 logger):
+    def __init__(
+        self,
+        _http: http.SlashCommandRequest,
+        _json: dict,
+        _discord: typing.Union[discord.Client, commands.Bot],
+        logger,
+    ):
         self._token = _json["token"]
         self.message = None  # Should be set later.
         self.interaction_id = _json["id"]
@@ -49,10 +49,14 @@ def __init__(self,
         self.responded = False
         self._deferred_hidden = False  # To check if the patch to the deferred response matches
         self.guild_id = int(_json["guild_id"]) if "guild_id" in _json.keys() else None
-        self.author_id = int(_json["member"]["user"]["id"] if "member" in _json.keys() else _json["user"]["id"])
+        self.author_id = int(
+            _json["member"]["user"]["id"] if "member" in _json.keys() else _json["user"]["id"]
+        )
         self.channel_id = int(_json["channel_id"])
         if self.guild:
-            self.author = discord.Member(data=_json["member"], state=self.bot._connection, guild=self.guild)
+            self.author = discord.Member(
+                data=_json["member"], state=self.bot._connection, guild=self.guild
+            )
         elif self.guild_id:
             self.author = discord.User(data=_json["member"]["user"], state=self.bot._connection)
         else:
@@ -61,12 +65,20 @@ def __init__(self,
 
     @property
     def _deffered_hidden(self):
-        warn("`_deffered_hidden` as been renamed to `_deferred_hidden`.", DeprecationWarning, stacklevel=2)
+        warn(
+            "`_deffered_hidden` as been renamed to `_deferred_hidden`.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         return self._deferred_hidden
 
     @_deffered_hidden.setter
     def _deffered_hidden(self, value):
-        warn("`_deffered_hidden` as been renamed to `_deferred_hidden`.", DeprecationWarning, stacklevel=2)
+        warn(
+            "`_deffered_hidden` as been renamed to `_deferred_hidden`.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         self._deferred_hidden = value
 
     @property
@@ -112,18 +124,20 @@ async def defer(self, hidden: bool = False):
         await self._http.post_initial_response(base, self.interaction_id, self._token)
         self.deferred = True
 
-    async def send(self,
-                   content: str = "", *,
-                   embed: discord.Embed = None,
-                   embeds: typing.List[discord.Embed] = None,
-                   tts: bool = False,
-                   file: discord.File = None,
-                   files: typing.List[discord.File] = None,
-                   allowed_mentions: discord.AllowedMentions = None,
-                   hidden: bool = False,
-                   delete_after: float = None,
-                   components: typing.List[dict] = None,
-                   ) -> model.SlashMessage:
+    async def send(
+        self,
+        content: str = "",
+        *,
+        embed: discord.Embed = None,
+        embeds: typing.List[discord.Embed] = None,
+        tts: bool = False,
+        file: discord.File = None,
+        files: typing.List[discord.File] = None,
+        allowed_mentions: discord.AllowedMentions = None,
+        hidden: bool = False,
+        delete_after: float = None,
+        components: typing.List[dict] = None,
+    ) -> model.SlashMessage:
         """
         Sends response of the slash command.
 
@@ -170,14 +184,19 @@ async def send(self,
         if delete_after and hidden:
             raise error.IncorrectFormat("You can't delete a hidden message!")
         if components and not all(comp.get("type") == 1 for comp in components):
-            raise error.IncorrectFormat("The top level of the components list must be made of ActionRows!")
+            raise error.IncorrectFormat(
+                "The top level of the components list must be made of ActionRows!"
+            )
 
         base = {
             "content": content,
             "tts": tts,
             "embeds": [x.to_dict() for x in embeds] if embeds else [],
-            "allowed_mentions": allowed_mentions.to_dict() if allowed_mentions
-            else self.bot.allowed_mentions.to_dict() if self.bot.allowed_mentions else {},
+            "allowed_mentions": allowed_mentions.to_dict()
+            if allowed_mentions
+            else self.bot.allowed_mentions.to_dict()
+            if self.bot.allowed_mentions
+            else {},
             "components": components or [],
         }
         if hidden:
@@ -197,10 +216,7 @@ async def send(self,
                 resp = await self._http.edit(base, self._token, files=files)
                 self.deferred = False
             else:
-                json_data = {
-                    "type": 4,
-                    "data": base
-                }
+                json_data = {"type": 4, "data": base}
                 await self._http.post_initial_response(json_data, self.interaction_id, self._token)
                 if not hidden:
                     resp = await self._http.edit({}, self._token)
@@ -213,11 +229,13 @@ async def send(self,
             for file in files:
                 file.close()
         if not hidden:
-            smsg = model.SlashMessage(state=self.bot._connection,
-                                      data=resp,
-                                      channel=self.channel or discord.Object(id=self.channel_id),
-                                      _http=self._http,
-                                      interaction_token=self._token)
+            smsg = model.SlashMessage(
+                state=self.bot._connection,
+                data=resp,
+                channel=self.channel or discord.Object(id=self.channel_id),
+                _http=self._http,
+                interaction_token=self._token,
+            )
             if delete_after:
                 self.bot.loop.create_task(smsg.delete(delay=delete_after))
             if initial_message:
@@ -238,11 +256,14 @@ class SlashContext(InteractionContext):
     :ivar subcommand_group: Subcommand group of the command.
     :ivar command_id: ID of the command.
     """
-    def __init__(self,
-                 _http: http.SlashCommandRequest,
-                 _json: dict,
-                 _discord: typing.Union[discord.Client, commands.Bot],
-                 logger):
+
+    def __init__(
+        self,
+        _http: http.SlashCommandRequest,
+        _json: dict,
+        _discord: typing.Union[discord.Client, commands.Bot],
+        logger,
+    ):
         self.name = self.command = self.invoked_with = _json["data"]["name"]
         self.args = []
         self.kwargs = {}
@@ -262,20 +283,24 @@ class ComponentContext(InteractionContext):
     :ivar origin_message: The origin message of the component. Not available if the origin message was ephemeral.
     :ivar origin_message_id: The ID of the origin message.
     """
-    def __init__(self,
-                 _http: http.SlashCommandRequest,
-                 _json: dict,
-                 _discord: typing.Union[discord.Client, commands.Bot],
-                 logger):
+
+    def __init__(
+        self,
+        _http: http.SlashCommandRequest,
+        _json: dict,
+        _discord: typing.Union[discord.Client, commands.Bot],
+        logger,
+    ):
         self.custom_id = self.component_id = _json["data"]["custom_id"]
         self.component_type = _json["data"]["component_type"]
         super().__init__(_http=_http, _json=_json, _discord=_discord, logger=logger)
         self.origin_message = None
         self.origin_message_id = int(_json["message"]["id"]) if "message" in _json.keys() else None
 
         if self.origin_message_id and (_json["message"]["flags"] & 64) != 64:
-            self.origin_message = ComponentMessage(state=self.bot._connection, channel=self.channel,
-                                                   data=_json["message"])
+            self.origin_message = ComponentMessage(
+                state=self.bot._connection, channel=self.channel, data=_json["message"]
+            )
 
     async def defer(self, hidden: bool = False, edit_origin: bool = False):
         """
@@ -329,8 +354,13 @@ async def edit_origin(self, **fields):
             _resp["embeds"] = [x.to_dict() for x in embeds]
 
         allowed_mentions = fields.get("allowed_mentions")
-        _resp["allowed_mentions"] = allowed_mentions.to_dict() if allowed_mentions else \
-            self.bot.allowed_mentions.to_dict() if self.bot.allowed_mentions else {}
+        _resp["allowed_mentions"] = (
+            allowed_mentions.to_dict()
+            if allowed_mentions
+            else self.bot.allowed_mentions.to_dict()
+            if self.bot.allowed_mentions
+            else {}
+        )
 
         if not self.responded:
             if files and not self.deferred: