async def reinvoke(self, *, call_hooks=False, restart=True):
cmd = self.command<EOL>view = self.view<EOL>if cmd is None:<EOL><INDENT>raise ValueError('<STR_LIT>')<EOL><DEDENT>index, previous = view.index, view.previous<EOL>invoked_with = self.invoked_with<EOL>invoked_subcommand = self.invoked_subcommand<EOL>subcommand_passed = self.subcommand_passed<EOL>if restart:<EOL><INDENT>to_call = cmd.root_parent or cmd<EOL>view.index = len(self.prefix)<EOL>view.previous = <NUM_LIT:0><EOL>view.get_word() <EOL><DEDENT>else:<EOL><INDENT>to_call = cmd<EOL><DEDENT>try:<EOL><INDENT>await to_call.reinvoke(self, call_hooks=call_hooks)<EOL><DEDENT>finally:<EOL><INDENT>self.command = cmd<EOL>view.index = index<EOL>view.previous = previous<EOL>self.invoked_with = invoked_with<EOL>self.invoked_subcommand = invoked_subcommand<EOL>self.subcommand_passed = subcommand_passed<EOL><DEDENT>
|coro|

        Calls the command again.

        This is similar to :meth:`~.Context.invoke` except that it bypasses
        checks, cooldowns, and error handlers.

        .. note::

            If you want to bypass :exc:`.UserInputError` derived exceptions,
            it is recommended to use the regular :meth:`~.Context.invoke`
            as it will work more naturally. After all, this will end up
            using the old arguments the user has used and will thus just
            fail again.

        Parameters
        ------------
        call_hooks: :class:`bool`
            Whether to call the before and after invoke hooks.
        restart: :class:`bool`
            Whether to start the call chain from the very beginning
            or where we left off (i.e. the command that caused the error).
            The default is to start where we left off.