Remove duplicate bot methods

Author: Dorukyum

discord/ext/commands/bot.py

@@ -173,116 +173,6 @@ async def on_command_error(self, context: Context, exception: errors.CommandErro
         print(f'Ignoring exception in command {context.command}:', file=sys.stderr)
         traceback.print_exception(type(exception), exception, exception.__traceback__, file=sys.stderr)
 
-    # global check registration
-
-    def check(self, func: T) -> T:
-        r"""A decorator that adds a global check to the bot.
-
-        A global check is similar to a :func:`.check` that is applied
-        on a per command basis except it is run before any command checks
-        have been verified and applies to every command the bot has.
-
-        .. note::
-
-            This function can either be a regular function or a coroutine.
-
-        Similar to a command :func:`.check`\, this takes a single parameter
-        of type :class:`.Context` and can only raise exceptions inherited from
-        :exc:`.CommandError`.
-
-        Example
-        ---------
-
-        .. code-block:: python3
-
-            @bot.check
-            def check_commands(ctx):
-                return ctx.command.qualified_name in allowed_commands
-
-        """
-        # T was used instead of Check to ensure the type matches on return
-        self.add_check(func)  # type: ignore
-        return func
-
-    def add_check(self, func: Check, *, call_once: bool = False) -> None:
-        """Adds a global check to the bot.
-
-        This is the non-decorator interface to :meth:`.check`
-        and :meth:`.check_once`.
-
-        Parameters
-        -----------
-        func
-            The function that was used as a global check.
-        call_once: :class:`bool`
-            If the function should only be called once per
-            :meth:`.invoke` call.
-        """
-
-        if call_once:
-            self._check_once.append(func)
-        else:
-            self._checks.append(func)
-
-    def remove_check(self, func: Check, *, call_once: bool = False) -> None:
-        """Removes a global check from the bot.
-
-        This function is idempotent and will not raise an exception
-        if the function is not in the global checks.
-
-        Parameters
-        -----------
-        func
-            The function to remove from the global checks.
-        call_once: :class:`bool`
-            If the function was added with ``call_once=True`` in
-            the :meth:`.Bot.add_check` call or using :meth:`.check_once`.
-        """
-        l = self._check_once if call_once else self._checks
-
-        try:
-            l.remove(func)
-        except ValueError:
-            pass
-
-    def check_once(self, func: CFT) -> CFT:
-        r"""A decorator that adds a "call once" global check to the bot.
-
-        Unlike regular global checks, this one is called only once
-        per :meth:`.invoke` call.
-
-        Regular global checks are called whenever a command is called
-        or :meth:`.Command.can_run` is called. This type of check
-        bypasses that and ensures that it's called only once, even inside
-        the default help command.
-
-        .. note::
-
-            When using this function the :class:`.Context` sent to a group subcommand
-            may only parse the parent command and not the subcommands due to it
-            being invoked once per :meth:`.Bot.invoke` call.
-
-        .. note::
-
-            This function can either be a regular function or a coroutine.
-
-        Similar to a command :func:`.check`\, this takes a single parameter
-        of type :class:`.Context` and can only raise exceptions inherited from
-        :exc:`.CommandError`.
-
-        Example
-        ---------
-
-        .. code-block:: python3
-
-            @bot.check_once
-            def whitelist(ctx):
-                return ctx.message.author.id in my_whitelist
-
-        """
-        self.add_check(func, call_once=True)
-        return func
-
     async def can_run(self, ctx: Context, *, call_once: bool = False) -> bool:
         data = self._check_once if call_once else self._checks
 
@@ -292,109 +182,6 @@ async def can_run(self, ctx: Context, *, call_once: bool = False) -> bool:
         # type-checker doesn't distinguish between functions and methods
         return await discord.utils.async_all(f(ctx) for f in data)  # type: ignore
 
-    async def is_owner(self, user: discord.User) -> bool:
-        """|coro|
-
-        Checks if a :class:`~discord.User` or :class:`~discord.Member` is the owner of
-        this bot.
-
-        If an :attr:`owner_id` is not set, it is fetched automatically
-        through the use of :meth:`~.Bot.application_info`.
-
-        .. versionchanged:: 1.3
-            The function also checks if the application is team-owned if
-            :attr:`owner_ids` is not set.
-
-        Parameters
-        -----------
-        user: :class:`.abc.User`
-            The user to check for.
-
-        Returns
-        --------
-        :class:`bool`
-            Whether the user is the owner.
-        """
-
-        if self.owner_id:
-            return user.id == self.owner_id
-        elif self.owner_ids:
-            return user.id in self.owner_ids
-        else:
-
-            app = await self.application_info()  # type: ignore
-            if app.team:
-                self.owner_ids = ids = {m.id for m in app.team.members}
-                return user.id in ids
-            else:
-                self.owner_id = owner_id = app.owner.id
-                return user.id == owner_id
-
-    def before_invoke(self, coro: CFT) -> CFT:
-        """A decorator that registers a coroutine as a pre-invoke hook.
-
-        A pre-invoke hook is called directly before the command is
-        called. This makes it a useful function to set up database
-        connections or any type of set up required.
-
-        This pre-invoke hook takes a sole parameter, a :class:`.Context`.
-
-        .. note::
-
-            The :meth:`~.Bot.before_invoke` and :meth:`~.Bot.after_invoke` hooks are
-            only called if all checks and argument parsing procedures pass
-            without error. If any check or argument parsing procedures fail
-            then the hooks are not called.
-
-        Parameters
-        -----------
-        coro: :ref:`coroutine <coroutine>`
-            The coroutine to register as the pre-invoke hook.
-
-        Raises
-        -------
-        TypeError
-            The coroutine passed is not actually a coroutine.
-        """
-        if not asyncio.iscoroutinefunction(coro):
-            raise TypeError('The pre-invoke hook must be a coroutine.')
-
-        self._before_invoke = coro
-        return coro
-
-    def after_invoke(self, coro: CFT) -> CFT:
-        r"""A decorator that registers a coroutine as a post-invoke hook.
-
-        A post-invoke hook is called directly after the command is
-        called. This makes it a useful function to clean-up database
-        connections or any type of clean up required.
-
-        This post-invoke hook takes a sole parameter, a :class:`.Context`.
-
-        .. note::
-
-            Similar to :meth:`~.Bot.before_invoke`\, this is not called unless
-            checks and argument parsing procedures succeed. This hook is,
-            however, **always** called regardless of the internal command
-            callback raising an error (i.e. :exc:`.CommandInvokeError`\).
-            This makes it ideal for clean-up scenarios.
-
-        Parameters
-        -----------
-        coro: :ref:`coroutine <coroutine>`
-            The coroutine to register as the post-invoke hook.
-
-        Raises
-        -------
-        TypeError
-            The coroutine passed is not actually a coroutine.
-        """
-        if not asyncio.iscoroutinefunction(coro):
-            raise TypeError('The post-invoke hook must be a coroutine.')
-
-        self._after_invoke = coro
-        return coro
-
 
     # cogs